taosdata / TDengine / #4918

coverage: 65.916% (+0.5%) from 65.42%
#4918

push

travis-ci

web-flow 
merge: from main to 3.0 branch #34215

16 of 22 new or added lines in 3 files covered. (72.73%)

788 existing lines in 116 files now uncovered.

204221 of 309822 relevant lines covered (65.92%)

126504701.11 hits per line

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

84.69
/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) {




648,979,690✔





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;




648,979,690✔





86



#endif










87



}










88












89



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




64,693✔





90



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




64,693✔





91



    SWITCH_ORDER(pCtx[i].order);




×







92



  }










93



}




64,693✔





94












95



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




688,247,731✔





96



  int32_t     code = TSDB_CODE_SUCCESS;




688,247,731✔





97



  STimeWindow w = {0};




688,247,731✔





98












99



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










100



  if (pInterval->interval == 0) {




688,438,729✔





101



    *overlap = false;




639,717,127✔





102



    return code;




639,780,183✔





103



  }










104












105



  if (order == TSDB_ORDER_ASC) {




48,583,383✔





106



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




46,599,157✔





107



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




46,560,390✔





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) {




46,539,400✔





113



      *overlap = true;




36,650,120✔





114



      return code;




36,650,252✔





115



    }










116












117



    while (1) {










118



      getNextTimeWindow(pInterval, &w, order);




9,944,103✔





119



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




9,964,416✔





120



        break;




9,708,018✔





121



      }










122












123



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




255,921✔





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) {




255,921✔





128



        *overlap = true;




255,921✔





129



        return code;




255,921✔





130



      }










131



    }










132



  } else {










133



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




1,984,226✔





134



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




1,983,880✔





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) {




1,984,489✔





140



      *overlap = true;




1,541,342✔





141



      return code;




1,541,342✔





142



    }










143












144



    while (1) {










145



      getNextTimeWindow(pInterval, &w, order);




443,490✔





146



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




443,490✔





147



        break;




440,988✔





148



      }










149












150



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




2,502✔





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,502✔





155



        *overlap = true;




2,502✔





156



        return code;




2,502✔





157



      }










158



    }










159



  }










160












161



  *overlap = false;




10,149,006✔





162



  return code;




10,148,106✔





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) {




164,653,110✔





167



  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {




164,653,110✔





168



    return NULL;




×







169



  }










170












171



  int64_t buf[2] = {0};




164,699,271✔





172



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




164,665,249✔





173












174



  STableScanInfo* pTableScanInfo = pOperator->info;




164,652,435✔





175












176



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




164,706,860✔





177



                                                               buf, GET_RES_WINDOW_KEY_LEN(sizeof(groupId)));










178












179



  if (p1 == NULL) {




164,747,300✔





180



    return NULL;




56,144,563✔





181



  }










182












183



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




108,602,737✔





184



  if (NULL == *pPage) {




108,603,770✔





185



    return NULL;




×







186



  }










187












188



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




108,606,456✔





189



}










190












191



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




11,633,998✔





192



  if (NULL == pTableScanInfo->pIgnoreTables) {




11,633,998✔





193



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




1,327,939✔





194



    pTableScanInfo->pIgnoreTables =




1,327,939✔





195



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




1,328,545✔





196



    if (NULL == pTableScanInfo->pIgnoreTables) {




1,327,939✔





197



      return terrno;




×







198



    }










199



  }










200












201



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




11,633,998✔





202



                                sizeof(pTableScanInfo->scanTimes));










203



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




11,632,786✔





204



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




×







205



    return tempRes;




×







206



  }










207



  return TSDB_CODE_SUCCESS;




11,632,786✔





208



}










209












210



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




756,316,764✔





211



  STableScanInfo* pTableScanInfo = pOperator->info;




756,316,764✔





212



  int32_t         code = TSDB_CODE_SUCCESS;




756,645,875✔





213












214



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




756,645,875✔





215



    return TSDB_CODE_SUCCESS;




591,659,821✔





216



  }










217












218



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




164,616,974✔





219












220



  SFilePage*  pPage = NULL;




164,720,577✔





221



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




164,672,749✔





222












223



  if (pRow == NULL) {




164,722,140✔





224



    return TSDB_CODE_SUCCESS;




56,116,261✔





225



  }










226












227



  bool notLoadBlock = true;




108,605,879✔





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;




96,969,161✔





236



      break;




96,969,161✔





237



    }










238



  }










239












240



  // release buffer pages










241



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




108,331,550✔





242












243



  if (notLoadBlock) {




108,592,184✔





244



    *status = FUNC_DATA_REQUIRED_NOT_LOAD;




11,632,786✔





245



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




11,632,584✔





246



  }










247












248



  return code;




108,518,538✔





249



}










250












251



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




9,309,707✔





252



                                  int32_t numOfRows, bool* keep) {










253



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




9,309,707✔





254



    *keep = true;




×







255



    return TSDB_CODE_SUCCESS;




×







256



  }










257












258



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




9,309,707✔





259



}










260












261



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




163,430,387✔





262



                              bool* pLoad) {










263



  SStorageAPI* pAPI = &pTaskInfo->storageAPI;




163,430,387✔





264



  bool         allColumnsHaveAgg = true;




163,438,551✔





265



  bool         hasNullSMA = false;




163,470,363✔





266



  if (pLoad != NULL) {




163,441,326✔





267



    *pLoad = false;




163,488,746✔





268



  }










269












270



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




163,437,353✔





271



                                                               &hasNullSMA);










272



  if (code != TSDB_CODE_SUCCESS) {




163,350,599✔





273



    return code;




×







274



  }










275












276



  if (!allColumnsHaveAgg || hasNullSMA) {




163,350,599✔





277



    *pLoad = false;




148,433,377✔





278



  } else {










279



    *pLoad = true;




14,917,222✔





280



  }










281












282



  return code;




163,345,152✔





283



}










284












285



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




813,192,362✔





286



                                  int32_t rows) {










287



  int32_t    code = 0;




813,192,362✔





288



  SExprSupp* pSup = &pTableScanInfo->pseudoSup;




813,192,362✔





289



  if (pSup->numOfExprs > 0) {




813,620,477✔





290



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




327,494,628✔





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) {




327,457,152✔





294



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




60✔





295



      code = 0;




×







296



    }










297



  }










298












299



  return code;




813,259,996✔





300



}










301












302



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




1,319,063,973✔





303



  SLimit*     pLimit = &pLimitInfo->limit;




1,319,063,973✔





304



  const char* id = GET_TASKID(pTaskInfo);




1,319,189,107✔





305












306



  if (pLimitInfo->remainOffset > 0) {




1,319,322,027✔





307



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




5,027,894✔





308



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




2,502,291✔





309



      blockDataEmpty(pBlock);




2,502,291✔





310



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




2,502,291✔





311



      return false;




2,502,291✔





312



    } else {










313



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




2,525,603✔





314



      if (code != TSDB_CODE_SUCCESS) {




2,525,603✔





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,525,603✔





320



    }










321



  }










322












323



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




1,316,660,409✔





324



    // limit the output rows










325



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




28,116,214✔





326



    blockDataKeepFirstNRows(pBlock, keep);




28,112,965✔





327












328



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




28,108,238✔





329



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




28,113,969✔





330



    return true;




28,105,379✔





331



  }










332












333



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




1,288,480,883✔





334



  return false;




1,288,577,100✔





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,




793,418,574✔





342



                             uint32_t* status) {










343



  int32_t        code = TSDB_CODE_SUCCESS;




793,418,574✔





344



  int32_t        lino = 0;




793,418,574✔





345



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




793,418,574✔





346



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




793,699,632✔





347



  bool           loadSMA = false;




793,500,981✔





348












349



  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;




793,500,981✔





350












351



  pCost->totalBlocks += 1;




793,401,391✔





352



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




793,502,245✔





353



  *status = pTableScanInfo->dataBlockLoadFlag;




793,276,607✔





354












355



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




793,509,735✔





356



    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




104,988,436✔





357



  } else {










358



    bool overlap = false;




688,165,281✔





359



    int  ret =










360



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




688,050,415✔





361



    if (ret != TSDB_CODE_SUCCESS) {




688,205,890✔





362



      return ret;




×







363



    }










364



    if (overlap) {




688,205,890✔





365



      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




38,440,517✔





366



    }










367



  }










368












369



  SDataBlockInfo* pBlockInfo = &pBlock->info;




793,561,860✔





370



  taosMemoryFreeClear(pBlock->pBlockAgg);




793,540,883✔





371












372



  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {




793,525,089✔





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) {




793,136,364✔





380



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




27,862,846✔





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,875,688✔





384



    pCost->skipBlocks += 1;




27,875,689✔





385



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




27,877,997✔





386



    return code;




27,859,462✔





387



  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {




765,272,377✔





388



    pCost->loadBlockStatis += 1;




58,441,480✔





389



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




58,438,482✔





390



    bool success = true;




58,438,482✔





391



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




58,436,024✔





392



    if (code) {




58,409,768✔





393



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




×







394



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




×







395



      QUERY_CHECK_CODE(code, lino, _end);




13,550✔





396



    }










397












398



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




58,422,423✔





399



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




5,607,515✔





400



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










401



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




5,607,515✔





402



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




5,607,515✔





403



      return code;




5,607,515✔





404



    } else {










405



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




52,814,908✔





406



      *status = FUNC_DATA_REQUIRED_DATA_LOAD;




52,835,058✔





407



    }










408



  }










409












410



  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {




759,674,556✔





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)) {




759,664,704✔





418



    bool success = true;




105,009,420✔





419



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




104,981,807✔





420



    if (code) {




104,884,310✔





421



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




×







422



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




×







423



      QUERY_CHECK_CODE(code, lino, _end);




95,792✔





424



    }










425












426



    if (success) {




104,980,102✔





427



      size_t size = taosArrayGetSize(pBlock->pDataBlock);




9,309,707✔





428



      bool   keep = false;




9,309,707✔





429



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




9,309,707✔





430



      if (code) {




9,309,707✔





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) {




9,309,707✔





437



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




3,296,293✔





438



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










439



        pCost->filterOutBlocks += 1;




3,296,293✔





440



        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;




3,296,293✔





441



        taosMemoryFreeClear(pBlock->pBlockAgg);




3,296,293✔





442












443



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




3,296,293✔





444



        return TSDB_CODE_SUCCESS;




3,296,293✔





445



      }










446



    }










447



  }










448












449



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










450



  taosMemoryFreeClear(pBlock->pBlockAgg);




756,564,602✔





451












452



  // try to filter data block according to current results










453



  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);




756,343,703✔





454



  if (code) {




756,360,931✔






UNCOV

455



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




×







456



    QUERY_CHECK_CODE(code, lino, _end);




×







457



  }










458












459



  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




756,360,931✔





460



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




11,633,392✔





461



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










462



    pCost->skipBlocks += 1;




11,634,402✔





463



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




11,634,402✔





464












465



    STableScanInfo* p1 = pOperator->info;




11,634,402✔





466



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




11,634,402✔





467



      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;




2,420,242✔





468



    } else {










469



      *status = FUNC_DATA_REQUIRED_FILTEROUT;




9,214,160✔





470



    }










471



    return TSDB_CODE_SUCCESS;




11,634,402✔





472



  }










473












474



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




744,722,627✔





475



  pCost->loadBlocks += 1;




744,210,160✔





476












477



  SSDataBlock* p = NULL;




744,817,689✔





478



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




744,888,325✔





479



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




745,038,971✔





480



    return code;




×







481



  }










482












483



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




745,038,971✔





484



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




602,421,971✔





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);




734,917,350✔





489



    if (code) {




734,862,994✔





490



      return code;




×







491



    }










492



  }










493












494



  // restore the previous value










495



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




744,890,112✔





496












497



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




744,956,746✔





498



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




101,624,647✔





499



    QUERY_CHECK_CODE(code, lino, _end);




101,688,253✔





500












501



    int64_t st = taosGetTimestampUs();




98,572,219✔





502



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




98,576,760✔





503



    pTableScanInfo->readRecorder.filterTime += el;




98,576,760✔





504












505



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




98,576,160✔





506



      pCost->filterOutBlocks += 1;




21,989,281✔





507



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




21,986,248✔





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,567,035✔





511



    }










512



  }










513












514



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




741,905,699✔





515



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




741,545,596✔





516



    setOperatorCompleted(pOperator);




2,580,059✔





517



  }










518












519



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




741,545,596✔





520












521



_end:




745,087,454✔





522



  if (code != TSDB_CODE_SUCCESS) {




745,030,247✔





523



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




3,138,175✔





524



  }










525



  return code;




744,893,155✔





526



}










527












528



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




64,693✔





529



  SET_REVERSE_SCAN_FLAG(pTableScanInfo);




64,693✔





530












531



  switchCtxOrder(pCtx, numOfOutput);




64,693✔





532



  pTableScanInfo->cond.order = TSDB_ORDER_DESC;




64,693✔





533



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










534



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










535



}




64,693✔





536












537



typedef struct STableCachedVal {










538



  const char* pName;










539



  STag*       pTags;










540



} STableCachedVal;










541












542



static void freeTableCachedVal(void* param) {




237,690,557✔





543



  if (param == NULL) {




237,690,557✔





544



    return;




×







545



  }










546












547



  STableCachedVal* pVal = param;




237,690,557✔





548



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




237,690,557✔





549



  taosMemoryFree(pVal->pTags);




237,694,081✔





550



  taosMemoryFree(pVal);




237,675,482✔





551



}










552












553



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




237,576,238✔





554



  int32_t          code = TSDB_CODE_SUCCESS;




237,576,238✔





555



  int32_t          lino = 0;




237,576,238✔





556



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




237,576,238✔





557



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




237,667,413✔





558












559



  pVal->pTags = NULL;




237,667,413✔





560



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




237,650,527✔





561



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




237,576,352✔





562












563



  // only child table has tag value










564



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




237,518,346✔





565



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




237,329,136✔





566



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




237,368,983✔





567



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




237,353,044✔





568



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




237,379,855✔





569



  }










570












571



  (*ppResVal) = pVal;




237,599,802✔





572












573



_end:




237,636,551✔





574



  if (code != TSDB_CODE_SUCCESS) {




237,636,551✔





575



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




×







576



    freeTableCachedVal(pVal);




×







577



  }










578



  return code;




237,578,976✔





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) {




237,685,969✔





583



  (void)key;










584



  (void)keyLen;










585



  (void)ud;










586



  freeTableCachedVal(value);




237,685,969✔





587



}




237,688,220✔





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,




381,942,567✔





604



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










605



  int32_t          code = TSDB_CODE_SUCCESS;




381,942,567✔





606



  int32_t          lino = 0;




381,942,567✔





607



  bool             freeReader = false;




381,942,567✔





608



  LRUHandle*       h = NULL;




381,942,567✔





609



  STableCachedVal  val = {0};




381,942,567✔





610



  SMetaReader      mr = {0};




381,942,567✔





611



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




381,945,555✔





612



  int32_t          insertRet = TAOS_LRU_STATUS_OK;




381,975,313✔





613



  STableCachedVal* pVal = NULL;




381,975,313✔





614












615



  // currently only the tbname pseudo column










616



  if (numOfExpr <= 0) {




381,999,185✔





617



    return TSDB_CODE_SUCCESS;




189,050✔





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;




381,810,135✔





624



  pBlock->info.rows = rows;




381,808,904✔





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) {




381,838,373✔





631



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




2,017,656✔





632



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




1,898,583✔





633



    if (code != TSDB_CODE_SUCCESS) {




1,897,874✔





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);




1,897,874✔





649












650



    val.pName = mr.me.name;




1,898,583✔





651



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




1,898,583✔





652












653



    freeReader = true;




1,898,583✔





654



  } else {










655



    pCache->metaFetch += 1;




379,827,675✔





656












657



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




379,928,419✔





658



    if (h == NULL) {




379,938,664✔





659



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




237,703,983✔





660



      freeReader = true;




237,697,136✔





661



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




237,697,136✔





662



      if (code != TSDB_CODE_SUCCESS) {




237,551,172✔





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);




237,551,172✔





677












678



      code = createTableCacheVal(&mr, &pVal);




237,650,094✔





679



      QUERY_CHECK_CODE(code, lino, _end);




237,611,987✔





680












681



      val = *pVal;




237,611,987✔





682



    } else {










683



      pCache->cacheHit += 1;




142,234,681✔





684



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




142,278,410✔





685



      val = *pValTmp;




142,270,798✔





686












687



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




142,278,066✔





688



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




142,273,440✔





689



    }










690












691



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




379,882,705✔





692



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










693



  }










694












695



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




1,505,531,665✔





696



    const SExprInfo* pExpr1 = &pExpr[j];




1,123,567,993✔





697



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




1,123,654,936✔





698












699



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




1,123,675,604✔





700



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




1,123,668,535✔





701












702



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




1,123,626,651✔





703












704



    // this is to handle the tbname










705



    if (fmIsScanPseudoColumnFunc(functionId)) {




1,123,649,960✔





706



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




130,967,236✔





707



      if (fType == FUNCTION_TYPE_TBNAME) {




130,966,883✔





708



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




130,966,883✔





709



        QUERY_CHECK_CODE(code, lino, _end);




130,963,331✔





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};




992,653,568✔





719



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




992,577,083✔





720



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




992,659,896✔





721












722



      char* data = NULL;




992,749,190✔





723



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




992,749,190✔





724



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




987,769,112✔





725



      } else {










726



        data = (char*)p;




4,986,089✔





727



      }










728












729



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




992,605,981✔





730



      if (isNullVal) {




992,611,992✔





731



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




4,521,152✔





732



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




988,090,840✔





733



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




987,714,624✔





734



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




987,688,556✔





735



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




365,256,591✔





736



          if (tmp != NULL) {




365,259,670✔





737



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




365,259,670✔





738



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




365,260,803✔





739



                   pBlock->info.id.uid);










740



            taosMemoryFree(tmp);




365,262,031✔





741



          }










742



          taosMemoryFree(data);




365,268,074✔





743



        }










744



        QUERY_CHECK_CODE(code, lino, _end);




987,693,477✔





745



      } else {  // todo opt for json tag










746



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




2,926,413✔





747



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




2,461,476✔





748



          QUERY_CHECK_CODE(code, lino, _end);




2,461,476✔





749



        }










750



      }










751



    }










752



  }










753












754



  // restore the rows










755



  pBlock->info.rows = backupRows;




381,963,672✔





756












757



_end:




381,898,915✔





758












759



  if (NULL != pVal) {




381,871,426✔





760



    insertRet =




237,695,801✔





761



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




237,691,152✔





762



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










763



    if (insertRet != TAOS_LRU_STATUS_OK) {




237,695,801✔





764



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




×







765



    }










766



  }










767












768



  if (freeReader) {




381,876,075✔





769



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




239,578,489✔





770



  }










771



  if (code != TSDB_CODE_SUCCESS) {




381,872,362✔





772



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




×







773



  }










774



  return code;




381,859,282✔





775



}










776












777



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




130,964,807✔





778



                         const char* name) {










779



  int32_t                     code = TSDB_CODE_SUCCESS;




130,964,807✔





780



  int32_t                     lino = 0;




130,964,807✔





781



  struct SScalarFuncExecFuncs fpSet = {0};




130,964,807✔





782



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




130,965,875✔





783



  QUERY_CHECK_CODE(code, lino, _end);




130,966,832✔





784












785



  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;




130,966,832✔





786



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




130,966,832✔





787



  STR_TO_VARSTR(buf, name)




130,967,902✔





788












789



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




130,968,443✔





790












791



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




130,967,350✔





792



  QUERY_CHECK_CODE(code, lino, _end);




130,966,946✔





793












794



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




130,966,946✔





795



  QUERY_CHECK_CODE(code, lino, _end);




130,967,025✔





796












797



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




130,967,025✔





798



  SScalarParam param = {.columnData = pColInfoData};




130,966,992✔





799












800



  if (fpSet.process != NULL) {




130,960,875✔





801



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




130,960,875✔





802



    QUERY_CHECK_CODE(code, lino, _end);




130,966,630✔





803



  } else {










804



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




×







805



  }










806












807



  colDataDestroy(&infoData);




130,966,630✔





808












809



_end:




130,955,975✔





810



  if (code != TSDB_CODE_SUCCESS) {




130,961,829✔





811



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




×







812



  }










813



  return code;




130,961,829✔





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) {




285,893,195✔





883



  int32_t code = TSDB_CODE_SUCCESS;




285,893,195✔





884



  int32_t lino = 0;




285,893,195✔





885



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




285,893,195✔





886



  QUERY_CHECK_CODE(code, lino, _end);




285,865,507✔





887












888



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




285,865,507✔





889



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




286,088,908✔





890



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




285,810,715✔





891



  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);




286,009,118✔





892












893



  if (!pInfo->needCountEmptyTable) {




285,699,462✔





894



    pInfo->countState = TABLE_COUNT_STATE_END;




263,698,731✔





895



  } else {










896



    pInfo->countState = TABLE_COUNT_STATE_SCAN;




22,227,568✔





897



  }










898












899



_end:




285,847,824✔





900



  if (code != TSDB_CODE_SUCCESS) {




285,847,824✔





901



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




×







902



  }










903



  return code;




285,894,664✔





904



}










905












906



void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {




658,687,592✔





907



  if (pInfo->countState == TABLE_COUNT_STATE_END) {




658,687,592✔





908



    return;




542,194,354✔





909



  }










910



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




116,495,962✔





911



    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;




214,580✔





912



  } else {










913



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




116,278,681✔





914



    if (code != TSDB_CODE_SUCCESS) {




116,288,735✔





915



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




49,943,690✔





916



    }










917



  }










918



}










919












920



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




44,984,093✔





921



                                         const STableKeyInfo* tbInfo) {










922



  blockDataEmpty(pBlock);




44,984,093✔





923



  pBlock->info.rows = 1;




44,985,073✔





924



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




44,985,563✔





925



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




44,986,053✔





926



  pBlock->info.blankFill = true;




44,987,033✔





927












928



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










929



  int32_t col_num = blockDataGetNumOfCols(pBlock);




44,986,053✔





930



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




185,334,832✔





931



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




140,349,238✔





932



    colDataSetNULL(pColInfoData, 0);










933



  }










934












935



  // set tag/tbname










936



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




44,985,594✔





937












938



  return pBlock;




44,986,053✔





939



}










940












941



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




43,222,655✔





942



  STableScanInfo* pTableScanInfo = pOperator->info;




43,222,655✔





943



  SSDataBlock*    pBlock =










944



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




43,225,595✔





945












946



  pOperator->resultInfo.totalRows++;




43,226,575✔





947



  return pBlock;




43,225,595✔





948



}










949












950



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




891,790,967✔





951



  int32_t         code = TSDB_CODE_SUCCESS;




891,790,967✔





952



  int32_t         lino = 0;




891,790,967✔





953



  STableScanInfo* pTableScanInfo = pOperator->info;




891,790,967✔





954



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




892,157,622✔





955



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




891,903,529✔





956



  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;




892,424,888✔





957



  bool            hasNext = false;




891,447,818✔





958



  int64_t         st = taosGetTimestampUs();




891,878,592✔





959












960



  QRY_PARAM_CHECK(ppRes);




891,878,592✔





961



  pBlock->info.dataLoad = false;




892,046,546✔





962












963



  while (true) {




28,044,281✔





964



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




919,743,024✔





965



    if (code != TSDB_CODE_SUCCESS) {




919,909,870✔





966



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




×







967



      QUERY_CHECK_CODE(code, lino, _end);




40,408✔





968



    }










969












970



    if (!hasNext) {




919,949,947✔





971



      break;




271,023,516✔





972



    }










973












974



    if (isTaskKilled(pTaskInfo)) {




648,926,431✔





975



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




14,565✔





976



      code = pTaskInfo->code;




14,565✔





977



      goto _end;




14,565✔





978



    }










979












980



    if (pOperator->status == OP_EXEC_DONE) {




649,261,618✔





981



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




29,120✔





982



      break;




29,120✔





983



    }










984












985



    // process this data block based on the probabilities










986



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




648,772,382✔





987



    if (!processThisBlock) {




649,127,264✔





988



      continue;




×







989



    }










990












991



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




649,127,264✔





992



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




649,194,075✔





993



    }










994












995



    uint32_t status = 0;




649,397,490✔





996



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




649,248,203✔





997



    QUERY_CHECK_CODE(code, lino, _end);




648,980,371✔





998












999



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




645,954,666✔





1000



      break;




2,420,242✔





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) {




643,534,424✔





1005



      continue;




28,043,832✔





1006



    }










1007












1008



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




615,496,322✔





1009



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




615,562,933✔





1010












1011



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




615,810,238✔





1012



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




615,604,654✔





1013












1014



    (*ppRes) = pBlock;




615,737,488✔





1015



    return code;




615,021,253✔





1016



  }










1017












1018



_end:




276,525,707✔





1019



  if (code != TSDB_CODE_SUCCESS) {




276,565,970✔





1020



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




3,075,617✔





1021



    pTaskInfo->code = code;




3,075,617✔





1022



    T_LONG_JMP(pTaskInfo->env, code);




3,040,270✔





1023



  }










1024



  return code;




273,490,353✔





1025



}










1026












1027



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




941,061,469✔





1028



  int32_t         code = TSDB_CODE_SUCCESS;




941,061,469✔





1029



  int32_t         lino = 0;




941,061,469✔





1030



  STableScanInfo* pTableScanInfo = pOperator->info;




941,061,469✔





1031



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




941,319,060✔





1032



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




941,087,016✔





1033












1034



  QRY_PARAM_CHECK(pBlock);




941,489,681✔





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) {




941,375,248✔





1038



    return code;




6,032,781✔





1039



  }










1040












1041



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










1042



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




1,194,347,459✔





1043



    SSDataBlock* p = NULL;




806,706,747✔





1044



    code = doTableScanImplNext(pOperator, &p);




806,521,547✔





1045



    QUERY_CHECK_CODE(code, lino, _end);




803,395,989✔





1046












1047



    if (p != NULL) {




803,395,989✔





1048



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




544,110,950✔





1049



      *pBlock = p;




544,260,045✔





1050



      return code;




543,538,912✔





1051



    }










1052












1053



    pTableScanInfo->scanTimes += 1;




259,285,039✔





1054



    taosHashClear(pTableScanInfo->pIgnoreTables);




259,287,853✔





1055












1056



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




259,319,990✔





1057



      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




81,111✔





1058



      pTableScanInfo->base.scanFlag = MAIN_SCAN;




81,111✔





1059



      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




81,111✔





1060



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




81,111✔





1061












1062



      // do prepare for the next round table scan operation










1063



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




81,111✔





1064



      QUERY_CHECK_CODE(code, lino, _end);




45,422✔





1065



    }










1066



  }










1067












1068



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




387,859,879✔





1069



  if (pTableScanInfo->scanTimes < total) {




387,904,772✔





1070



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




85,496,885✔





1071



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




64,693✔





1072



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




64,693✔





1073



      QUERY_CHECK_CODE(code, lino, _end);




64,693✔





1074



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




64,693✔





1075



    }










1076












1077



    while (pTableScanInfo->scanTimes < total) {




99,620,866✔





1078



      SSDataBlock* p = NULL;




85,478,977✔





1079



      code = doTableScanImplNext(pOperator, &p);




85,467,894✔





1080



      QUERY_CHECK_CODE(code, lino, _end);




85,400,665✔





1081












1082



      if (p != NULL) {




85,400,665✔





1083



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




71,211,962✔





1084



        *pBlock = p;




71,243,992✔





1085



        return code;




71,233,170✔





1086



      }










1087












1088



      pTableScanInfo->scanTimes += 1;




14,188,703✔





1089



      taosHashClear(pTableScanInfo->pIgnoreTables);




14,191,018✔





1090












1091



      if (pTableScanInfo->scanTimes < total) {




14,188,134✔





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);




671✔





1098



      }










1099



    }










1100



  }










1101












1102



  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {




316,513,725✔





1103



    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;




64,884,671✔





1104



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




64,888,398✔





1105



      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {




109,591✔





1106



        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;




1,960✔





1107



        STableKeyInfo* pStart =










1108



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




1,960✔





1109












1110



        if (NULL == pStart) {




1,960✔





1111



          return code;




×







1112



        }










1113












1114



        *pBlock = getBlockForEmptyTable(pOperator, pStart);




1,960✔





1115



        return code;




1,960✔





1116



      }










1117



    } else {  // group by tag + no sort










1118



      int32_t numOfTables = 0;




64,779,895✔





1119



      code = tableListGetSize(pTableListInfo, &numOfTables);




64,781,350✔





1120



      QUERY_CHECK_CODE(code, lino, _end);




64,781,841✔





1121












1122



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




64,781,841✔





1123



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










1124



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




63,421,148✔





1125



        if (pIte != NULL) {




63,421,050✔





1126



          size_t        keySize = 0;




43,224,125✔





1127



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




43,225,105✔





1128



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




43,220,205✔





1129



          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);




43,219,715✔





1130



          markGroupProcessed(pTableScanInfo, *pGroupId);




43,222,165✔





1131



          *pBlock = getBlockForEmptyTable(pOperator, &info);




43,222,655✔





1132












1133



          return code;




43,225,105✔





1134



        }










1135



      }










1136



    }










1137



    pTableScanInfo->countState = TABLE_COUNT_STATE_END;




21,664,766✔





1138



  }










1139












1140



_end:




251,739,508✔





1141



  if (code != TSDB_CODE_SUCCESS) {




273,355,052✔





1142



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




×







1143



    pTaskInfo->code = code;




×







1144



  }










1145












1146



  return code;




273,355,052✔





1147



}










1148












1149



static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {




208,552✔





1150



  STableScanInfo*          pInfo = pOperator->info;




208,552✔





1151



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




208,552✔





1152



  int32_t                  code = 0;




208,552✔





1153



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




208,552✔





1154



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




208,552✔





1155



  int32_t                  num = taosArrayGetSize(pParam->pUidList);




208,552✔





1156



  if (num <= 0) {




208,552✔





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",




208,552✔





1162



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










1163



         pOperator->status);










1164












1165



  if (pParam->tableSeq) {




208,552✔





1166



    pListInfo->oneTableForEachGroup = true;




4,284✔





1167



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




4,284✔





1168



      taosHashClear(pListInfo->map);




×







1169



      taosArrayClear(pListInfo->pTableList);




×







1170



      pOperator->status = OP_EXEC_DONE;




×







1171



    }










1172



  } else {










1173



    pListInfo->oneTableForEachGroup = false;




204,268✔





1174



    pListInfo->numOfOuputGroups = 1;




204,268✔





1175



  }










1176



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




208,552✔





1177



    // do nothing










1178



  } else {










1179



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




×







1180



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




×







1181



  }










1182












1183



  STableKeyInfo info = {.groupId = 0};




208,552✔





1184



  int32_t       tableIdx = 0;




208,552✔





1185



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




7,333,732✔





1186



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




7,125,180✔





1187



    if (!pUid) {




7,125,180✔





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))) {




7,125,180✔





1193



      if (TSDB_CODE_DUP_KEY == terrno) {




6,623,749✔





1194



        continue;




6,623,749✔





1195



      }










1196



      return terrno;




×







1197



    }










1198












1199



    info.uid = *pUid;




501,431✔





1200



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




501,431✔





1201



    if (p == NULL) {




501,431✔





1202



      return terrno;




×







1203



    }










1204












1205



    tableIdx++;




501,431✔





1206



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




501,431✔





1207



  }










1208












1209



  return code;




208,552✔





1210



}










1211












1212



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




279,970,018✔





1213



                            STableKeyInfo** pList) {










1214



  const char* idStr = GET_TASKID(pTaskInfo);




279,970,018✔





1215



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




280,171,332✔





1216



  if (code) {




279,466,435✔





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) {




279,466,435✔





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,




559,673,658✔





1227



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




279,816,650✔





1228



  if (code) {




279,918,361✔





1229



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




2,085✔





1230



  }










1231












1232



  return code;




280,060,291✔





1233



}










1234












1235



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




107,653,950✔





1236



  SColIdPair* node1 = (SColIdPair*)elem1;




107,653,950✔





1237



  SColIdPair* node2 = (SColIdPair*)elem2;




107,653,950✔





1238












1239



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




107,653,950✔





1240



    return 0;




106,068✔





1241



  }










1242












1243



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




107,591,121✔





1244



}










1245












1246



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




107,659,914✔





1247



  SColIdSlotIdPair* node1 = (SColIdSlotIdPair*)elem1;




107,659,914✔





1248



  SColIdSlotIdPair* node2 = (SColIdSlotIdPair*)elem2;




107,659,914✔





1249












1250



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




107,659,914✔





1251



    return 0;




106,068✔





1252



  }










1253












1254



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




107,587,145✔





1255



}










1256












1257



static bool isNewScanParam(STableScanOperatorParam* pParam) {




10,547,954✔





1258



  return pParam->isNewParam;




10,547,954✔





1259



}










1260












1261



static int32_t createVTableScanInfoFromBatchParam(SOperatorInfo* pOperator) {




9,381,869✔





1262



  int32_t                  code = 0;




9,381,869✔





1263



  int32_t                  lino = 0;




9,381,869✔





1264



  STableScanInfo*          pInfo = pOperator->info;




9,381,869✔





1265



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




9,380,378✔





1266



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




9,380,875✔





1267



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




9,381,372✔





1268



  SMetaReader              orgTable = {0};




9,382,366✔





1269



  SMetaReader              superTable = {0};




9,387,336✔





1270



  SSchemaWrapper*          schema = NULL;




9,383,857✔





1271



  SArray*                  pColArray = NULL;




9,383,857✔





1272



  SArray*                  pBlockColArray = NULL;




9,383,857✔





1273



  int32_t                  num = 0;




9,383,857✔





1274



  STableKeyInfo*           pList = NULL;




9,385,348✔





1275



  SOrgTbInfo*              pOrgTbInfo;










1276



  bool                     isNewTable;










1277












1278



  cleanupQueryTableDataCond(&pInfo->base.cond);




9,384,851✔





1279












1280



  if (pOperator->pOperatorGetParam) {




9,383,857✔





1281



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




1,876,672✔





1282



    pInfo->pBatchColMap = pParam->pBatchTbInfo;




1,878,163✔





1283



    pParam->pBatchTbInfo = NULL;




1,873,690✔





1284



    pInfo->cachedTimeWindow = pParam->window;




1,871,205✔





1285



    pInfo->currentBatchIdx = 0;




1,873,193✔





1286



    pInfo->lastBatchIdx = -1;




1,873,690✔





1287



    pInfo->cachedTagList = pParam->pTagList;




1,876,672✔





1288



    pParam->pTagList = NULL;




1,874,187✔





1289



    pInfo->cachedGroupId = pParam->groupid;




1,869,217✔





1290












1291



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




1,875,181✔





1292



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










1293



    taosHashClear(pInfo->pIgnoreTables);




1,875,181✔





1294












1295



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




1,876,672✔





1296



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




1,878,163✔





1297



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




23,333,653✔





1298



        SqlFunctionCtx ctx = pSup->pCtx[i];




21,463,939✔





1299



        ctx.skipDynDataCheck = false;




21,456,981✔





1300



      }










1301



    }










1302



  }










1303












1304



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




9,374,911✔





1305



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




9,386,839✔





1306












1307



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




9,386,839✔





1308



    isNewTable = false;




5,799,990✔





1309



  } else {










1310



    isNewTable = true;




3,586,352✔





1311



    pInfo->lastBatchIdx = pInfo->currentBatchIdx;




3,586,352✔





1312



  }










1313












1314



  if (isNewTable) {




9,386,839✔





1315



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




3,586,849✔





1316



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




3,586,352✔





1317



    pAPI->metaReaderFn.readerReleaseLock(&orgTable);




3,577,406✔





1318



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




3,582,873✔





1319



    QUERY_CHECK_CODE(code, lino, _return);




3,580,388✔





1320



    switch (orgTable.me.type) {




3,580,388✔





1321



      case TSDB_CHILD_TABLE:




×







1322



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




×







1323



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




×







1324



        pAPI->metaReaderFn.readerReleaseLock(&superTable);




×







1325



        QUERY_CHECK_CODE(code, lino, _return);




×







1326



        schema = &superTable.me.stbEntry.schemaRow;




×







1327



        break;




×







1328



      case TSDB_NORMAL_TABLE:




3,567,466✔





1329



        schema = &orgTable.me.ntbEntry.schemaRow;




3,567,466✔





1330



        break;




3,567,466✔





1331



      default:




12,922✔





1332



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




12,922✔





1333



        return TSDB_CODE_INVALID_PARA;




×







1334



        break;










1335



    }










1336












1337



    pListInfo->oneTableForEachGroup = true;




3,567,466✔





1338



    taosHashClear(pListInfo->map);




3,581,879✔





1339



    taosArrayClear(pListInfo->pTableList);




3,588,340✔





1340












1341



    uint64_t      pUid = orgTable.me.uid;




3,586,849✔





1342



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




3,586,849✔





1343



    int32_t       tableIdx = 0;




3,587,843✔





1344



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




3,586,849✔





1345



    QUERY_CHECK_CODE(code, lino, _return);




3,588,340✔





1346



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




7,174,692✔





1347



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




3,586,352✔





1348












1349



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




3,586,352✔





1350



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




3,586,849✔





1351



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




3,586,849✔





1352



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




3,584,861✔





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};




3,584,861✔





1356



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




3,588,340✔





1357












1358



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




14,251,972✔





1359



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




10,664,626✔





1360



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




86,666,860✔





1361



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




86,556,526✔





1362



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




10,672,578✔





1363



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




10,672,578✔





1364



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




10,672,578✔





1365



                 pPair.vtbColId, GET_TASKID(pTaskInfo));










1366



          break;




10,666,614✔





1367



        }










1368



      }










1369



    }










1370












1371



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




17,841,306✔





1372



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




14,253,960✔





1373



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




89,181,183✔





1374



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




89,124,525✔





1375



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




89,132,974✔





1376



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




14,255,948✔





1377



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




14,258,930✔





1378



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




14,258,930✔





1379



                 colIdSlotIdPair.vtbSlotId, GET_TASKID(pTaskInfo));










1380



          break;




14,252,966✔





1381



        }










1382



      }










1383



    }










1384












1385



    taosArraySort(pColArray, compareColIdPair);




3,586,352✔





1386



    taosArraySort(pBlockColArray, compareColIdSlotIdPair);




3,586,352✔





1387



    if (pInfo->pBlockColMap) {




3,586,849✔





1388



      taosArrayDestroy(pInfo->pBlockColMap);




2,852,780✔





1389



      pInfo->pBlockColMap = NULL;




2,846,816✔





1390



    }










1391



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




3,581,382✔





1392



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




3,584,364✔





1393












1394












1395



    taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




3,576,412✔





1396



    taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




3,582,873✔





1397












1398



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




3,585,855✔





1399



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




3,584,861✔





1400



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




45,015,775✔





1401



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




41,434,890✔





1402



        bool           needScan = false;




41,428,429✔





1403



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




83,426,917✔





1404



          SFunctParam pParam = ctx->param[j];




41,979,105✔





1405



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




201,820,269✔





1406



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




169,801,044✔





1407



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




170,141,489✔





1408



              needScan |= true;




10,434,515✔





1409



              break;




10,434,515✔





1410



            }










1411



          }










1412



        }










1413



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




41,450,297✔





1414



        if (!needScan) {




41,463,716✔





1415



          ctx->skipDynDataCheck = true;




31,032,680✔





1416



        } else {










1417



          ctx->skipDynDataCheck = false;




10,431,036✔





1418



        }










1419



      }










1420



    }










1421












1422












1423



  } else {










1424



    pColArray = pInfo->lastColArray;




5,799,990✔





1425



    pBlockColArray = pInfo->lastBlockColArray;




5,799,990✔





1426



  }










1427












1428



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




9,383,857✔





1429



  QUERY_CHECK_CODE(code, lino, _return);




9,388,330✔





1430












1431



  if (pInfo->pResBlock) {




9,388,330✔





1432



    blockDataDestroy(pInfo->pResBlock);




7,508,676✔





1433



    pInfo->pResBlock = NULL;




7,509,173✔





1434



  }










1435












1436



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




9,388,827✔





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) {




9,384,354✔





1445



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




3,584,364✔





1446



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




3,580,388✔





1447



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




3,582,376✔





1448



    } else {










1449



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




3,976✔





1450



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




×







1451



    }










1452



  } else {










1453



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




5,799,990✔





1454



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




803,649✔





1455



    else {










1456



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




4,996,341✔





1457



    }










1458



  }










1459












1460



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




9,381,869✔





1461



  pInfo->currentGroupId = 0;




9,376,899✔





1462



  pInfo->ignoreTag = true;




9,370,935✔





1463












1464



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




9,368,450✔





1465



  QUERY_CHECK_CODE(code, lino, _return);




9,382,863✔





1466












1467



  if (isNewTable) {




9,382,863✔





1468



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




3,582,873✔





1469



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




2,850,792✔





1470



    }










1471



    pInfo->base.dataReader = NULL;




3,569,951✔





1472












1473



    taosRLockLatch(&pTaskInfo->lock);




3,571,939✔





1474



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




3,580,388✔





1475



    taosRUnLockLatch(&pTaskInfo->lock);




3,570,945✔





1476



    QUERY_CHECK_CODE(code, lino, _return);




3,580,388✔





1477












1478



    pInfo->newReader = true;




3,580,388✔





1479



    if (pInfo->lastColArray) {




3,581,879✔





1480



      taosArrayDestroy(pInfo->lastColArray);




1,708,686✔





1481



      pInfo->lastColArray = NULL;




1,708,686✔





1482



    }










1483



    if (pInfo->lastBlockColArray) {




3,579,891✔





1484



      taosArrayDestroy(pInfo->lastBlockColArray);




1,709,183✔





1485



      pInfo->lastBlockColArray = NULL;




1,709,183✔





1486



    }










1487



    pInfo->lastColArray = pColArray;




3,569,951✔





1488



    pInfo->lastBlockColArray = pBlockColArray;




3,577,903✔





1489



  } else {










1490



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




5,799,990✔





1491



    QUERY_CHECK_CODE(code, lino, _return);




5,799,990✔





1492












1493



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




5,799,990✔





1494



    pInfo->newReader = false;




5,799,990✔





1495



    pInfo->scanTimes = 0;




5,799,990✔





1496



  }










1497












1498



  pOperator->status = OP_OPENED;




9,358,510✔





1499












1500



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




9,380,875✔





1501



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




×







1502



  }










1503












1504



  pInfo->currentGroupId = -1;




9,374,414✔





1505



_return:




9,372,426✔





1506



  if (code) {




9,374,911✔





1507



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




×







1508



  }










1509



  pAPI->metaReaderFn.clearReader(&superTable);




9,374,911✔





1510



  pAPI->metaReaderFn.clearReader(&orgTable);




9,373,917✔





1511



  return code;




9,373,917✔





1512



}










1513












1514



static int32_t createVTableScanInfoFromParam(SOperatorInfo* pOperator) {




6,315,563✔





1515



  int32_t                  code = 0;




6,315,563✔





1516



  int32_t                  lino = 0;




6,315,563✔





1517



  STableScanInfo*          pInfo = pOperator->info;




6,315,563✔





1518



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




6,315,563✔





1519



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




6,315,563✔





1520



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




6,315,563✔





1521



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




6,315,563✔





1522



  SMetaReader              orgTable = {0};




6,315,563✔





1523



  SMetaReader              superTable = {0};




6,315,563✔





1524



  SSchemaWrapper*          schema = NULL;




6,315,563✔





1525



  SArray*                  pColArray = NULL;




6,315,563✔





1526



  SArray*                  pBlockColArray = NULL;




6,315,563✔





1527



  int32_t                  num = 0;




6,315,563✔





1528



  STableKeyInfo*           pList = NULL;




6,315,563✔





1529



  SOrgTbInfo*              pOrgTbInfo;










1530












1531



  cleanupQueryTableDataCond(&pInfo->base.cond);




6,315,563✔





1532












1533



  pOrgTbInfo = pParam->pOrgTbInfo;




6,315,563✔





1534












1535



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




6,315,563✔





1536












1537



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




6,315,563✔





1538



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




6,315,563✔





1539



  pAPI->metaReaderFn.readerReleaseLock(&orgTable);




6,315,563✔





1540



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




6,315,563✔





1541



  QUERY_CHECK_CODE(code, lino, _return);




6,315,563✔





1542



  switch (orgTable.me.type) {




6,315,563✔





1543



    case TSDB_CHILD_TABLE:




1,189,815✔





1544



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




1,189,815✔





1545



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




1,189,815✔





1546



      pAPI->metaReaderFn.readerReleaseLock(&superTable);




1,189,815✔





1547



      QUERY_CHECK_CODE(code, lino, _return);




1,189,815✔





1548



      schema = &superTable.me.stbEntry.schemaRow;




1,189,815✔





1549



      break;




1,189,815✔





1550



    case TSDB_NORMAL_TABLE:




5,125,748✔





1551



      schema = &orgTable.me.ntbEntry.schemaRow;




5,125,748✔





1552



      break;




5,125,748✔





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;




6,315,563✔





1560



  taosHashClear(pListInfo->map);




6,315,563✔





1561



  taosArrayClear(pListInfo->pTableList);




6,315,563✔





1562












1563



  uint64_t      pUid = orgTable.me.uid;




6,315,563✔





1564



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




6,315,563✔





1565



  int32_t       tableIdx = 0;




6,315,563✔





1566



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




6,315,563✔





1567



  QUERY_CHECK_CODE(code, lino, _return);




6,315,563✔





1568



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




12,631,126✔





1569



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




6,315,563✔





1570












1571



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




6,315,563✔





1572



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




6,315,563✔





1573



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




6,315,563✔





1574



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




6,315,563✔





1575












1576



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










1577



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




6,315,563✔





1578



                       .type.type = TSDB_DATA_TYPE_TIMESTAMP,










1579



                       .type.bytes = 8};










1580



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




6,315,563✔





1581












1582



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




27,949,462✔





1583



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




21,633,899✔





1584



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




188,366,416✔





1585



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




188,366,416✔





1586



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




21,633,899✔





1587



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




21,633,899✔





1588



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




21,633,899✔





1589



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




21,633,899✔





1590



        break;




21,633,899✔





1591



      }










1592



    }










1593



  }










1594












1595



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




34,264,411✔





1596



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




27,949,462✔





1597



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




186,598,431✔





1598



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




186,598,431✔





1599



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




186,598,431✔





1600



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




27,949,462✔





1601



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




27,948,848✔





1602



          qError("column type not match for vtable colId:%d, org colId:%d, org table name:%s", pPair->vtbColId, pPair->orgColId, orgTable.me.name);




614✔





1603



          code = TSDB_CODE_VTABLE_COLUMN_TYPE_MISMATCH;




614✔





1604



          goto _return;




614✔





1605



        }










1606



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




27,948,848✔





1607



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




27,948,848✔





1608



        break;




27,948,848✔





1609



      }










1610



    }










1611



  }










1612












1613



  taosArraySort(pColArray, compareColIdPair);




6,314,949✔





1614



  taosArraySort(pBlockColArray, compareColIdSlotIdPair);




6,314,949✔





1615



  if (pInfo->pBlockColMap) {




6,314,949✔





1616



    taosArrayDestroy(pInfo->pBlockColMap);




5,646,527✔





1617



    pInfo->pBlockColMap = NULL;




5,646,527✔





1618



  }










1619



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




6,314,949✔





1620



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




6,314,949✔





1621












1622












1623



  taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




6,314,949✔





1624



  taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




6,314,949✔





1625












1626



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




6,314,949✔





1627



  QUERY_CHECK_CODE(code, lino, _return);




6,314,949✔





1628












1629



  if (pInfo->pResBlock) {




6,314,949✔





1630



    blockDataDestroy(pInfo->pResBlock);




4,233,005✔





1631



    pInfo->pResBlock = NULL;




4,233,005✔





1632



  }










1633












1634



  if (isNewScanParam(pParam)) {




6,314,949✔





1635



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




2,087,821✔





1636



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




2,087,821✔





1637



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




2,087,821✔





1638



    } else {










1639



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




×







1640



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




×







1641



    }










1642



  } else {










1643



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




4,227,128✔





1644



  }










1645



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




6,314,949✔





1646



  pInfo->currentGroupId = 0;




6,314,949✔





1647



  pInfo->ignoreTag = true;




6,314,949✔





1648












1649



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




6,314,949✔





1650



  QUERY_CHECK_CODE(code, lino, _return);




6,314,949✔





1651












1652



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




6,314,949✔





1653



  if (reader) {




6,314,949✔





1654



    if (isNewScanParam(pParam)) {




4,233,005✔





1655



      pAPI->tsdReader.tsdReaderClose(*reader);




5,877✔





1656



      pInfo->base.dataReader = NULL;




5,877✔





1657












1658



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




5,877✔





1659



      QUERY_CHECK_CODE(code, lino, _return);




5,877✔





1660












1661



      taosRLockLatch(&pTaskInfo->lock);




5,877✔





1662



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




5,877✔





1663



      taosRUnLockLatch(&pTaskInfo->lock);




5,877✔





1664



      QUERY_CHECK_CODE(code, lino, _return);




5,877✔





1665












1666



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




5,877✔





1667



      QUERY_CHECK_CODE(code, lino, _return);




5,877✔





1668



      pInfo->newReader = true;




5,877✔





1669



    } else {










1670



      pInfo->base.dataReader = *reader;




4,227,128✔





1671



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




4,227,128✔





1672



      QUERY_CHECK_CODE(code, lino, _return);




4,227,128✔





1673












1674



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




4,227,128✔





1675



      pInfo->newReader = false;




4,227,128✔





1676



      pInfo->scanTimes = 0;




4,227,128✔





1677



    }










1678



  } else {










1679



    pInfo->base.dataReader = NULL;




2,081,944✔





1680












1681



    taosRLockLatch(&pTaskInfo->lock);




2,081,944✔





1682



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




2,081,944✔





1683



    taosRUnLockLatch(&pTaskInfo->lock);




2,081,944✔





1684



    QUERY_CHECK_CODE(code, lino, _return);




2,081,944✔





1685












1686



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




2,081,944✔





1687



    QUERY_CHECK_CODE(code, lino, _return);




2,081,944✔





1688



    pInfo->newReader = true;




2,081,944✔





1689



  }










1690



  pOperator->status = OP_OPENED;




6,314,949✔





1691












1692



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




6,314,949✔





1693



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




×







1694



  }










1695












1696



  pInfo->currentGroupId = -1;




6,314,949✔





1697



_return:




6,315,563✔





1698



  if (code) {




6,315,563✔





1699



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




614✔





1700



  }










1701



  taosArrayDestroy(pColArray);




6,315,563✔





1702



  taosArrayDestroy(pBlockColArray);




6,315,563✔





1703



  pAPI->metaReaderFn.clearReader(&superTable);




6,315,563✔





1704



  pAPI->metaReaderFn.clearReader(&orgTable);




6,315,563✔





1705



  return code;




6,315,563✔





1706



}










1707












1708



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




273,999,138✔





1709



  int32_t         code = TSDB_CODE_SUCCESS;




273,999,138✔





1710



  int32_t         lino = 0;




273,999,138✔





1711



  STableScanInfo* pInfo = pOperator->info;




273,999,138✔





1712



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




274,016,290✔





1713



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




274,003,725✔





1714



  int32_t         numOfTables = 0;




274,031,928✔





1715












1716



  QRY_PARAM_CHECK(pResult);




273,866,933✔





1717












1718



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




273,852,889✔





1719



  QUERY_CHECK_CODE(code, lino, _end);




273,937,299✔





1720












1721



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




273,937,299✔





1722



    setOperatorCompleted(pOperator);




267,933,581✔





1723



    if (pOperator->dynamicTask) {




267,989,725✔





1724



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




207,838✔





1725



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




207,838✔





1726



    }










1727



    return code;




268,044,986✔





1728



  }










1729












1730



  // reset value for the next group data output










1731



  pOperator->status = OP_OPENED;




5,910,343✔





1732



  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);




5,935,193✔





1733












1734



  int32_t        num = 0;




5,940,163✔





1735



  STableKeyInfo* pList = NULL;




5,940,163✔





1736



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




5,939,169✔





1737



  QUERY_CHECK_CODE(code, lino, _end);




5,942,648✔





1738












1739



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




5,942,648✔





1740



  QUERY_CHECK_CODE(code, lino, _end);




5,944,636✔





1741












1742



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




5,944,636✔





1743



  QUERY_CHECK_CODE(code, lino, _end);




5,929,229✔





1744



  pInfo->scanTimes = 0;




5,929,229✔





1745












1746



  code = doGroupedTableScan(pOperator, pResult);




5,932,708✔





1747



  QUERY_CHECK_CODE(code, lino, _end);




5,949,109✔





1748












1749



  if (*pResult != NULL) {




5,949,109✔





1750



    if (pOperator->dynamicTask) {




4,610,079✔





1751



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




4,389,234✔





1752



    }










1753



    return code;




4,610,576✔





1754



  }










1755












1756



_end:




1,339,527✔





1757



  if (code != TSDB_CODE_SUCCESS) {




1,339,030✔





1758



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




×







1759



    pTaskInfo->code = code;




×







1760



  }










1761



  return code;




1,339,527✔





1762



}










1763












1764



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




914,000,238✔





1765



  int32_t         code = TSDB_CODE_SUCCESS;




914,000,238✔





1766



  int32_t         lino = 0;




914,000,238✔





1767



  STableScanInfo* pInfo = pOperator->info;




914,000,238✔





1768



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




914,459,080✔





1769



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




914,199,355✔





1770



  int32_t         num = 0;




914,150,374✔





1771



  STableKeyInfo*  pList = NULL;




914,123,786✔





1772



  SSDataBlock*    pResult = NULL;




914,019,290✔





1773



  const char*     idStr = GET_TASKID(pTaskInfo);




914,385,624✔





1774












1775



  QRY_PARAM_CHECK(pResBlock);




914,147,448✔





1776












1777



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




914,039,908✔





1778



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




274,299,152✔





1779



      setOperatorCompleted(pOperator);




×







1780



      return code;




×







1781



    }










1782












1783



    taosRLockLatch(&pTaskInfo->lock);




274,233,730✔





1784



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




274,516,861✔





1785



    taosRUnLockLatch(&pTaskInfo->lock);




274,137,787✔





1786



    QUERY_CHECK_CODE(code, lino, _end);




274,495,841✔





1787












1788



    if (pInfo->filesetDelimited) {




274,493,756✔





1789



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




205,707✔





1790



    }










1791












1792



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




274,497,692✔





1793



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




×







1794



    }










1795



  }










1796












1797



  code = doGroupedTableScan(pOperator, &pResult);




914,288,513✔





1798



  QUERY_CHECK_CODE(code, lino, _end);




910,988,750✔





1799












1800



  if (pResult != NULL) {




910,988,750✔





1801



    if (pOperator->dynamicTask) {




642,964,070✔





1802



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




463,708✔





1803



    }










1804












1805



    *pResBlock = pResult;




642,945,579✔





1806



    return code;




642,735,278✔





1807



  }










1808












1809



  while (true) {










1810



    code = startNextGroupScan(pOperator, &pResult);




268,070,932✔





1811



    QUERY_CHECK_CODE(code, lino, _end);




268,332,553✔





1812












1813



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




268,332,553✔





1814



      *pResBlock = pResult;




268,286,402✔





1815



      return code;




268,232,998✔





1816



    }










1817



  }










1818












1819



_end:




2,085✔





1820



  if (code != TSDB_CODE_SUCCESS) {




2,085✔





1821



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




2,085✔





1822



    pTaskInfo->code = code;




2,085✔





1823



  }










1824












1825



  return code;




2,085✔





1826



}










1827












1828



static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {




6,314,949✔





1829



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




6,314,949✔





1830



}










1831












1832



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




208,552✔





1833



  int32_t                  code = TSDB_CODE_SUCCESS;




208,552✔





1834



  int32_t                  lino = 0;




208,552✔





1835



  STableScanInfo*          pInfo = pOperator->info;




208,552✔





1836



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




208,552✔





1837



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




208,552✔





1838



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




208,552✔





1839












1840



  code = createTableListInfoFromParam(pOperator);




208,552✔





1841



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




208,552✔





1842



  pOperator->pOperatorGetParam = NULL;




208,552✔





1843



  QUERY_CHECK_CODE(code, lino, _end);




208,552✔





1844












1845



  if (pOperator->status == OP_EXEC_DONE) {




208,552✔





1846



    pInfo->currentGroupId = -1;




2,142✔





1847



    pOperator->status = OP_OPENED;




2,142✔





1848



    SSDataBlock* result = NULL;




2,142✔





1849












1850



    while (true) {










1851



      code = startNextGroupScan(pOperator, &result);




2,142✔





1852



      QUERY_CHECK_CODE(code, lino, _end);




2,142✔





1853












1854



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




2,142✔





1855



        (*ppRes) = result;




2,142✔





1856



        return code;




2,142✔





1857



      }










1858



    }










1859



  }










1860



_end:




206,410✔





1861



  if (code) {




206,410✔





1862



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




×







1863



  }










1864



  return code;




206,410✔





1865



}










1866












1867



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




6,315,563✔





1868



  int32_t                  code = TSDB_CODE_SUCCESS;




6,315,563✔





1869



  int32_t                  lino = 0;




6,315,563✔





1870



  STableScanInfo*          pInfo = pOperator->info;




6,315,563✔





1871



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




6,315,563✔





1872



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




6,315,563✔





1873



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




6,315,563✔





1874












1875



  QRY_PARAM_CHECK(ppRes);




6,315,563✔





1876



  qTrace("%s call", __FUNCTION__);




6,315,563✔





1877












1878



  code = createVTableScanInfoFromParam(pOperator);




6,315,563✔





1879



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




6,315,563✔





1880



  pOperator->pOperatorGetParam = NULL;




6,315,563✔





1881












1882



  QUERY_CHECK_CODE(code, lino, _end);




6,315,563✔





1883












1884



  SSDataBlock* result = NULL;




6,314,949✔





1885



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




6,314,949✔





1886



    (*ppRes) = result;




16,488✔





1887



    return code;




16,488✔





1888



  }










1889












1890



  if (pInfo->newReader) {




6,298,461✔





1891



    code = startNextGroupScan(pOperator, &result);




2,087,821✔





1892



    QUERY_CHECK_CODE(code, lino, _end);




2,087,821✔





1893



  } else {










1894



    code = doGroupedTableScan(pOperator, &result);




4,210,640✔





1895



    QUERY_CHECK_CODE(code, lino, _end);




4,210,640✔





1896



  }










1897












1898



  if (result) {




6,298,461✔





1899



    SSDataBlock* res = NULL;




4,227,128✔





1900



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




4,227,128✔





1901



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




4,227,128✔





1902



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




4,227,128✔





1903



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




4,227,128✔





1904



    QUERY_CHECK_CODE(code, lino, _end);




4,227,128✔





1905












1906



    pInfo->pResBlock = res;




4,227,128✔





1907



    blockDataDestroy(result);




4,227,128✔





1908



    (*ppRes) = res;




4,227,128✔





1909



  } else {










1910



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




2,071,333✔





1911



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




2,071,333✔





1912












1913



    blockDataDestroy(pInfo->pResBlock);




2,071,333✔





1914



    pInfo->pResBlock = NULL;




2,071,333✔





1915












1916



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




2,071,333✔





1917



    if (reader) {




2,071,333✔





1918



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




2,071,333✔





1919



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




2,071,333✔





1920



        pInfo->base.dataReader = NULL;




2,071,333✔





1921



      }










1922



      if (pAPI->tsdReader.tsdReaderClose) {




2,071,333✔





1923



        pAPI->tsdReader.tsdReaderClose(*reader);




2,071,333✔





1924



      }










1925



    }










1926












1927



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




2,071,333✔





1928



    QUERY_CHECK_CODE(code, lino, _end);




2,071,333✔





1929



  }










1930



_end:




6,299,075✔





1931



  if (code) {




6,299,075✔





1932



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




614✔





1933



  }










1934



  return code;




6,299,075✔





1935



}










1936












1937



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




1,757,392✔





1938



  int32_t                  code = TSDB_CODE_SUCCESS;




1,757,392✔





1939



  int32_t                  lino = 0;




1,757,392✔





1940



  STableScanInfo*          pInfo = pOperator->info;




1,757,392✔





1941



  int32_t                  index = 0;




1,757,392✔





1942



  char*                    tagVal = NULL;




1,757,392✔





1943












1944



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




12,490,604✔





1945



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




10,733,212✔





1946



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




10,733,212✔





1947












1948



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




10,733,212✔





1949



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




10,733,212✔





1950












1951



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




2,147,483,647✔





1952



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




2,147,483,647✔





1953



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




2,147,483,647✔





1954



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




2,147,483,647✔





1955












1956



        varDataSetLen(tagVal, pTagVal->nData);




2,147,483,647✔





1957



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




2,147,483,647✔





1958



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




2,147,483,647✔





1959



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





1960



        taosMemoryFreeClear(tagVal);




2,147,483,647✔





1961



      } else {










1962



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




2,147,483,647✔





1963



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





1964



      }










1965



    }










1966



    index++;




10,733,212✔





1967



  }










1968



  return code;




1,757,392✔





1969



_end:




×







1970



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




×







1971



  taosMemoryFreeClear(tagVal);




×







1972



  return code;




×







1973



}










1974












1975



static void clearVstbBatchDynamicTableScanInfo(STableScanInfo* pInfo) {




1,879,157✔





1976



  if (pInfo->pBatchColMap) {




1,879,157✔





1977



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




5,467,497✔





1978



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




3,588,340✔





1979



      taosArrayDestroy(pOrgTbInfo->colMap);




3,588,340✔





1980



    }










1981



    taosArrayDestroy(pInfo->pBatchColMap);




1,879,157✔





1982



    pInfo->pBatchColMap = NULL;




1,879,157✔





1983



  }










1984



  if (pInfo->cachedTagList) {




1,879,157✔





1985



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




6,600,160✔





1986



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




5,637,968✔





1987



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




5,637,968✔





1988



        taosMemoryFreeClear(pTagVal->pData);




2,481,024✔





1989



      }










1990



    }










1991



    taosArrayDestroy(pInfo->cachedTagList);




962,192✔





1992



    pInfo->cachedTagList = NULL;




962,192✔





1993



  }










1994



  if (pInfo->lastColArray) {




1,879,157✔





1995



    taosArrayDestroy(pInfo->lastColArray);




1,879,157✔





1996



    pInfo->lastColArray = NULL;




1,879,157✔





1997



  }










1998



  if (pInfo->lastBlockColArray) {




1,879,157✔





1999



    taosArrayDestroy(pInfo->lastBlockColArray);




1,879,157✔





2000



    pInfo->lastBlockColArray = NULL;




1,879,157✔





2001



  }










2002












2003



  blockDataDestroy(pInfo->pResBlock);




1,879,157✔





2004



  pInfo->pResBlock = NULL;




1,879,157✔





2005



}




1,879,157✔





2006












2007



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




7,672,686✔





2008



  int32_t                  code = TSDB_CODE_SUCCESS;




7,672,686✔





2009



  int32_t                  lino = 0;




7,672,686✔





2010



  STableScanInfo*          pInfo = pOperator->info;




7,672,686✔





2011



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




7,673,183✔





2012



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




7,673,183✔





2013



  SSDataBlock*             result = NULL;




7,675,668✔





2014












2015



  QRY_PARAM_CHECK(ppRes);




7,676,165✔





2016



  qTrace("%s call", __FUNCTION__);




7,676,165✔





2017












2018



  while (!result) {




15,184,841✔





2019



    code = createVTableScanInfoFromBatchParam(pOperator);




9,384,851✔





2020



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




9,370,935✔





2021



    pOperator->pOperatorGetParam = NULL;




9,366,462✔





2022



    QUERY_CHECK_CODE(code, lino, _end);




9,376,899✔





2023












2024



    if (pInfo->newReader) {




9,376,899✔





2025



      code = startNextGroupScan(pOperator, &result);




3,571,939✔





2026



      QUERY_CHECK_CODE(code, lino, _end);




3,586,849✔





2027



    } else {










2028



      code = doGroupedTableScan(pOperator, &result);




5,801,481✔





2029



      QUERY_CHECK_CODE(code, lino, _end);




5,799,990✔





2030



    }










2031



    if (!result) {




9,386,839✔





2032



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




3,586,849✔





2033



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










2034



      pInfo->currentBatchIdx++;




3,586,849✔





2035



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




3,585,855✔





2036



        // all batch scan finished










2037



        break;




1,879,157✔





2038



      }










2039



    }










2040



  }










2041












2042



  if (result) {




7,679,147✔





2043



    SSDataBlock* res = NULL;




5,799,990✔





2044



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




5,799,990✔





2045



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




5,798,499✔





2046



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




5,799,990✔





2047












2048



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




5,799,493✔





2049



    QUERY_CHECK_CODE(code, lino, _end);




5,799,990✔





2050












2051



    if (pInfo->cachedTagList) {




5,799,990✔





2052



      code = setTagValFromTagList(pOperator, res);




1,757,392✔





2053



      QUERY_CHECK_CODE(code, lino, _end);




1,757,392✔





2054



    }










2055












2056



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




5,799,990✔





2057



    pInfo->pResBlock = res;




5,799,990✔





2058



    blockDataDestroy(result);




5,799,990✔





2059



    (*ppRes) = res;




5,799,990✔





2060












2061



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




5,799,990✔





2062



  } else {










2063



    clearVstbBatchDynamicTableScanInfo(pInfo);




1,879,157✔





2064



    setOperatorCompleted(pOperator);




1,879,157✔





2065



  }










2066












2067



_end:




7,679,147✔





2068



  return code;




7,679,147✔





2069



}










2070












2071



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




14,197,795✔





2072



  int32_t                  code = TSDB_CODE_SUCCESS;




14,197,795✔





2073



  int32_t                  lino = 0;




14,197,795✔





2074



  STableScanInfo*          pInfo = pOperator->info;




14,197,795✔





2075



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




14,198,292✔





2076



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




14,197,795✔





2077












2078



  QRY_PARAM_CHECK(ppRes);




14,198,292✔





2079



  qTrace("%s call", __FUNCTION__);




14,198,789✔





2080












2081



  pOperator->dynamicTask = true;




14,198,789✔





2082












2083



  switch (type) {




14,201,274✔





2084



    case DYN_TYPE_STB_JOIN: {




208,552✔





2085



      code = doStbJoinDynamicTableScanNext(pOperator, ppRes);




208,552✔





2086



      QUERY_CHECK_CODE(code, lino, _end);




208,552✔





2087



      break;




208,552✔





2088



    }










2089



    case DYN_TYPE_VSTB_SINGLE_SCAN: {




6,315,563✔





2090



      code = doVstbSingleDynamicTableScanNext(pOperator, ppRes);




6,315,563✔





2091



      QUERY_CHECK_CODE(code, lino, _end);




6,315,563✔





2092



      break;




6,314,949✔





2093



    }










2094



    case DYN_TYPE_VSTB_BATCH_SCAN:




7,677,159✔





2095



      code = doVstbBatchDynamicTableScanNext(pOperator, ppRes);




7,677,159✔





2096



      QUERY_CHECK_CODE(code, lino, _end);




7,679,147✔





2097



      break;




7,679,147✔





2098



    default:




×







2099



      code = TSDB_CODE_INVALID_PARA;




×







2100



      QUERY_CHECK_CODE(code, lino, _end);




×







2101



      break;




×







2102



  }










2103












2104



_end:




14,203,262✔





2105



  return code;




14,203,262✔





2106



}










2107












2108



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




933,809,471✔





2109



  int32_t         code = TSDB_CODE_SUCCESS;




933,809,471✔





2110



  int32_t         lino = 0;




933,809,471✔





2111



  STableScanInfo* pInfo = pOperator->info;




933,809,471✔





2112



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




934,151,855✔





2113



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




934,053,985✔





2114



  QRY_PARAM_CHECK(ppRes);




933,909,810✔





2115



  qTrace("%s call", __FUNCTION__);




933,899,875✔





2116












2117



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




933,899,875✔





2118



    ETableScanDynType type = pOperator->pOperatorGetParam ?




14,113,469✔





2119



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




14,203,262✔





2120



                                                          DYN_TYPE_VSTB_BATCH_SCAN;










2121












2122



    code = doDynamicTableScanNext(pOperator, type, ppRes);




14,202,268✔





2123



    QUERY_CHECK_CODE(code, lino, _end);




14,203,262✔





2124












2125



    if (type != DYN_TYPE_STB_JOIN) {




14,202,648✔





2126



      return code;




13,994,096✔





2127



    }










2128



  }










2129












2130



  // scan table one by one sequentially










2131



  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {




919,882,032✔





2132



    int32_t       numOfTables = 0;




5,734,219✔





2133



    STableKeyInfo tInfo = {0};




5,734,219✔





2134



    pInfo->countState = TABLE_COUNT_STATE_END;




5,734,219✔





2135












2136



    while (1) {




5,351,408✔





2137



      SSDataBlock* result = NULL;




11,085,627✔





2138



      code = doGroupedTableScan(pOperator, &result);




11,083,521✔





2139



      QUERY_CHECK_CODE(code, lino, _end);




11,077,081✔





2140












2141



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




11,077,081✔





2142



        (*ppRes) = result;




5,689,031✔





2143



        return code;




5,694,587✔





2144



      }










2145












2146



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










2147



      pInfo->currentTable++;




5,393,164✔





2148












2149



      taosRLockLatch(&pTaskInfo->lock);




5,392,247✔





2150



      numOfTables = 0;




5,393,742✔





2151



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




5,393,742✔





2152



      if (code != TSDB_CODE_SUCCESS) {




5,392,262✔





2153



        taosRUnLockLatch(&pTaskInfo->lock);




×







2154



        TSDB_CHECK_CODE(code, lino, _end);




×







2155



      }










2156












2157



      if (pInfo->currentTable >= numOfTables) {




5,392,262✔





2158



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




39,034✔





2159



        taosRUnLockLatch(&pTaskInfo->lock);




39,034✔





2160



        (*ppRes) = NULL;




39,034✔





2161



        return code;




39,034✔





2162



      }










2163












2164



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




5,346,936✔





2165



      if (!tmp) {




5,350,847✔





2166



        taosRUnLockLatch(&pTaskInfo->lock);




×







2167



        (*ppRes) = NULL;




×







2168



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




×







2169



      }










2170












2171



      tInfo = *tmp;




5,350,847✔





2172



      taosRUnLockLatch(&pTaskInfo->lock);




5,346,013✔





2173












2174



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




5,352,349✔





2175



      QUERY_CHECK_CODE(code, lino, _end);




5,351,136✔





2176



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




5,351,136✔





2177



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










2178












2179



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




5,354,116✔





2180



      QUERY_CHECK_CODE(code, lino, _end);




5,349,297✔





2181



      pInfo->scanTimes = 0;




5,349,297✔





2182



    }










2183



  } else {  // scan table group by group sequentially










2184



    code = groupSeqTableScan(pOperator, ppRes);




913,896,671✔





2185



    QUERY_CHECK_CODE(code, lino, _end);




910,887,992✔





2186



  }










2187












2188



_end:




910,885,907✔





2189



  if (code != TSDB_CODE_SUCCESS) {




910,998,768✔





2190



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




2,699✔





2191



    pTaskInfo->code = code;




2,699✔





2192



    T_LONG_JMP(pTaskInfo->env, code);




2,699✔





2193



  }










2194












2195



  return code;




910,996,069✔





2196



}










2197












2198



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




31,369,696✔





2199



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




31,369,696✔





2200



  if (!pRecorder) {




31,282,113✔





2201



    return terrno;




×







2202



  }










2203



  STableScanInfo* pTableScanInfo = pOptr->info;




31,282,113✔





2204



  *pRecorder = pTableScanInfo->base.readRecorder;




31,289,875✔





2205



  *pOptrExplain = pRecorder;




31,371,568✔





2206



  *len = sizeof(SFileBlockLoadRecorder);




31,280,521✔





2207



  return 0;




31,310,017✔





2208



}










2209












2210



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




319,957,458✔





2211



  cleanupQueryTableDataCond(&pBase->cond);




319,957,458✔





2212



  cleanupQueryTableDataCond(&pBase->orgCond);




319,879,771✔





2213












2214



  if (pAPI->tsdReaderClose) {




319,965,062✔





2215



    pAPI->tsdReaderClose(pBase->dataReader);




320,023,518✔





2216



  }










2217



  pBase->dataReader = NULL;




319,594,481✔





2218












2219



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




319,724,450✔





2220



    taosArrayDestroy(pBase->matchInfo.pList);




319,930,538✔





2221



  }










2222












2223



  tableListDestroy(pBase->pTableListInfo);




319,448,684✔





2224



  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);




319,949,752✔





2225



  cleanupExprSupp(&pBase->pseudoSup);




320,149,303✔





2226



}




320,139,652✔





2227












2228



static void cleanReaderForVTable(STableScanInfo* pInfo){




1,437,531✔





2229



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




1,437,531✔





2230



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




1,437,531✔





2231



    while (pIter != NULL) {




1,448,142✔





2232



      void **reader = pIter;




10,611✔





2233



      if (*reader) {




10,611✔





2234



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




10,611✔





2235



          pInfo->base.dataReader = NULL;




10,611✔





2236



        }










2237



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




10,611✔





2238



      }










2239



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




10,611✔





2240



    }










2241



  }










2242



}




1,437,531✔





2243












2244



static void destroyTableScanOperatorInfo(void* param) {




292,241,853✔





2245



  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;




292,241,853✔





2246



  blockDataDestroy(pTableScanInfo->pResBlock);




292,241,853✔





2247



  blockDataDestroy(pTableScanInfo->pOrgBlock);




292,127,578✔





2248



  taosHashCleanup(pTableScanInfo->pIgnoreTables);




292,105,559✔





2249



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




291,988,710✔





2250



    cleanReaderForVTable(pTableScanInfo);




1,437,531✔





2251



    taosHashCleanup(pTableScanInfo->readerCache);




1,437,531✔





2252



  }










2253



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




292,010,416✔





2254



  taosArrayDestroy(pTableScanInfo->pBlockColMap);




292,370,706✔





2255



  taosMemoryFreeClear(param);




292,372,903✔





2256



}




292,370,258✔





2257












2258



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




292,013,514✔





2259



  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {




292,013,514✔





2260



    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);




13,558,720✔





2261



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




31,030,924✔





2262



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




17,500,577✔





2263



      if (pCol) {




17,487,123✔





2264



        pCol->info.noData = true;




17,487,349✔





2265



      }










2266



    }










2267



  }










2268



}




291,985,141✔





2269












2270



static int32_t resetTableScanOperatorState(SOperatorInfo* pOper) {




198,403✔





2271



  int32_t         code = TSDB_CODE_SUCCESS;




198,403✔





2272



  STableScanInfo*   pInfo = pOper->info;




198,403✔





2273



  pOper->status = OP_NOT_OPENED;




198,403✔





2274












2275



  pInfo->scanTimes = 0;




198,403✔





2276



  pInfo->currentGroupId = -1;




198,403✔





2277



  pInfo->tableEndIndex = -1;




198,403✔





2278



  pInfo->tableStartIndex = 0;




198,403✔





2279



  pInfo->currentTable = 0;




198,403✔





2280



  pInfo->scanMode = 0;




198,403✔





2281



  pInfo->countState = 0;




198,403✔





2282



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




198,403✔





2283












2284



  if (!pInfo->virtualStableScan) {




198,403✔





2285



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










2286



  //   cleanReaderForVTable(pInfo);










2287



  //   taosHashClear(pInfo->readerCache);










2288



  //   pInfo->readerCache = false;










2289



  // } else {










2290



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




64,605✔





2291



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




64,605✔





2292



    }










2293



    pInfo->base.dataReader = NULL;




64,605✔





2294



  }










2295



  tableListDestroy(pInfo->base.pTableListInfo);




198,403✔





2296



  pInfo->base.pTableListInfo = tableListCreate();




198,403✔





2297



  if (!pInfo->base.pTableListInfo) {




198,403✔





2298



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




×







2299



    return terrno;




×







2300



  }










2301



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




198,403✔





2302












2303



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




198,403✔





2304



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




198,403✔





2305



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




126,474✔





2306



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










2307



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




126,474✔





2308



    if (code) {




63,657✔





2309



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




×







2310



      return code;




×







2311



    }










2312



  }










2313












2314



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




198,403✔





2315



  cleanupQueryTableDataCond(&pInfo->base.cond);




198,403✔





2316



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




198,403✔





2317



  if (code) {




198,199✔





2318



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




×







2319



    return code;




×







2320



  }










2321



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




198,199✔





2322



    cleanupQueryTableDataCond(&pInfo->base.orgCond);




133,798✔





2323



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




133,798✔





2324



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




133,798✔





2325



  } 










2326












2327



  pOper->resultInfo.totalRows = 0;




198,199✔





2328



  blockDataEmpty(pInfo->pResBlock);




198,199✔





2329



  blockDataEmpty(pInfo->pOrgBlock);




198,199✔





2330



  taosHashClear(pInfo->pIgnoreTables);




198,199✔





2331



  taosArrayDestroy(pInfo->pBlockColMap);




198,403✔





2332



  pInfo->pBlockColMap = NULL;




198,403✔





2333



  return code;




198,199✔





2334



}










2335












2336



int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




292,285,432✔





2337



                                    STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










2338



                                    SOperatorInfo** pOptrInfo) {










2339



  QRY_PARAM_CHECK(pOptrInfo);




292,285,432✔





2340












2341



  int32_t         code = TSDB_CODE_SUCCESS;




292,326,797✔





2342



  int32_t         lino = 0;




292,326,797✔





2343



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




292,326,797✔





2344



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




291,965,014✔





2345



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




291,886,232✔





2346



    code = terrno;




×







2347



    goto _error;




×







2348



  }










2349












2350



  pOperator->pPhyNode = pTableScanNode;




291,889,394✔





2351



  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;




291,930,397✔





2352



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




291,972,138✔





2353












2354



  int32_t numOfCols = 0;




292,027,054✔





2355



  code =










2356



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




292,075,849✔





2357



  QUERY_CHECK_CODE(code, lino, _error);




292,078,718✔





2358












2359



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




292,078,718✔





2360



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




291,938,566✔





2361



  QUERY_CHECK_CODE(code, lino, _error);




291,739,550✔





2362












2363



  if (pScanNode->pScanPseudoCols != NULL) {




291,739,550✔





2364



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




48,135,477✔





2365



    pSup->pExprInfo = NULL;




48,136,964✔





2366



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




48,134,399✔





2367



    QUERY_CHECK_CODE(code, lino, _error);




48,125,702✔





2368












2369



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




48,125,702✔





2370



                                      &pTaskInfo->storageAPI.functionStore);










2371



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




48,113,968✔





2372



  }










2373












2374



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




292,024,450✔





2375



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




291,546,633✔





2376












2377



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




291,949,843✔





2378



  pInfo->base.readHandle = *readHandle;




291,325,463✔





2379



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




291,611,053✔





2380












2381



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




292,150,309✔





2382



  pInfo->sample.seed = taosGetTimestampSec();




291,787,318✔





2383












2384



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




291,939,312✔





2385



  initResultSizeInfo(&pOperator->resultInfo, 4096);




291,903,120✔





2386



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




291,771,922✔





2387



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




292,297,922✔





2388



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




292,039,977✔





2389












2390



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




291,817,052✔





2391



  QUERY_CHECK_CODE(code, lino, _error);




291,597,982✔





2392












2393



  pInfo->virtualStableScan = pScanNode->virtualStableScan;




291,597,982✔





2394



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




291,542,038✔





2395



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




1,434,926✔





2396



    pInfo->pResBlock = NULL;




1,436,040✔





2397



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




1,433,315✔





2398



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




1,436,040✔





2399



  }










2400












2401



  if (pInfo->virtualStableScan) {




291,832,699✔





2402



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




1,435,980✔





2403



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




1,437,034✔





2404



  }










2405












2406



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




291,916,269✔





2407



                            pTaskInfo->pStreamRuntimeInfo);




291,920,801✔





2408



  QUERY_CHECK_CODE(code, lino, _error);




291,496,003✔





2409












2410



  pInfo->currentGroupId = -1;




291,473,513✔





2411












2412



  pInfo->tableEndIndex = -1;




291,542,222✔





2413



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




291,636,616✔





2414



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




292,076,608✔





2415












2416



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




291,703,652✔





2417



                  pTaskInfo);










2418



  pOperator->exprSupp.numOfExprs = numOfCols;




291,726,609✔





2419












2420



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




291,419,843✔





2421



  pInfo->ignoreTag = false;




291,347,163✔





2422












2423



  pInfo->lastBatchIdx = -1;




292,065,867✔





2424



  pInfo->currentBatchIdx = 0;




291,802,232✔





2425



  pInfo->base.pTableListInfo = pTableListInfo;




291,346,076✔





2426



  if (readHandle->streamRtInfo == NULL) {




291,413,403✔





2427



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(1024 * 128, -1, .5);




291,976,854✔





2428



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




292,182,661✔





2429



      code = terrno;




×







2430



      QUERY_CHECK_CODE(code, lino, _error);




×







2431



    }










2432



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




292,092,928✔





2433



  }










2434












2435



  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




292,266,220✔





2436












2437



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




292,149,820✔





2438



                                         optrDefaultBufFn, getTableScannerExecInfo, optrDefaultGetNextExtFn, NULL);










2439












2440



  setOperatorResetStateFn(pOperator, resetTableScanOperatorState); 




292,086,372✔





2441



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










2442



  pOperator->cost.openCost = 0;




291,968,659✔





2443



  *pOptrInfo = pOperator;




291,891,639✔





2444



  return TSDB_CODE_SUCCESS;




291,530,026✔





2445












2446



_error:




22,490✔





2447



  if (pInfo != NULL) {




22,490✔





2448



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




22,490✔





2449



    destroyTableScanOperatorInfo(pInfo);




22,490✔





2450



  }










2451












2452



  if (pOperator != NULL) {




22,490✔





2453



    pOperator->info = NULL;




22,490✔





2454



    destroyOperator(pOperator);




22,490✔





2455



  }










2456



  pTaskInfo->code = code;




22,490✔





2457



  return code;




22,490✔





2458



}










2459












2460



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




×







2461



  QRY_PARAM_CHECK(pOptrInfo);




×







2462












2463



  int32_t         code = 0;




×







2464



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




×







2465



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




×







2466



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




×







2467



    code = terrno;




×







2468



    goto _end;




×







2469



  }










2470












2471



  pInfo->base.dataReader = pReadHandle;




×







2472



  //  pInfo->prevGroupId       = -1;










2473












2474



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




×







2475



                  pInfo, pTaskInfo);










2476



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




×







2477



                                         optrDefaultGetNextExtFn, NULL);










2478



  *pOptrInfo = pOperator;




×







2479



  return code;




×







2480












2481



_end:




×







2482



  if (pInfo != NULL) {




×







2483



    taosMemoryFree(pInfo);




×







2484



  }










2485












2486



  if (pOperator != NULL) {




×







2487



    taosMemoryFree(pOperator);




×







2488



  }










2489












2490



  pTaskInfo->code = code;




×







2491



  return code;




×







2492



}










2493












2494



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




13,634✔





2495



  int32_t code = TSDB_CODE_SUCCESS;




13,634✔





2496



  int32_t lino = 0;




13,634✔





2497



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




13,634✔





2498



    return code;




1,611✔





2499



  }










2500



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




12,023✔





2501



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




12,023✔





2502



  bool hasUnqualified = false;




12,023✔





2503












2504



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




12,023✔





2505



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




12,023✔





2506












2507



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




12,023✔





2508



         VALUE_GET_TRIVIAL_DATUM(&offset->primaryKey));










2509



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




12,023✔





2510



                        TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);










2511












2512



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




12,023✔





2513



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




12,023✔





2514



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




43,323,523✔





2515



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




43,311,500✔





2516



    void*    data = colDataGetData(pColPk, i);




43,311,500✔





2517



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




43,313,828✔





2518



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




2,328✔





2519



        QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY, lino, _end);




×







2520



      }










2521



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




2,328✔





2522



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




2,328✔





2523



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




2,328✔





2524



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




2,328✔





2525



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




2,328✔





2526



      taosMemoryFree(tmq);




2,328✔





2527



    } else {










2528



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




43,309,172✔





2529



    }










2530












2531



    if (!p[i]) {




43,311,500✔





2532



      hasUnqualified = true;




15,442,502✔





2533



    }










2534



  }










2535












2536



  if (hasUnqualified) {




12,023✔





2537



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




4,061✔





2538



    QUERY_CHECK_CODE(code, lino, _end);




4,061✔





2539



  }










2540












2541



_end:




12,023✔





2542



  taosMemoryFree(p);




12,023✔





2543



  if (code != TSDB_CODE_SUCCESS) {




12,023✔





2544



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




×







2545



  }










2546



  return code;




12,023✔





2547



}










2548












2549



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




1,204,902,108✔





2550



  int32_t p1 = *(int32_t*)param1;




1,204,902,108✔





2551



  int32_t p2 = *(int32_t*)param2;




1,204,927,523✔





2552












2553



  if (p1 == p2) {




1,204,962,400✔





2554



    return 0;




×







2555



  } else {










2556



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




1,204,962,400✔





2557



  }










2558



}










2559












2560



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




89,396,947✔





2561



  int32_t         code = TSDB_CODE_SUCCESS;




89,396,947✔





2562



  int32_t         lino = 0;




89,396,947✔





2563



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




89,396,947✔





2564



  SOperatorInfo*  pOperator = pInfo->pStreamScanOp;




89,398,916✔





2565



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




89,398,916✔





2566



  const char*     id = GET_TASKID(pTaskInfo);




89,399,250✔





2567



  SArray* pColList = NULL;




89,398,916✔





2568












2569



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




89,398,916✔





2570



  QUERY_CHECK_CODE(code, lino, _end);




89,397,250✔





2571












2572



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




89,397,250✔





2573



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




89,395,945✔





2574



  pBlockInfo->type = STREAM_NORMAL;




89,396,279✔





2575



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




89,396,613✔





2576












2577



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




89,395,611✔





2578



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




89,396,947✔





2579












2580



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




89,396,916✔





2581



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




89,397,281✔





2582












2583



  // todo extract method










2584



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




470,228,293✔





2585



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




380,829,625✔





2586



    if (!pColMatchInfo->needOutput) {




380,821,555✔





2587



      continue;




630✔





2588



    }










2589












2590



    bool colExists = false;




380,819,422✔





2591



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




1,176,834,740✔





2592



      SColumnInfoData* pResCol = NULL;




1,176,540,705✔





2593



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




1,176,503,217✔





2594



      QUERY_CHECK_CODE(code, lino, _end);




1,176,443,756✔





2595












2596



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




1,176,443,756✔





2597



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




380,854,464✔





2598



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




380,843,338✔





2599



        QUERY_CHECK_CODE(code, lino, _end);




380,723,102✔





2600












2601



        colExists = true;




380,723,102✔





2602



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




380,723,102✔





2603



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




380,835,617✔





2604



        break;




380,835,617✔





2605



      }










2606



    }










2607












2608



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










2609



    if (!colExists) {




380,830,382✔





2610



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




×







2611



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




×







2612



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




×







2613



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




×







2614



    }










2615



  }










2616












2617



  // currently only the tbname pseudo column










2618



  if (pInfo->numOfPseudoExpr > 0) {




89,397,684✔





2619



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




108,385,987✔





2620



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




54,192,572✔





2621



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










2622



    if (code) {




54,190,234✔





2623



      QUERY_CHECK_CODE(code, lino, _end);




×







2624



    }










2625












2626



    // reset the error code.










2627



    terrno = 0;




54,190,234✔





2628












2629



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




219,743,173✔





2630



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




165,548,879✔





2631



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




165,552,605✔





2632



    }










2633



  }










2634












2635



  taosArraySort(pColList, colIdComparFn);




89,383,353✔





2636












2637



  int32_t i = 0, j = 0;




89,397,264✔





2638



  while (i < taosArrayGetSize(pColList)) {




635,671,426✔





2639



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




546,241,294✔





2640



    if (slot1 > j) {




546,274,162✔





2641



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




×







2642



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




×







2643



      j += 1;




×







2644



    } else {










2645



      i += 1;




546,274,162✔





2646



      j += 1;




546,274,162✔





2647



    }










2648



  }










2649












2650



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




89,394,932✔





2651



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




630✔





2652



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




630✔





2653



    j += 1;




630✔





2654



  }










2655












2656



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




89,394,302✔





2657



  QUERY_CHECK_CODE(code, lino, _end);




89,392,387✔





2658












2659



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




89,392,387✔





2660



  QUERY_CHECK_CODE(code, lino, _end);




89,391,165✔





2661












2662



_end:




89,391,165✔





2663



  taosArrayDestroy(pColList);




89,047,200✔





2664



  if (code != TSDB_CODE_SUCCESS) {




89,393,038✔





2665



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




×







2666



  }










2667



  return code;




89,390,938✔





2668



}










2669












2670



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




6,399,972✔





2671



  int32_t code = TSDB_CODE_SUCCESS;




6,399,972✔





2672



  int32_t lino = 0;




6,399,972✔





2673



  SValue  val = {0};




6,399,972✔





2674



  if (hasPrimaryKey) {




6,400,546✔





2675



    code = doBlockDataPrimaryKeyFilter(pBlock, offset);




13,634✔





2676



    if (code != TSDB_CODE_SUCCESS) {




13,634✔





2677



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




×







2678



      return code;




×







2679



    }










2680



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




13,634✔





2681












2682



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




13,634✔





2683



      return code;




3,770✔





2684



    }










2685



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




9,864✔





2686



    val.type = pColPk->info.type;




9,864✔





2687



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




9,864✔





2688



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




621✔





2689



        return TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY;




×







2690



      }










2691



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




621✔





2692



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




621✔





2693



      val.nData = varDataLen(tmp);




621✔





2694



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




621✔





2695



    } else {










2696



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




9,243✔





2697



    }










2698



  }










2699



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




6,396,776✔





2700












2701



_end:




6,395,911✔





2702



  if (code != TSDB_CODE_SUCCESS) {




6,396,198✔





2703



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




×







2704



  }










2705



  return code;




6,395,327✔





2706



}










2707












2708



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




114,933,042✔





2709



  int32_t        code = TSDB_CODE_SUCCESS;




114,933,042✔





2710



  int32_t        lino = 0;




114,933,042✔





2711



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




114,933,042✔





2712



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




114,932,700✔





2713












2714



  SStreamScanInfo* pInfo = pOperator->info;




114,933,118✔





2715



  const char*      id = GET_TASKID(pTaskInfo);




114,934,401✔





2716












2717



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




114,934,487✔





2718












2719



  if (isTaskKilled(pTaskInfo)) {




114,935,413✔





2720



    (*ppRes) = NULL;




×







2721



    return pTaskInfo->code;




×







2722



  }










2723












2724



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




114,934,337✔





2725



    while (1) {




3,770✔





2726



      SSDataBlock* pResult = NULL;




5,734,219✔





2727



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




5,734,219✔





2728



      QUERY_CHECK_CODE(code, lino, _end);




5,732,459✔





2729












2730



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




5,732,459✔





2731



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




5,693,986✔





2732



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




5,694,339✔





2733



        QUERY_CHECK_CODE(code, lino, _end);




5,692,841✔





2734



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




5,692,841✔





2735



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




5,695,484✔





2736



          (*ppRes) = pResult;




5,691,415✔





2737



          return code;




5,691,415✔





2738



        }










2739



      } else {










2740



        break;










2741



      }










2742



    }










2743












2744



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




39,034✔





2745



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




39,034✔





2746












2747



    pTSInfo->base.dataReader = NULL;




39,034✔





2748



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




39,034✔





2749



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




39,034✔





2750



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




39,034✔





2751



      (*ppRes) = NULL;




9,856✔





2752



      return code;




9,856✔





2753



    }










2754












2755



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




29,178✔





2756



  }










2757












2758



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




109,232,732✔





2759



    while (1) {




730,785✔





2760



      bool hasResult =










2761



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




109,964,114✔





2762












2763



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




109,946,421✔





2764



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




109,965,238✔





2765












2766



      // curVersion move to next










2767



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




109,965,939✔





2768












2769



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










2770



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




109,960,931✔





2771












2772



      if (hasResult) {




109,954,265✔





2773



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




89,383,640✔





2774



               pTaskInfo->streamInfo.currentOffset.version);










2775



        blockDataCleanup(pInfo->pRes);




89,392,608✔





2776



        code = setBlockIntoRes(pInfo, pRes);




89,395,910✔





2777



        QUERY_CHECK_CODE(code, lino, _end);




89,391,548✔





2778



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




89,391,548✔





2779



               pTaskInfo->streamInfo.currentOffset.version);










2780



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




89,393,250✔





2781



          (*ppRes) = pInfo->pRes;




88,664,036✔





2782



          return code;




88,662,032✔





2783



        }










2784



      } else {










2785



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




20,570,625✔





2786



        (*ppRes) = NULL;




20,570,625✔





2787



        return code;




20,570,625✔





2788



      }










2789



    }










2790



  } else {










2791



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




×







2792



    (*ppRes) = NULL;




×







2793



    return code;




×







2794



  }










2795












2796



_end:




×







2797



  if (code != TSDB_CODE_SUCCESS) {




×







2798



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




×







2799



    pTaskInfo->code = code;




×







2800



    T_LONG_JMP(pTaskInfo->env, code);




×







2801



  }










2802



  (*ppRes) = NULL;




×







2803



  return code;




×







2804



}










2805












2806



static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {




×







2807



  SSDataBlock* pRes = NULL;




×







2808



  int32_t      code = doQueueScanNext(pOperator, &pRes);




×







2809



  return pRes;




×







2810



}










2811












2812



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




314,328✔





2813



  int32_t code = TSDB_CODE_SUCCESS;




314,328✔





2814



  int32_t lino = 0;




314,328✔





2815



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




314,328✔





2816



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




314,924✔





2817












2818



  // Transfer the Array of STableKeyInfo into uid list.










2819



  int32_t size = 0;




314,924✔





2820



  code = tableListGetSize(pTableListInfo, &size);




315,189✔





2821



  QUERY_CHECK_CODE(code, lino, _end);




314,859✔





2822



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




9,382,281✔





2823



    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);




9,067,092✔





2824



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




9,066,545✔





2825



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




9,066,545✔





2826



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




9,067,422✔





2827



  }










2828












2829



  (*ppArrayRes) = tableIdList;




315,189✔





2830












2831



_end:




314,601✔





2832



  if (code != TSDB_CODE_SUCCESS) {




314,923✔





2833



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




×







2834



  }










2835



  return code;




314,923✔





2836



}










2837












2838



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




1,459,376✔





2839



  int32_t        code = TSDB_CODE_SUCCESS;




1,459,376✔





2840



  int32_t        lino = 0;




1,459,376✔





2841



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,459,376✔





2842



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,459,376✔





2843












2844



  SStreamRawScanInfo* pInfo = pOperator->info;




1,459,376✔





2845



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




1,459,376✔





2846



  pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL;




1,459,376✔





2847












2848



  qDebug("tmqsnap doRawScan called");




1,459,376✔





2849



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




1,459,376✔





2850



    bool hasNext = false;




1,454,624✔





2851



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




1,454,624✔





2852



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




1,453,788✔





2853



      if (code != TSDB_CODE_SUCCESS) {




1,452,640✔





2854



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




×







2855



        QUERY_CHECK_CODE(code, lino, _end);




×







2856



      }










2857



    }










2858












2859



    if (pInfo->dataReader && hasNext) {




1,453,476✔





2860



      if (isTaskKilled(pTaskInfo)) {




707,414✔





2861



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




×







2862



        return code;




×







2863



      }










2864












2865



      SSDataBlock* pBlock = NULL;




707,701✔





2866



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




707,127✔





2867



      QUERY_CHECK_CODE(code, lino, _end);




706,553✔





2868












2869



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




706,553✔





2870



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




707,127✔





2871



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




707,127✔





2872



        QUERY_CHECK_CODE(code, lino, _end);




707,127✔





2873



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




707,127✔





2874



        (*ppRes) = pBlock;




707,414✔





2875



        return code;




707,701✔





2876



      }










2877



    }










2878












2879



    SMetaTableInfo mtInfo = {0};




746,349✔





2880



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




746,636✔





2881



    QUERY_CHECK_CODE(code, lino, _end);




744,896✔





2882



    if (code != 0) {




744,896✔





2883



      destroyMetaTableInfo(&mtInfo);










2884



      QUERY_CHECK_CODE(code, lino, _end);




×







2885



    }










2886



    STqOffsetVal offset = {0};




744,896✔





2887



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




744,618✔





2888



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




11,820✔





2889



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




11,820✔





2890



    } else {










2891



      SValue val = {0};




734,529✔





2892



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




734,529✔





2893



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




733,964✔





2894



    }










2895



    destroyMetaTableInfo(&mtInfo);










2896



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




746,923✔





2897



    QUERY_CHECK_CODE(code, lino, _end);




746,923✔





2898



    (*ppRes) = NULL;




746,923✔





2899



    return code;




746,923✔





2900



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




4,752✔





2901



    SSnapContext* sContext = pInfo->sContext;




4,752✔





2902



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




39,776✔





2903



      void*   data = NULL;




39,776✔





2904



      int32_t dataLen = 0;




39,776✔





2905



      int16_t type = 0;




39,776✔





2906



      int64_t uid = 0;




39,776✔





2907



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




39,776✔





2908



        qError("tmqsnap getTableInfoFromSnapshot error");




×







2909



        taosMemoryFreeClear(data);




×







2910



        break;




×







2911



      }










2912












2913



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




39,776✔





2914



        STqOffsetVal offset = {0};




4,752✔





2915



        SValue       val = {0};




4,752✔





2916



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




×







2917



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




4,752✔





2918



        QUERY_CHECK_CODE(code, lino, _end);




4,752✔





2919



        break;




4,752✔





2920



      } else {










2921



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




35,024✔





2922



        SMqMetaRsp tmpMetaRsp = {0};




35,024✔





2923



        tmpMetaRsp.resMsgType = type;




35,024✔





2924



        tmpMetaRsp.metaRspLen = dataLen;




35,024✔





2925



        tmpMetaRsp.metaRsp = data;




35,024✔





2926



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




35,024✔





2927



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




4,224✔





2928



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




4,224✔





2929












2930



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




4,224✔





2931



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




4,224✔





2932



        }










2933



        int32_t  tempRes = TSDB_CODE_SUCCESS;




35,024✔





2934



        uint32_t len = 0;




35,024✔





2935



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




35,024✔





2936



        if (TSDB_CODE_SUCCESS != tempRes) {




35,024✔





2937



          qError("tmqsnap tEncodeMqMetaRsp error");




×







2938



          taosMemoryFreeClear(data);




×







2939



          break;




×







2940



        }










2941












2942



        int32_t tLen = sizeof(SMqRspHead) + len;




35,024✔





2943



        void*   tBuf = taosMemoryCalloc(1, tLen);




35,024✔





2944



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




35,024✔





2945












2946



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




35,024✔





2947



        SEncoder encoder = {0};




35,024✔





2948



        tEncoderInit(&encoder, metaBuff, len);




35,024✔





2949



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




35,024✔





2950



        if (tempLen < 0) {




35,024✔





2951



          qError("tmqsnap tEncodeMqMetaRsp error");




×







2952



          tEncoderClear(&encoder);




×







2953



          taosMemoryFreeClear(tBuf);




×







2954



          taosMemoryFreeClear(data);




×







2955



          break;




×







2956



        }










2957



        taosMemoryFreeClear(data);




35,024✔





2958



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




35,024✔





2959



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




35,024✔





2960












2961



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




35,024✔





2962



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




35,024✔





2963



      }










2964



    }










2965












2966



    (*ppRes) = NULL;




4,752✔





2967



    return code;




4,752✔





2968



  }










2969












2970



_end:




×







2971



  if (code != TSDB_CODE_SUCCESS) {




×







2972



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




×







2973



    pTaskInfo->code = code;




×







2974



    T_LONG_JMP(pTaskInfo->env, code);




×







2975



  }










2976












2977



  (*ppRes) = NULL;




×







2978



  return code;




×







2979



}










2980












2981



static void destroyTmqRawScanOperatorInfo(void* param) {




113,083✔





2982



  SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;




113,083✔





2983



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




113,083✔





2984



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




113,083✔





2985



  tableListDestroy(pRawScan->pTableListInfo);




113,083✔





2986



  taosMemoryFree(pRawScan);




113,083✔





2987



}




113,083✔





2988












2989



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










2990



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










2991



// and schemas are decided when scanning










2992



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




112,457✔





2993



  // create operator










2994



  // create tb reader










2995



  // create meta reader










2996



  // create tq reader










2997












2998



  QRY_PARAM_CHECK(pOptrInfo);




112,457✔





2999



  int32_t code = TSDB_CODE_SUCCESS;




113,083✔





3000



  int32_t lino = 0;




113,083✔





3001












3002



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




113,083✔





3003



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




112,787✔





3004



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




112,787✔





3005



    code = terrno;




×







3006



    lino = __LINE__;




×







3007



    goto _end;




×







3008



  }










3009












3010



  pInfo->pTableListInfo = tableListCreate();




112,787✔





3011



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




112,787✔





3012



  pInfo->vnode = pHandle->vnode;




112,787✔





3013



  pInfo->pAPI = &pTaskInfo->storageAPI;




112,787✔





3014












3015



  pInfo->sContext = pHandle->sContext;




112,787✔





3016



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




113,083✔





3017



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




112,787✔





3018



                  pTaskInfo);










3019












3020



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




112,787✔





3021



                                         NULL, optrDefaultGetNextExtFn, NULL);










3022



  *pOptrInfo = pOperator;




112,787✔





3023



  return code;




113,083✔





3024












3025



_end:




×







3026



  if (code != TSDB_CODE_SUCCESS) {




×







3027



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




×







3028



  }










3029



  taosMemoryFree(pInfo);




×







3030



  taosMemoryFree(pOperator);




×







3031



  pTaskInfo->code = code;




×







3032



  return code;




×







3033



}










3034












3035



void destroyTmqScanOperatorInfo(void* param) {




314,924✔





3036



  if (param == NULL) {




314,924✔





3037



    return;




×







3038



  }










3039












3040



  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;




314,924✔





3041



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




314,924✔





3042



    destroyOperator(pStreamScan->pTableScanOp);




315,189✔





3043



  }










3044












3045



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




314,924✔





3046



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




315,189✔





3047



  }










3048



  if (pStreamScan->pVtableMergeHandles) {




315,189✔





3049



    taosHashCleanup(pStreamScan->pVtableMergeHandles);




×







3050



    pStreamScan->pVtableMergeHandles = NULL;




×







3051



  }










3052



  if (pStreamScan->pVtableMergeBuf) {




315,189✔





3053



    destroyDiskbasedBuf(pStreamScan->pVtableMergeBuf);




×







3054



    pStreamScan->pVtableMergeBuf = NULL;




×







3055



  }










3056



  if (pStreamScan->pVtableReadyHandles) {




315,189✔





3057



    taosArrayDestroy(pStreamScan->pVtableReadyHandles);




×







3058



    pStreamScan->pVtableReadyHandles = NULL;




×







3059



  }










3060



  if (pStreamScan->pTableListInfo) {




314,926✔





3061



    tableListDestroy(pStreamScan->pTableListInfo);




×







3062



    pStreamScan->pTableListInfo = NULL;




×







3063



  }










3064



  if (pStreamScan->matchInfo.pList) {




315,189✔





3065



    taosArrayDestroy(pStreamScan->matchInfo.pList);




315,189✔





3066



  }










3067



  if (pStreamScan->pPseudoExpr) {




315,189✔





3068



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




183,130✔





3069



    taosMemoryFree(pStreamScan->pPseudoExpr);




182,867✔





3070



  }










3071












3072



  cleanupExprSupp(&pStreamScan->tbnameCalSup);




314,926✔





3073



  cleanupExprSupp(&pStreamScan->tagCalSup);




315,189✔





3074












3075



  blockDataDestroy(pStreamScan->pRes);




315,189✔





3076



  blockDataDestroy(pStreamScan->pUpdateRes);




315,189✔





3077



  blockDataDestroy(pStreamScan->pDeleteDataRes);




315,189✔





3078



  blockDataDestroy(pStreamScan->pUpdateDataRes);




315,189✔





3079



  blockDataDestroy(pStreamScan->pCreateTbRes);




315,189✔





3080



  taosArrayDestroy(pStreamScan->pBlockLists);




315,189✔





3081



  blockDataDestroy(pStreamScan->pCheckpointRes);




315,189✔





3082












3083



  taosMemoryFree(pStreamScan);




314,899✔





3084



}










3085












3086



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




×







3087



  int32_t code = TSDB_CODE_SUCCESS;




×







3088



  int32_t lino = 0;




×







3089



  pBlock->info.rowSize += bytes;




×







3090



  SColumnInfoData infoData = {0};




×







3091



  infoData.info.type = type;




×







3092



  infoData.info.bytes = bytes;




×







3093



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




×







3094



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




×







3095












3096



_end:




×







3097



  if (code != TSDB_CODE_SUCCESS) {




×







3098



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




×







3099



  }










3100



  return code;




×







3101



}










3102












3103



 int32_t createTmqScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,




314,923✔





3104



                                                  SNode* pTagCond, STableListInfo* pTableListInfo,










3105



                                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3106



  QRY_PARAM_CHECK(pOptrInfo);




314,923✔





3107












3108



  int32_t          code = TSDB_CODE_SUCCESS;




315,189✔





3109



  int32_t          lino = 0;




315,189✔





3110



  SArray*          pColIds = NULL;




315,189✔





3111



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




315,189✔





3112



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




315,189✔





3113



  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;




315,189✔





3114



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




315,189✔





3115












3116



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




315,189✔





3117



    code = terrno;




×







3118



    goto _error;




×







3119



  }










3120












3121



  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;




315,189✔





3122



  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;




315,189✔





3123












3124



  pInfo->pTagCond = pTagCond;




315,189✔





3125



  pInfo->pGroupTags = pTableScanNode->pGroupTags;




315,189✔





3126












3127



  int32_t numOfCols = 0;




315,189✔





3128



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




315,189✔





3129



  if (code != TSDB_CODE_SUCCESS) {




315,189✔





3130



    goto _error;




×







3131



  }










3132












3133



  SDataType pkType = {0};




315,189✔





3134



  pInfo->primaryKeyIndex = -1;




315,189✔





3135



  pInfo->basic.primaryPkIndex = -1;




315,189✔





3136



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




315,189✔





3137



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




315,189✔





3138



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




315,189✔





3139












3140



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




1,975,216✔





3141



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




1,660,027✔





3142



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




1,660,027✔





3143












3144



    int16_t colId = id->colId;




1,660,027✔





3145



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




1,660,027✔





3146



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




1,660,027✔





3147












3148



    if (id->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




1,660,027✔





3149



      pInfo->primaryTsIndex = id->dstSlotId;




315,189✔





3150



    }










3151



    if (id->isPk) {




1,660,027✔





3152



      pInfo->primaryKeyIndex = id->dstSlotId;




1,492✔





3153



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




1,492✔





3154



      pkType = id->dataType;




1,492✔





3155



    }










3156



  }










3157












3158



  pInfo->pPartTbnameSup = NULL;




315,189✔





3159



  if (pTableScanNode->pSubtable != NULL) {




315,189✔





3160



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




×







3161



    if (pSubTableExpr == NULL) {




×







3162



      code = terrno;




×







3163



      goto _error;




×







3164



    }










3165












3166



    pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;




×







3167



    code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);




×







3168



    QUERY_CHECK_CODE(code, lino, _error);




×







3169












3170



    if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) {




×







3171



      goto _error;




×







3172



    }










3173



  }










3174












3175



  if (pTableScanNode->pTags != NULL) {




315,189✔





3176



    int32_t    numOfTags;




×







3177



    SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags);




×







3178



    if (pTagExpr == NULL) {




×







3179



      goto _error;




×







3180



    }










3181



    code = initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore);




×







3182



    if (code != 0) {




×







3183



      goto _error;




×







3184



    }










3185



  }










3186












3187



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




315,189✔





3188



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




315,189✔





3189












3190



  if (pHandle->vnode) {




315,189✔





3191



    SOperatorInfo* pTableScanOp = NULL;




315,189✔





3192



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




315,189✔





3193



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




314,286✔





3194



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




265✔





3195



      goto _error;




×







3196



    }










3197












3198



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




314,077✔





3199



    if (pHandle->version > 0) {




314,036✔





3200



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




314,585✔





3201



    }










3202












3203



    STableKeyInfo* pList = NULL;




314,682✔





3204



    int32_t        num = 0;




314,924✔





3205



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




314,054✔





3206



    QUERY_CHECK_CODE(code, lino, _error);




314,302✔





3207












3208



    if (pHandle->initTableReader) {




314,302✔





3209



      pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;




314,302✔





3210



      pTSInfo->base.dataReader = NULL;




314,624✔





3211



    }










3212












3213



    if (pHandle->initTqReader) {




313,491✔





3214



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




314,038✔





3215



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




314,924✔





3216



    } else {










3217



      pInfo->tqReader = pHandle->tqReader;




×







3218



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




×







3219



    }










3220












3221



    pInfo->pUpdateInfo = NULL;




315,189✔





3222



    pInfo->pTableScanOp = pTableScanOp;




315,189✔





3223



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




315,189✔





3224



      pAPI->stateStore.streamStateSetNumber(pInfo->pTableScanOp->pTaskInfo->streamInfo.pState, -1,




×







3225



                                            pInfo->primaryTsIndex);










3226



    }










3227












3228



    pInfo->readHandle = *pHandle;




315,189✔





3229



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




315,189✔





3230



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




314,924✔





3231



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




314,859✔





3232



    pInfo->hasPart = false;




314,064✔





3233












3234



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




314,064✔





3235



    QUERY_CHECK_CODE(code, lino, _error);




315,189✔





3236












3237



    // set the extract column id to streamHandle










3238



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




315,189✔





3239



    QUERY_CHECK_CODE(code, lino, _error);




315,189✔





3240












3241



    SArray* tableIdList = NULL;




315,189✔





3242



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




315,189✔





3243



    QUERY_CHECK_CODE(code, lino, _error);




314,601✔





3244



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




314,601✔





3245



    QUERY_CHECK_CODE(code, lino, _error);




315,189✔





3246



    taosArrayDestroy(tableIdList);




315,189✔





3247



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




315,189✔





3248



  } else {










3249



    taosArrayDestroy(pColIds);




×







3250



    tableListDestroy(pTableListInfo);




×







3251



  }










3252












3253



  // clear the local variable to avoid repeatly free










3254



  pColIds = NULL;




315,189✔





3255












3256



  // create the pseduo columns info










3257



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




315,189✔





3258



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




183,130✔





3259



    QUERY_CHECK_CODE(code, lino, _error);




183,130✔





3260



  }










3261












3262



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




315,189✔





3263



  QUERY_CHECK_CODE(code, lino, _error);




315,189✔





3264












3265



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




315,189✔





3266



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




315,189✔





3267



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




315,189✔





3268



  QUERY_CHECK_CODE(code, lino, _error);




314,867✔





3269












3270



  pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;




314,867✔





3271



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




315,189✔





3272



  pInfo->groupId = 0;




314,867✔





3273



  pInfo->igCheckGroupId = false;




314,867✔





3274



  pInfo->pStreamScanOp = pOperator;




314,867✔





3275



  pInfo->deleteDataIndex = 0;




314,867✔





3276



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




314,867✔





3277



  QUERY_CHECK_CODE(code, lino, _error);




315,189✔





3278












3279



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




315,189✔





3280



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




314,867✔





3281



  QUERY_CHECK_CODE(code, lino, _error);




314,907✔





3282












3283



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




314,907✔





3284



  pInfo->partitionSup.needCalc = false;




314,907✔





3285



  pInfo->igCheckUpdate = pTableScanNode->igCheckUpdate;




314,907✔





3286



  pInfo->igExpired = pTableScanNode->igExpired;




314,867✔





3287



  pInfo->twAggSup.maxTs = INT64_MIN;




314,907✔





3288



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




314,867✔





3289



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




314,867✔





3290



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




314,867✔





3291



  pInfo->pFillSup = NULL;




315,189✔





3292



  pInfo->useGetResultRange = false;




314,867✔





3293



  pInfo->pRangeScanRes = NULL;




314,867✔





3294












3295



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




314,867✔





3296



  QUERY_CHECK_CODE(code, lino, _error);




315,189✔





3297












3298



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




315,189✔





3299



                  pTaskInfo);










3300



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




315,189✔





3301












3302



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




315,189✔





3303



                                         NULL, optrDefaultGetNextExtFn, NULL);










3304












3305



  *pOptrInfo = pOperator;




314,867✔





3306



  return code;




315,189✔





3307












3308



_error:




×







3309



  if (pColIds != NULL) {




×







3310



    taosArrayDestroy(pColIds);




×







3311



  }










3312












3313



  if (pInfo != NULL && pInfo->pTableScanOp != NULL) {




×







3314



    STableScanInfo* p = (STableScanInfo*)pInfo->pTableScanOp->info;




×







3315



    if (p != NULL) {




×







3316



      p->base.pTableListInfo = NULL;




×







3317



    }










3318



    destroyTmqScanOperatorInfo(pInfo);




×







3319



  }










3320












3321



  if (pOperator != NULL) {




×







3322



    pOperator->info = NULL;




×







3323



    destroyOperator(pOperator);




×







3324



  }










3325



  pTaskInfo->code = code;




×







3326



  return code;




×







3327



}










3328












3329



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




8,215,855✔





3330



  int32_t        code = TSDB_CODE_SUCCESS;




8,215,855✔





3331



  int32_t        lino = 0;




8,215,855✔





3332



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




8,215,855✔





3333



  STagScanInfo*  pInfo = pOperator->info;




8,217,346✔





3334



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




8,216,352✔





3335



  int32_t        count = pRes->info.rows;




8,214,861✔





3336












3337



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




8,216,352✔





3338



  if (!item) {




8,215,855✔





3339



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3340



           GET_TASKID(pTaskInfo));










3341



    tDecoderClear(&(*mr).coder);




×







3342



    goto _end;




×







3343



  }










3344












3345



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




8,215,855✔





3346



  tDecoderClear(&(*mr).coder);




8,217,843✔





3347



  if (code != TSDB_CODE_SUCCESS) {




8,217,346✔





3348



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3349



           GET_TASKID(pTaskInfo));










3350



    goto _end;




×







3351



  }










3352












3353



  char str[512];




8,217,242✔





3354



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




26,054,912✔





3355



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




17,838,063✔





3356












3357



    // refactor later










3358



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




17,839,057✔





3359



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




2,206,810✔





3360



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




2,206,313✔





3361



      QUERY_CHECK_CODE(code, lino, _end);




2,206,313✔





3362



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




15,633,738✔





3363



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




3,154,652✔





3364



      QUERY_CHECK_CODE(code, lino, _end);




3,154,652✔





3365



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




12,479,086✔





3366



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




14,606✔





3367



      QUERY_CHECK_CODE(code, lino, _end);




14,606✔





3368



    } else {  // it is a tag value










3369



      STagVal val = {0};




12,464,977✔





3370



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




12,464,977✔





3371



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




12,464,977✔





3372












3373



      char* data = NULL;




12,464,480✔





3374



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




12,464,480✔





3375



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




12,462,672✔





3376



      } else {










3377



        data = (char*)p;




1,311✔





3378



      }










3379












3380



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




12,463,486✔





3381



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




12,462,989✔





3382



      QUERY_CHECK_CODE(code, lino, _end);




12,463,486✔





3383












3384



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




12,463,486✔





3385



          (data != NULL)) {










3386



        taosMemoryFree(data);




4,677,442✔





3387



      }










3388



    }










3389



  }










3390












3391



_end:




8,218,837✔





3392



  if (code != TSDB_CODE_SUCCESS) {




8,216,849✔





3393



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




×







3394



    pTaskInfo->code = code;




×







3395



  } else {










3396



    pRes->info.rows++;




8,216,849✔





3397



  }










3398












3399



  return code;




8,217,346✔





3400



}










3401












3402



static void tagScanFreeUidTag(void* p) {




8,434,211✔





3403



  STUidTagInfo* pInfo = p;




8,434,211✔





3404



  if (pInfo->pTagVal != NULL) {




8,434,211✔





3405



    taosMemoryFree(pInfo->pTagVal);




8,435,717✔





3406



  }










3407



}




8,433,602✔





3408












3409



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




1,600,953✔





3410



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




1,600,953✔





3411



  if (pColumnData == NULL) {




1,599,522✔





3412



    return terrno;




×







3413



  }










3414












3415



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




1,599,522✔





3416



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




1,600,476✔





3417



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




1,599,987✔





3418



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




1,600,953✔





3419












3420



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




1,599,498✔





3421



  if (code != TSDB_CODE_SUCCESS) {




1,600,464✔





3422



    terrno = code;




×







3423



    taosMemoryFree(pColumnData);




×







3424



    return terrno;




×







3425



  }










3426












3427



  pParam->columnData = pColumnData;




1,600,464✔





3428



  pParam->colAlloced = true;




1,599,987✔





3429



  return TSDB_CODE_SUCCESS;




1,599,644✔





3430



}










3431












3432



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




9,863,004✔





3433



  int32_t                code = TSDB_CODE_SUCCESS;




9,863,004✔





3434



  int32_t                lino = 0;




9,863,004✔





3435



  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;




9,863,004✔





3436



  SColumnNode*           pSColumnNode = NULL;




9,863,004✔





3437



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




9,862,514✔





3438



    pSColumnNode = *(SColumnNode**)pNode;




2,777,649✔





3439



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




7,087,505✔





3440



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




474✔





3441



    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {




474✔





3442



      pSColumnNode = NULL;




×







3443



      pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);




×







3444



      if (NULL == pSColumnNode) {




×







3445



        return DEAL_RES_ERROR;




×







3446



      }










3447



      pSColumnNode->colId = -1;




×







3448



      pSColumnNode->colType = COLUMN_TYPE_TBNAME;




×







3449



      pSColumnNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




×







3450



      pSColumnNode->node.resType.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;




×







3451



      nodesDestroyNode(*pNode);




×







3452



      *pNode = (SNode*)pSColumnNode;




×







3453



    } else {










3454



      return DEAL_RES_CONTINUE;




474✔





3455



    }










3456



  } else {










3457



    return DEAL_RES_CONTINUE;




7,087,031✔





3458



  }










3459












3460



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




2,777,649✔





3461



  if (!data) {




2,777,160✔





3462



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




1,603,252✔





3463



    if (code == TSDB_CODE_DUP_KEY) {




1,603,741✔





3464



      code = TSDB_CODE_SUCCESS;




×







3465



    }










3466



    QUERY_CHECK_CODE(code, lino, _end);




1,603,741✔





3467



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




1,603,741✔





3468



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




1,603,741✔





3469



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




1,602,761✔





3470



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




1,601,795✔





3471



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




1,602,761✔





3472



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




1,603,742✔





3473



  } else {










3474



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




1,173,908✔





3475



    pSColumnNode->slotId = col->slotId;




1,173,908✔





3476



  }










3477












3478



_end:




2,776,180✔





3479



  if (code != TSDB_CODE_SUCCESS) {




2,777,159✔






UNCOV

3480



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




×







3481



    return DEAL_RES_ERROR;




×







3482



  }










3483



  return DEAL_RES_CONTINUE;




2,777,159✔





3484



}










3485












3486



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




1,600,953✔





3487



                                      SStorageAPI* pAPI, STagScanInfo* pInfo, void* pStreamRuntimeInfo) {










3488



  int32_t code = TSDB_CODE_SUCCESS;




1,600,953✔





3489



  int32_t lino = 0;




1,600,953✔





3490



  int32_t numOfTables = taosArrayGetSize(aUidTags);




1,600,953✔





3491



  SArray* pBlockList = NULL;




1,600,476✔





3492












3493



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




1,600,476✔





3494



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




1,600,476✔





3495












3496



  pBlockList = taosArrayInit(1, POINTER_BYTES);




1,600,476✔





3497



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




1,600,953✔





3498












3499



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




1,600,953✔





3500



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




1,600,953✔





3501












3502



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




1,600,953✔





3503












3504



  SScalarParam output = {0};




1,600,464✔





3505



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




1,599,510✔





3506



  QUERY_CHECK_CODE(code, lino, _end);




1,600,133✔





3507












3508



  gTaskScalarExtra.pStreamInfo = (void*)pStreamRuntimeInfo;




1,600,133✔





3509



  gTaskScalarExtra.pStreamRange = NULL;




1,600,133✔





3510



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




1,600,953✔





3511



  QUERY_CHECK_CODE(code, lino, _end);




1,598,317✔





3512












3513



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




1,598,317✔





3514



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




3,999,147✔





3515



    if (result[i]) {




2,397,898✔





3516



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




2,239,815✔





3517



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




2,239,815✔





3518



    }










3519



  }










3520












3521



  colDataDestroy(output.columnData);




1,599,497✔





3522



  taosMemoryFreeClear(output.columnData);




1,597,152✔





3523












3524



_end:




1,596,686✔





3525



  blockDataDestroy(pResBlock);




1,596,060✔





3526



  taosArrayDestroy(pBlockList);




1,595,908✔





3527



  if (code != TSDB_CODE_SUCCESS) {




1,593,615✔





3528



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




×







3529



  }










3530



  return code;




1,593,615✔





3531



}










3532












3533



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




28,554,746✔





3534



                                         SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex,










3535



                                         const SStorageAPI* pAPI, void* pVnode) {










3536



  int32_t code = TSDB_CODE_SUCCESS;




28,554,746✔





3537



  int32_t lino = 0;




28,554,746✔





3538



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




28,554,746✔





3539



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




13,513,696✔





3540



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




×







3541



      STR_TO_VARSTR(str, "ctbidx");




×







3542












3543



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




×







3544



      QUERY_CHECK_CODE(code, lino, _end);




×







3545



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




13,510,294✔





3546



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




6,753,773✔





3547



      QUERY_CHECK_CODE(code, lino, _end);




6,756,706✔





3548



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




6,758,302✔





3549



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




6,753,941✔





3550



      QUERY_CHECK_CODE(code, lino, _end);




6,756,982✔





3551



    }










3552



  } else {










3553



    STagVal tagVal = {0};




15,031,385✔





3554



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




15,034,656✔





3555



    if (pUidTagInfo->pTagVal == NULL) {




15,039,535✔





3556



      colDataSetNULL(pColInfo, rowIndex);




×







3557



    } else {










3558



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




15,034,980✔





3559












3560



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




15,037,790✔





3561



        colDataSetNULL(pColInfo, rowIndex);




5,038✔





3562



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




15,033,991✔





3563



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




×







3564



        QUERY_CHECK_CODE(code, lino, _end);




×







3565



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




18,901,157✔





3566



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




3,876,340✔





3567



          QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_TAG, lino, _end);




×







3568



        }










3569



        char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);




3,878,872✔





3570



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




3,872,221✔





3571












3572



        varDataSetLen(tmp, tagVal.nData);




3,872,221✔





3573



        memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);




3,872,221✔





3574



        code = colDataSetVal(pColInfo, rowIndex, tmp, false);




3,877,227✔





3575



        taosMemoryFree(tmp);




3,875,780✔





3576



        QUERY_CHECK_CODE(code, lino, _end);




3,874,777✔





3577



      } else {










3578



        code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false);




11,141,647✔





3579



        QUERY_CHECK_CODE(code, lino, _end);




11,150,118✔





3580



      }










3581



    }










3582



  }










3583












3584



_end:




28,547,043✔





3585



  if (code != TSDB_CODE_SUCCESS) {




28,547,043✔





3586



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3587



  }










3588



  return code;




28,540,461✔





3589



}










3590












3591



static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags,




5,452,995✔





3592



                                      SArray* aFilterIdxs, bool ignoreFilterIdx, SStorageAPI* pAPI) {










3593



  int32_t       code = TSDB_CODE_SUCCESS;




5,452,995✔





3594



  int32_t       lino = 0;




5,452,995✔





3595



  STagScanInfo* pInfo = pOperator->info;




5,452,995✔





3596



  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];




5,453,783✔





3597



  if (!ignoreFilterIdx) {




5,452,373✔





3598



    size_t szTables = taosArrayGetSize(aFilterIdxs);




1,597,553✔





3599



    for (int i = 0; i < szTables; ++i) {




3,834,860✔





3600



      int32_t       idx = *(int32_t*)taosArrayGet(aFilterIdxs, i);




2,236,536✔





3601



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);




2,237,031✔





3602



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




2,234,391✔





3603



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




12,834,627✔





3604



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




10,599,412✔





3605



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




10,601,845✔





3606



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




10,601,845✔





3607



        QUERY_CHECK_CODE(code, lino, _end);




10,600,236✔





3608



      }










3609



    }










3610



  } else {










3611



    size_t szTables = taosArrayGetSize(aUidTags);




3,854,820✔





3612



    for (int i = 0; i < szTables; ++i) {




9,892,910✔





3613



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);




6,039,424✔





3614



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




6,039,424✔





3615



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




23,977,097✔





3616



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




17,941,464✔





3617



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




17,945,626✔





3618



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




17,945,626✔





3619



        QUERY_CHECK_CODE(code, lino, _end);




17,937,673✔





3620



      }










3621



    }










3622



  }










3623












3624



_end:




3,853,486✔





3625



  if (code != TSDB_CODE_SUCCESS) {




5,451,810✔





3626



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3627



  }










3628



  return code;




5,451,567✔





3629



}










3630












3631



static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




10,454,173✔





3632



  int32_t        code = TSDB_CODE_SUCCESS;




10,454,173✔





3633



  int32_t        lino = 0;




10,454,173✔





3634



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




10,454,173✔





3635



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




10,461,404✔





3636












3637



  STagScanInfo* pInfo = pOperator->info;




10,453,130✔





3638



  SSDataBlock*  pRes = pInfo->pRes;




10,459,260✔





3639












3640



  QRY_PARAM_CHECK(ppRes);




10,457,298✔





3641












3642



  if (pOperator->status == OP_EXEC_DONE) {




10,457,202✔





3643



    return TSDB_CODE_SUCCESS;




4,939,859✔





3644



  }










3645



  blockDataCleanup(pRes);




5,516,065✔





3646












3647



  if (pInfo->pCtbCursor == NULL) {




5,518,759✔





3648



    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);




5,521,415✔





3649



    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);




5,512,394✔





3650



  } else {










3651



    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);




×







3652



    QUERY_CHECK_CODE(code, lino, _end);




×







3653



  }










3654












3655



  SArray* aUidTags = pInfo->aUidTags;




5,515,537✔





3656



  SArray* aFilterIdxs = pInfo->aFilterIdxs;




5,519,578✔





3657



  int32_t count = 0;




5,506,570✔





3658



  bool    ctbCursorFinished = false;




5,506,570✔





3659



  while (1) {




101,007✔





3660



    taosArrayClearEx(aUidTags, tagScanFreeUidTag);




5,607,554✔





3661



    taosArrayClear(aFilterIdxs);




5,619,388✔





3662












3663



    int32_t numTables = 0;




5,618,518✔





3664



    while (numTables < pOperator->resultInfo.capacity) {




14,063,270✔





3665



      SMCtbCursor* pCur = pInfo->pCtbCursor;




14,053,796✔





3666



      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);




14,052,686✔





3667



      if (uid == 0) {




14,044,565✔





3668



        ctbCursorFinished = true;




5,627,138✔





3669



        break;




5,627,138✔





3670



      }










3671



      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};




8,417,427✔





3672



      info.pTagVal = taosMemoryMalloc(pCur->vLen);




8,411,726✔





3673



      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);




8,410,902✔





3674












3675



      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);




8,410,902✔





3676



      void* tmp = taosArrayPush(aUidTags, &info);




8,434,570✔





3677



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




8,434,570✔





3678



      ++numTables;




8,434,570✔





3679



    }










3680












3681



    if (numTables == 0) {




5,627,138✔





3682



      break;




171,725✔





3683



    }










3684



    bool ignoreFilterIdx = true;




5,455,413✔





3685



    if (pInfo->pTagCond != NULL) {




5,455,413✔





3686



      ignoreFilterIdx = false;




1,600,953✔





3687



      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo, pTaskInfo->pStreamRuntimeInfo);




1,600,953✔





3688



      QUERY_CHECK_CODE(code, lino, _end);




1,597,023✔





3689



    } else {










3690



      ignoreFilterIdx = true;




3,854,820✔





3691



    }










3692












3693



    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);




5,451,843✔





3694



    QUERY_CHECK_CODE(code, lino, _end);




5,452,524✔





3695












3696



    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);




5,452,524✔





3697












3698



    if (count != 0) {




5,453,340✔





3699



      break;




5,352,356✔





3700



    }










3701



  }










3702












3703



  if (count > 0) {




5,524,081✔





3704



    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);




5,348,747✔





3705



  }










3706



  if (count == 0 || ctbCursorFinished) {




5,523,632✔





3707



    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




5,523,632✔





3708



    pInfo->pCtbCursor = NULL;




5,514,197✔





3709



    setOperatorCompleted(pOperator);




5,514,646✔





3710



  }










3711












3712



  pRes->info.rows = count;




5,520,970✔





3713



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




5,515,116✔





3714



  if (bLimitReached) {




5,512,947✔





3715



    setOperatorCompleted(pOperator);




×







3716



  }










3717












3718



  pOperator->resultInfo.totalRows += pRes->info.rows;




5,512,947✔





3719



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




5,505,344✔





3720












3721



_end:




5,494,617✔





3722



  if (code != TSDB_CODE_SUCCESS) {




5,494,617✔





3723



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3724



    pTaskInfo->code = code;




×







3725



    T_LONG_JMP(pTaskInfo->env, code);




×







3726



  }










3727












3728



  return code;




5,494,617✔





3729



}










3730












3731



static int32_t createTagScanTableListInfoFromParam(SOperatorInfo* pOperator) {




1,273,409✔





3732



  STagScanInfo*          pInfo = pOperator->info;




1,273,409✔





3733



  SExecTaskInfo*         pTaskInfo = pOperator->pTaskInfo;




1,273,409✔





3734



  int32_t                code = 0;




1,273,409✔





3735



  STableListInfo*        pListInfo = pInfo->pTableListInfo;




1,273,409✔





3736



  STagScanOperatorParam* pParam = (STagScanOperatorParam*)pOperator->pOperatorGetParam->value;




1,273,409✔





3737



  tb_uid_t               pUid = pParam->vcUid;




1,273,409✔





3738












3739



  // qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",










3740



  //        pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList),










3741



  //        pOperator->status);










3742












3743



  STableKeyInfo info = {.groupId = 0};




1,273,409✔





3744












3745



  int32_t tableIdx = 0;




1,273,409✔





3746



  taosHashClear(pListInfo->map);




1,273,409✔





3747



  taosArrayClear(pListInfo->pTableList);




1,273,409✔





3748












3749



  if (taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {




1,273,409✔





3750



    if (TSDB_CODE_DUP_KEY == terrno) {




×







3751



    } else {










3752



      return terrno;




×







3753



    }










3754



  }










3755












3756



  info.uid = pUid;




1,273,409✔





3757



  void* p = taosArrayPush(pListInfo->pTableList, &info);




1,273,409✔





3758



  if (p == NULL) {




1,273,409✔





3759



    return terrno;




×







3760



  }










3761












3762



  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));




1,273,409✔





3763












3764



  return code;




1,273,409✔





3765



}










3766












3767



static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




9,639,773✔





3768



  int32_t       code = TSDB_CODE_SUCCESS;




9,639,773✔





3769



  int32_t       lino = 0;




9,639,773✔





3770



  STagScanInfo* pInfo = pOperator->info;




9,639,773✔





3771



  if (pOperator->pOperatorGetParam) {




9,639,773✔





3772



    pOperator->resultInfo.totalRows = 0;




1,273,409✔





3773



    pOperator->dynamicTask = true;




1,273,409✔





3774



    pInfo->curPos = 0;




1,273,409✔





3775



    code = createTagScanTableListInfoFromParam(pOperator);




1,273,409✔





3776



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




1,273,409✔





3777



    pOperator->pOperatorGetParam = NULL;




1,273,409✔





3778



    QUERY_CHECK_CODE(code, lino, _end);




1,273,409✔





3779












3780



    if (pOperator->status == OP_EXEC_DONE) {




1,273,409✔





3781



      pOperator->status = OP_OPENED;




757,513✔





3782



    }










3783



  }










3784












3785



  if (pOperator->status == OP_EXEC_DONE) {




9,639,276✔





3786



    (*ppRes) = NULL;




3,945,366✔





3787



    return code;




3,945,366✔





3788



  }










3789












3790



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




5,692,916✔





3791



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




5,693,413✔





3792












3793



  SExprInfo*   pExprInfo = &pOperator->exprSupp.pExprInfo[0];




5,693,413✔





3794



  SSDataBlock* pRes = pInfo->pRes;




5,694,407✔





3795



  blockDataCleanup(pRes);




5,693,413✔





3796












3797



  int32_t size = 0;




5,695,401✔





3798



  code = tableListGetSize(pInfo->pTableListInfo, &size);




5,695,401✔





3799



  QUERY_CHECK_CODE(code, lino, _end);




5,694,407✔





3800












3801



  if (size == 0) {




5,694,407✔





3802



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




17,297✔





3803



    (*ppRes) = NULL;




17,297✔





3804



    return code;




17,297✔





3805



  }










3806












3807



  SMetaReader mr = {0};




5,677,110✔





3808



  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




5,677,110✔





3809



  pRes->info.rows = 0;




5,677,110✔





3810












3811



  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {




13,893,959✔





3812



    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);




8,216,352✔





3813



    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD &&




8,217,843✔





3814



        code != TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED) {










3815



      // ignore other error










3816



      code = TSDB_CODE_SUCCESS;




8,217,843✔





3817



    }










3818



    QUERY_CHECK_CODE(code, lino, _end);




8,217,843✔





3819












3820



    if (++pInfo->curPos >= size) {




8,217,843✔





3821



      setOperatorCompleted(pOperator);




5,678,104✔





3822



    }










3823



  }










3824












3825



  pAPI->metaReaderFn.clearReader(&mr);




5,677,110✔





3826



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




5,678,104✔





3827



  if (bLimitReached) {




5,678,104✔





3828



    setOperatorCompleted(pOperator);




×







3829



  }










3830












3831



  // qDebug("QInfo:0x%" PRIx64 ", create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);










3832



  if (pOperator->status == OP_EXEC_DONE) {




5,678,104✔





3833



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




5,678,104✔





3834



  }










3835












3836



  pOperator->resultInfo.totalRows += pRes->info.rows;




5,678,104✔





3837












3838



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




5,678,104✔





3839



_end:




5,678,104✔





3840



  if (code != TSDB_CODE_SUCCESS) {




5,678,104✔





3841



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3842



    pTaskInfo->code = code;




×







3843



    T_LONG_JMP(pTaskInfo->env, code);




×







3844



  }










3845



  return code;




5,678,104✔





3846



}










3847












3848



static void destroyTagScanOperatorInfo(void* param) {




11,420,747✔





3849



  STagScanInfo* pInfo = (STagScanInfo*)param;




11,420,747✔





3850



  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {




11,420,747✔





3851



    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




×







3852



  }










3853



  taosHashCleanup(pInfo->filterCtx.colHash);




11,423,730✔





3854



  taosArrayDestroy(pInfo->filterCtx.cInfoList);




11,409,771✔





3855



  taosArrayDestroy(pInfo->aFilterIdxs);




11,418,050✔





3856



  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);




11,412,606✔





3857












3858



  blockDataDestroy(pInfo->pRes);




11,422,690✔





3859



  taosArrayDestroy(pInfo->matchInfo.pList);




11,420,848✔





3860



  tableListDestroy(pInfo->pTableListInfo);




11,420,844✔





3861












3862



  pInfo->pRes = NULL;




11,423,501✔





3863



  pInfo->pTableListInfo = NULL;




11,423,496✔





3864



  taosMemoryFreeClear(param);




11,423,017✔





3865



}




11,420,686✔





3866












3867



static int32_t resetTagScanOperatorState(SOperatorInfo* pOper) {




4,356✔





3868



  int32_t         code = TSDB_CODE_SUCCESS;




4,356✔





3869



  STagScanInfo*   pInfo = pOper->info;




4,356✔





3870












3871



  pOper->status = OP_NOT_OPENED;




4,356✔





3872



  STagScanPhysiNode* pTagScanNode = (STagScanPhysiNode*)pOper->pPhyNode;




4,356✔





3873



  if (pTagScanNode->onlyMetaCtbIdx) {




4,356✔





3874



      SExecTaskInfo* pTaskInfo = pOper->pTaskInfo;




1,896✔





3875



      SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,896✔





3876



      pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




1,896✔





3877



      pInfo->pCtbCursor = NULL;




1,896✔





3878



  } else {










3879



      pInfo->curPos = 0;




2,460✔





3880



  }










3881












3882



  return code;




4,356✔





3883



}










3884












3885



int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,




11,414,967✔





3886



                                  STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond,










3887



                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3888



  QRY_PARAM_CHECK(pOptrInfo);




11,414,967✔





3889












3890



  int32_t         code = TSDB_CODE_SUCCESS;




11,419,055✔





3891



  int32_t         lino = 0;




11,419,055✔





3892



  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;




11,419,055✔





3893



  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));




11,419,055✔





3894



  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




11,402,352✔





3895



  if (pInfo == NULL || pOperator == NULL) {




11,392,556✔





3896



    code = terrno;




×







3897



    goto _error;




×







3898



  }










3899



  pOperator->pPhyNode = pTagScanNode;




11,392,556✔





3900



  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;




11,404,551✔





3901












3902



  int32_t    numOfExprs = 0;




11,405,307✔





3903



  SExprInfo* pExprInfo = NULL;




11,408,337✔





3904












3905



  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);




11,408,253✔





3906



  QUERY_CHECK_CODE(code, lino, _error);




11,410,738✔





3907












3908



  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);




11,410,738✔





3909



  QUERY_CHECK_CODE(code, lino, _error);




11,408,702✔





3910












3911



  int32_t num = 0;




11,408,702✔





3912



  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




11,411,021✔





3913



  QUERY_CHECK_CODE(code, lino, _error);




11,419,713✔





3914












3915



  pInfo->pTagCond = pTagCond;




11,419,713✔





3916



  pInfo->pTagIndexCond = pTagIndexCond;




11,422,416✔





3917



  pInfo->suid = pPhyNode->suid;




11,416,652✔





3918



  pInfo->pStorageAPI = &pTaskInfo->storageAPI;




11,402,734✔





3919












3920



  pInfo->pTableListInfo = pTableListInfo;




11,414,833✔





3921



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




11,403,285✔





3922



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




11,417,591✔





3923












3924



  pInfo->readHandle = *pReadHandle;




11,410,943✔





3925



  pInfo->curPos = 0;




11,413,379✔





3926












3927



  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);




11,404,584✔





3928



  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,




11,416,070✔





3929



                  pTaskInfo);










3930



  initResultSizeInfo(&pOperator->resultInfo, 4096);




11,412,102✔





3931



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




11,400,270✔





3932



  QUERY_CHECK_CODE(code, lino, _error);




11,422,954✔





3933












3934



  if (pTagScanNode->onlyMetaCtbIdx) {




11,422,954✔





3935



    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));




5,924,699✔





3936



    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);




5,930,061✔





3937












3938



    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));




5,925,571✔





3939



    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);




5,928,265✔





3940












3941



    pInfo->filterCtx.colHash =




5,926,605✔





3942



        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);




5,925,571✔





3943



    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);




5,927,503✔





3944












3945



    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));




5,924,777✔





3946



    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);




5,924,488✔





3947












3948



    if (pInfo->pTagCond != NULL) {




5,924,222✔





3949



      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);




1,603,260✔





3950



    }










3951



  }










3952



  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;




11,424,795✔





3953



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,




11,420,096✔





3954



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










3955



  setOperatorResetStateFn(pOperator, resetTagScanOperatorState);     




11,419,013✔





3956



  










3957



  *pOptrInfo = pOperator;




11,421,065✔





3958



  return code;




11,415,693✔





3959












3960



_error:




×







3961



  if (pInfo) {




×







3962



    pInfo->pTableListInfo = NULL;




×







3963



  }










3964












3965



  if (pInfo != NULL) destroyTagScanOperatorInfo(pInfo);




×







3966



  if (pOperator != NULL) {




×







3967



    pOperator->info = NULL;




×







3968



    destroyOperator(pOperator);




×







3969



  }










3970



  return code;




×







3971



}










3972












3973



// table merge scan operator










3974












3975



static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {




229,253,281✔





3976



  int32_t                 left = *(int32_t*)pLeft;




229,253,281✔





3977



  int32_t                 right = *(int32_t*)pRight;




229,253,624✔





3978



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




229,253,281✔





3979












3980



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




229,253,281✔





3981



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




229,252,938✔





3982












3983



  if (leftIdx == -1) {




229,253,281✔





3984



    return 1;




196,577,761✔





3985



  } else if (rightIdx == -1) {




32,675,520✔





3986



    return -1;




323,520✔





3987



  }










3988












3989



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




32,352,000✔





3990



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




32,352,000✔





3991



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




32,352,000✔





3992



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




32,352,000✔





3993



    ret = -1 * ret;




×







3994



  }










3995



  return ret;




32,352,000✔





3996



}










3997












3998



static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) {




×







3999



  int32_t                 left = *(int32_t*)pLeft;




×







4000



  int32_t                 right = *(int32_t*)pRight;




×







4001



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




×







4002












4003



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




×







4004



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




×







4005












4006



  if (leftIdx == -1) {




×







4007



    return 1;




×







4008



  } else if (rightIdx == -1) {




×







4009



    return -1;




×







4010



  }










4011












4012



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




×







4013



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




×







4014



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




×







4015



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




×







4016



    ret = -1 * ret;




×







4017



  }










4018



  if (ret == 0 && pInfo->pPkOrderInfo) {




×







4019



    ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx,




×







4020



                               pInfo->pPkOrderInfo);




×







4021



  }










4022



  return ret;




×







4023



}










4024












4025



int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {




2,918,908✔





4026



  int32_t code = TSDB_CODE_SUCCESS;




2,918,908✔





4027



  int32_t lino = 0;




2,918,908✔





4028



  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));




2,918,908✔





4029



  dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));




2,918,908✔





4030



  QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);




2,913,173✔





4031



  for (int i = 0; i < src->numOfCols; i++) {




9,616,152✔





4032



    dst->colList[i] = src->colList[i];




6,705,356✔





4033



  }










4034












4035



_end:




2,920,936✔





4036



  if (code != TSDB_CODE_SUCCESS) {




2,920,936✔





4037



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4038



  }










4039



  return code;




2,918,565✔





4040



}










4041












4042



static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,




4,380,309✔





4043



                                                bool* pSubTableHasBlock) {










4044



  int32_t code = 0;




4,380,309✔





4045












4046



  STableMergeScanInfo*    pInfo = pOperator->info;




4,380,309✔





4047



  SReadHandle*            pHandle = &pInfo->base.readHandle;




4,380,646✔





4048



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




4,381,669✔





4049



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




4,382,686✔





4050



  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;




4,382,012✔





4051












4052



  blockDataCleanup(pInput->pReaderBlock);




4,378,600✔





4053



  if (!pInput->bInMemReader) {




4,380,652✔





4054



    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,




4,404,624✔





4055



                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




2,201,626✔





4056



    if (code != 0) {




2,202,643✔





4057



      return code;




×







4058



    }










4059



  }










4060












4061



  pInfo->base.dataReader = pInput->pReader;




4,383,703✔





4062












4063



  while (true) {




4,802✔





4064



    bool hasNext = false;




4,385,430✔





4065



    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);




4,385,436✔





4066



    if (code != 0) {




4,388,854✔





4067



      pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4068



      pInfo->base.dataReader = NULL;




×







4069



      return code;




×







4070



    }










4071












4072



    if (!hasNext || isTaskKilled(pTaskInfo)) {




4,388,854✔





4073



      if (isTaskKilled(pTaskInfo)) {




2,925,335✔





4074



        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4075



        pInfo->base.dataReader = NULL;




×







4076



        return code;




×







4077



      }










4078












4079



      *pSubTableHasBlock = false;




2,925,672✔





4080



      break;




2,925,672✔





4081



    }










4082












4083



    if (pInput->tblCond.order == TSDB_ORDER_ASC) {




1,463,519✔





4084



      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;




1,434,364✔





4085



    } else {










4086



      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;




28,812✔





4087



    }










4088












4089



    uint32_t status = 0;




1,463,176✔





4090



    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);




1,463,519✔





4091



    if (code != 0) {




1,463,519✔





4092



      pInfo->base.dataReader = NULL;




×







4093



      return code;




×







4094



    }










4095












4096



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




1,463,519✔





4097



      *pSubTableHasBlock = false;




×







4098



      break;




×







4099



    }










4100



    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {




1,463,519✔





4101



      continue;




4,802✔





4102



    }










4103












4104



    *pSubTableHasBlock = true;




1,458,717✔





4105



    break;




1,458,717✔





4106



  }










4107












4108



  if (*pSubTableHasBlock) {




4,384,389✔





4109



    pInput->pReaderBlock->info.id.groupId =




2,917,434✔





4110



        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);




2,917,091✔





4111



    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;




1,458,717✔





4112



  }










4113



  if (!pInput->bInMemReader || !*pSubTableHasBlock) {




4,383,709✔





4114



    pAPI->tsdReader.tsdReaderClose(pInput->pReader);




3,295,908✔





4115



    pInput->pReader = NULL;




3,294,897✔





4116



  }










4117












4118



  pInfo->base.dataReader = NULL;




4,383,715✔





4119



  return TSDB_CODE_SUCCESS;




4,383,041✔





4120



}










4121












4122



static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {




1,825,643✔





4123



  pInfo->bGroupProcessed = false;




1,825,643✔





4124












4125



  int32_t numOfTables = 0;




1,825,637✔





4126



  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




1,816,171✔





4127



  if (code != TSDB_CODE_SUCCESS) {




1,816,851✔





4128



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4129



    return code;




×







4130



  }










4131












4132



  int32_t i = pInfo->tableStartIndex + 1;




1,816,851✔





4133



  for (; i < numOfTables; ++i) {




2,909,755✔





4134



    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




1,148,472✔





4135



    if (!tableKeyInfo) {




1,147,443✔





4136



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4137



      return terrno;




×







4138



    }










4139



    if (tableKeyInfo->groupId != pInfo->groupId) {




1,147,443✔





4140



      break;




57,590✔





4141



    }










4142



  }










4143



  pInfo->tableEndIndex = i - 1;




1,818,873✔





4144



  return TSDB_CODE_SUCCESS;




1,831,378✔





4145



}










4146












4147



static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {




1,833,424✔





4148



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,757,742✔





4149



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,925,672✔





4150



    if (pInput->rowIdx == -1) {




2,924,661✔





4151



      continue;




1,466,281✔





4152



    }










4153












4154



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,458,374✔





4155



      pInput->rowIdx = 0;




1,458,374✔





4156



      pInput->pageIdx = -1;




1,458,374✔





4157



    }










4158












4159



    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,459,060✔





4160



    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




1,458,374✔





4161



    if (!col) {




1,458,374✔





4162



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4163



      return terrno;




×







4164



    }










4165



    pInput->aTs = (int64_t*)col->pData;




1,458,374✔





4166



  }










4167












4168



  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;




1,832,070✔





4169



  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);




1,833,761✔





4170



}










4171












4172



static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {




1,826,997✔





4173



  int32_t code = setGroupStartEndIndex(pInfo);




1,826,997✔





4174



  if (code != TSDB_CODE_SUCCESS) {




1,826,263✔





4175



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4176



    return code;




×







4177



  }










4178



  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));




1,826,263✔





4179



  if (pSubTblsInfo == NULL) {




1,817,519✔





4180



    return terrno;




×







4181



  }










4182



  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);




1,817,519✔





4183



  if (!pSubTblsInfo->pTsOrderInfo) {




1,826,311✔





4184



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4185



    return terrno;




×







4186



  }










4187



  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {




1,815,166✔





4188



    pSubTblsInfo->pPkOrderInfo = taosArrayGet(pInfo->pSortInfo, 1);




×







4189



    if (!pSubTblsInfo->pPkOrderInfo) {




×







4190



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4191



      return terrno;




×







4192



    }










4193



  } else {










4194



    pSubTblsInfo->pPkOrderInfo = NULL;




1,808,402✔





4195



  }










4196



  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




1,828,369✔





4197



  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));




1,819,908✔





4198



  if (pSubTblsInfo->aInputs == NULL) {




1,816,526✔





4199



    taosMemoryFree(pSubTblsInfo);




×







4200



    return terrno;




×







4201



  }










4202



  int32_t bufPageSize = pInfo->bufPageSize;




1,825,306✔





4203



  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;




1,825,324✔





4204



  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);




1,820,582✔





4205



  if (code != TSDB_CODE_SUCCESS) {




1,815,503✔





4206



    taosMemoryFree(pSubTblsInfo->aInputs);




×







4207



    taosMemoryFree(pSubTblsInfo);




×







4208



    return code;




×







4209



  }










4210



  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;




1,815,503✔





4211



  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;




1,823,946✔





4212












4213



  pInfo->pSubTablesMergeInfo = pSubTblsInfo;




1,828,694✔





4214



  return TSDB_CODE_SUCCESS;




1,813,481✔





4215



}










4216












4217



static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {




1,824,975✔





4218



  int32_t        code = TSDB_CODE_SUCCESS;




1,824,975✔





4219



  int32_t        lino = 0;




1,824,975✔





4220



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,824,975✔





4221



  SReadHandle*   pHandle = &pInfo->base.readHandle;




1,822,616✔





4222



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,823,621✔





4223












4224



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




1,809,419✔





4225












4226



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,751,995✔





4227



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,915,893✔





4228



    pInput->type = SUB_TABLE_MEM_BLOCK;




2,912,162✔





4229












4230



    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);




2,909,761✔





4231



    QUERY_CHECK_CODE(code, lino, _end);




2,907,107✔





4232












4233



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);




2,907,107✔





4234



    QUERY_CHECK_CODE(code, lino, _end);




2,921,273✔





4235












4236



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);




2,921,273✔





4237



    QUERY_CHECK_CODE(code, lino, _end);




2,926,009✔





4238












4239



    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);




2,926,009✔





4240



    pInput->pKeyInfo = keyInfo;




2,922,284✔





4241












4242



    if (isTaskKilled(pTaskInfo)) {




2,921,947✔





4243



      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);




×







4244



    }










4245












4246



    if (i + 1 < pSubTblsInfo->numInMemReaders) {




2,913,829✔





4247



      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,




2,182,450✔





4248



                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




1,091,568✔





4249



      QUERY_CHECK_CODE(code, lino, _end);




1,090,196✔





4250



      pInput->bInMemReader = true;




1,090,196✔





4251



    } else {










4252



      pInput->pReader = NULL;




1,830,379✔





4253



      pInput->bInMemReader = false;




1,830,379✔





4254



    }










4255



    bool hasNext = true;




2,920,232✔





4256



    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);




2,922,615✔





4257



    QUERY_CHECK_CODE(code, lino, _end);




2,926,009✔





4258



    if (!hasNext) {




2,926,009✔





4259



      pInput->rowIdx = -1;




1,467,292✔





4260



      ++pSubTblsInfo->numSubTablesCompleted;




1,466,281✔





4261



      continue;




1,466,955✔





4262



    } else {










4263



      pInput->rowIdx = 0;




1,458,717✔





4264



      pInput->pageIdx = -1;




1,458,717✔





4265



    }










4266



  }










4267












4268



_end:




1,832,744✔





4269



  if (code != TSDB_CODE_SUCCESS) {




1,832,738✔





4270



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4271



  }










4272



  return code;




1,833,761✔





4273



}










4274












4275



static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




1,458,717✔





4276



  int32_t              code = TSDB_CODE_SUCCESS;




1,458,717✔





4277



  int32_t              lino = 0;




1,458,717✔





4278



  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;




1,458,717✔





4279



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




1,458,717✔





4280



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




1,458,717✔





4281



  bool                 hasNext = true;




1,458,717✔





4282



  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);




1,458,717✔





4283



  QUERY_CHECK_CODE(code, lino, _end);




1,458,717✔





4284












4285



  if (!hasNext) {




1,458,717✔





4286



    pInput->rowIdx = -1;




1,458,717✔





4287



    ++pSubTblsInfo->numSubTablesCompleted;




1,458,717✔





4288



  } else {










4289



    pInput->rowIdx = 0;




×







4290



  }










4291












4292



_end:




1,458,717✔





4293



  if (code != TSDB_CODE_SUCCESS) {




1,458,717✔





4294



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4295



    pTaskInfo->code = code;




×







4296



    T_LONG_JMP(pTaskInfo->env, code);




×







4297



  }










4298



}




1,458,717✔





4299












4300



static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




265,641,150✔





4301



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




265,641,150✔





4302



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




265,643,876✔





4303












4304



  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




265,645,561✔





4305



  if (pInput->rowIdx < pInputBlock->info.rows - 1) {




265,651,332✔





4306



    ++pInput->rowIdx;




264,192,609✔





4307



  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {




1,458,717✔





4308



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,458,717✔





4309



      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);




1,458,717✔





4310



    }










4311



    if (pInput->rowIdx != -1) {




1,458,717✔





4312



      SColumnInfoData* col = taosArrayGet(pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




×







4313



      if (!col) {




×







4314



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4315



        return terrno;




×







4316



      }










4317



      pInput->pInputBlock = pInputBlock;




×







4318



      pInput->aTs = (int64_t*)col->pData;




×







4319



    }










4320



  }










4321












4322



  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));




265,652,674✔





4323



}










4324












4325



static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {




265,587,597✔





4326



  int32_t            code = TSDB_CODE_SUCCESS;




265,587,597✔





4327



  int32_t            lino = 0;




265,587,597✔





4328



  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




265,587,597✔





4329



  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




265,593,344✔





4330












4331



  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {




1,075,844,504✔





4332



    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);




809,726,235✔





4333



    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);




809,657,427✔





4334












4335



    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);




809,657,427✔





4336



    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);




809,599,952✔





4337



    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);




809,599,952✔





4338












4339



    if (isNull) {




809,973,862✔





4340



      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);




91,716,347✔





4341



      QUERY_CHECK_CODE(code, lino, _end);




91,712,881✔





4342



    } else {










4343



      if (pSrcColInfo->pData != NULL) {




718,257,515✔





4344



        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);




718,234,437✔





4345



        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);




718,857,844✔





4346



        QUERY_CHECK_CODE(code, lino, _end);




718,562,758✔





4347



      }










4348



    }










4349



  }










4350



  pBlock->info.dataLoad = 1;




265,644,917✔





4351



  pBlock->info.scanFlag = pInputBlock->info.scanFlag;




265,644,905✔





4352



  pBlock->info.rows += 1;




265,644,538✔





4353












4354



_end:




265,647,264✔





4355



  if (code != TSDB_CODE_SUCCESS) {




265,647,264✔





4356



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4357



  }










4358



  return code;




265,643,551✔





4359



}










4360












4361



static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,




2,968,958✔





4362



                                       SSDataBlock** pResBlock) {










4363



  int32_t                 code = TSDB_CODE_SUCCESS;




2,968,958✔





4364



  int32_t                 lino = 0;




2,968,958✔





4365



  STableMergeScanInfo*    pInfo = pOperator->info;




2,968,958✔





4366



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




2,968,958✔





4367



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




2,968,284✔





4368



  bool                    finished = false;




2,967,604✔





4369












4370



  QRY_PARAM_CHECK(pResBlock);




2,967,604✔





4371












4372



  blockDataCleanup(pBlock);




2,968,621✔





4373












4374



  while (true) {




×







4375



    while (true) {










4376



      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {




268,557,915✔





4377



        finished = true;




2,969,295✔





4378



        break;




2,969,295✔





4379



      }










4380












4381



      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);




265,591,003✔





4382



      QUERY_CHECK_CODE(code, lino, _end);




265,643,876✔





4383












4384



      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);




265,643,876✔





4385



      QUERY_CHECK_CODE(code, lino, _end);




265,587,609✔





4386












4387



      if (pBlock->info.rows >= capacity) {




265,587,609✔





4388



        break;




×







4389



      }










4390



    }










4391












4392



    if (isTaskKilled(pTaskInfo)) {




2,969,295✔





4393



      return pTaskInfo->code;




×







4394



    }










4395












4396



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);




2,968,958✔





4397



    if (finished || limitReached || pBlock->info.rows > 0) {




2,968,621✔





4398



      break;










4399



    }










4400



  }










4401












4402



  if (pBlock->info.rows > 0) {




2,968,621✔





4403



    *pResBlock = pBlock;




1,135,197✔





4404



  }










4405












4406



_end:




1,834,098✔





4407



  if (code != TSDB_CODE_SUCCESS) {




2,969,295✔





4408



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4409



    pTaskInfo->code = code;




×







4410



  }










4411



  return code;




2,968,958✔





4412



}










4413












4414



static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {




1,826,654✔





4415



  int32_t              code = TSDB_CODE_SUCCESS;




1,826,654✔





4416



  int32_t              lino = 0;




1,826,654✔





4417



  STableMergeScanInfo* pInfo = pOperator->info;




1,826,654✔





4418












4419



  code = initSubTablesMergeInfo(pInfo);




1,830,042✔





4420



  QUERY_CHECK_CODE(code, lino, _end);




1,812,831✔





4421












4422



  code = initSubTableInputs(pOperator, pInfo);




1,812,831✔





4423



  QUERY_CHECK_CODE(code, lino, _end);




1,833,424✔





4424












4425



  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);




1,833,424✔





4426



  QUERY_CHECK_CODE(code, lino, _end);




1,834,098✔





4427












4428



_end:




1,834,098✔





4429



  if (code != TSDB_CODE_SUCCESS) {




1,834,098✔





4430



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4431



  }










4432



  return code;




1,833,761✔





4433



}










4434












4435



static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {




31,870,523✔





4436



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




31,870,523✔





4437



  if (pSubTblsInfo != NULL) {




31,872,781✔





4438



    tMergeTreeDestroy(&pSubTblsInfo->pTree);




1,833,761✔





4439












4440



    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,759,770✔





4441



      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,926,009✔





4442



      taosMemoryFree(pInput->tblCond.colList);




2,923,987✔





4443



      blockDataDestroy(pInput->pReaderBlock);




2,924,655✔





4444



      blockDataDestroy(pInput->pPageBlock);




2,924,992✔





4445



      taosArrayDestroy(pInput->aBlockPages);




2,925,335✔





4446



      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);




2,925,335✔





4447



      pInput->pReader = NULL;




2,926,009✔





4448



    }










4449












4450



    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);




1,833,761✔





4451



    taosMemoryFree(pSubTblsInfo->aInputs);




1,832,750✔





4452












4453



    taosMemoryFree(pSubTblsInfo);




1,833,087✔





4454



    pInfo->pSubTablesMergeInfo = NULL;




1,832,744✔





4455












4456



    // taosMemoryTrim(0);










4457



  }










4458



}




31,871,764✔





4459












4460



int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




2,937,183✔





4461



  QRY_PARAM_CHECK(ppRes);




2,937,183✔





4462












4463



  int32_t lino = 0;




2,939,211✔





4464



  int32_t tableListSize = 0;




2,939,211✔





4465



  int64_t st = taosGetTimestampUs();




2,941,245✔





4466












4467



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




2,941,245✔





4468



  STableMergeScanInfo* pInfo = pOperator->info;




2,931,099✔





4469












4470



  if (pOperator->status == OP_EXEC_DONE) {




2,931,105✔





4471



    return TSDB_CODE_SUCCESS;




×







4472



  }










4473












4474



  int32_t code = pOperator->fpSet._openFn(pOperator);




2,933,813✔





4475



  QUERY_CHECK_CODE(code, lino, _end);




2,919,268✔





4476












4477



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




2,919,268✔





4478



  QUERY_CHECK_CODE(code, lino, _end);




2,933,807✔





4479












4480



  if (!pInfo->hasGroupId) {




2,933,807✔





4481



    pInfo->hasGroupId = true;




1,796,576✔





4482












4483



    if (tableListSize == 0) {




1,785,407✔





4484



      setOperatorCompleted(pOperator);




32,242✔





4485



      (*ppRes) = NULL;




32,242✔





4486



      return code;




32,242✔





4487



    }










4488












4489



    pInfo->tableStartIndex = 0;




1,753,165✔





4490



    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,761,981✔





4491



    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




1,751,486✔





4492



    pInfo->groupId = pTmpGpId->groupId;




1,751,486✔





4493



    code = startSubTablesTableMergeScan(pOperator);




1,766,368✔





4494



    QUERY_CHECK_CODE(code, lino, _end);




1,775,834✔





4495



  }










4496












4497



  SSDataBlock* pBlock = NULL;




2,914,419✔





4498



  while (pInfo->tableStartIndex < tableListSize) {




2,968,621✔





4499



    if (isTaskKilled(pTaskInfo)) {




2,968,621✔





4500



      break;




×







4501



    }










4502












4503



    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);




2,967,267✔





4504



    QUERY_CHECK_CODE(code, lino, _end);




2,968,958✔





4505












4506



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




2,968,958✔





4507



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




×







4508



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




×







4509












4510



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




×







4511



    }










4512












4513



    if (pBlock != NULL) {




2,968,958✔





4514



      pBlock->info.id.groupId = pInfo->groupId;




1,135,197✔





4515



      pOperator->resultInfo.totalRows += pBlock->info.rows;




1,135,197✔





4516



      pInfo->bGroupProcessed = true;




1,135,197✔





4517



      break;




1,135,197✔





4518



    } else {










4519



      // Data of this group are all dumped, let's try the next group










4520



      stopSubTablesTableMergeScan(pInfo);




1,833,761✔





4521



      if (pInfo->tableEndIndex >= tableListSize - 1) {




1,832,744✔





4522



        setOperatorCompleted(pOperator);




1,775,491✔





4523



        break;




1,775,834✔





4524



      }










4525












4526



      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




57,590✔





4527



      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




57,590✔





4528



      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




57,590✔





4529












4530



      pInfo->groupId = pTmpGpId->groupId;




57,590✔





4531



      code = startSubTablesTableMergeScan(pOperator);




57,590✔





4532



      QUERY_CHECK_CODE(code, lino, _end);




57,590✔





4533



      resetLimitInfoForNextGroup(&pInfo->limitInfo);




57,590✔





4534



    }










4535



  }










4536












4537



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




2,911,031✔





4538












4539



_end:




2,911,031✔





4540



  if (code != TSDB_CODE_SUCCESS) {




2,910,020✔





4541



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4542



    pTaskInfo->code = code;




×







4543



    T_LONG_JMP(pTaskInfo->env, code);




×







4544



  } else {










4545



    (*ppRes) = pBlock;




2,910,020✔





4546



  }










4547












4548



  return code;




2,911,031✔





4549



}










4550












4551



static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {




3,314,420✔





4552



  int32_t              code = TSDB_CODE_SUCCESS;




3,314,420✔





4553



  int32_t              lino = 0;




3,314,420✔





4554



  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;




3,314,420✔





4555



  STableMergeScanInfo* pInfo = pOperator->info;




3,314,420✔





4556



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,314,420✔





4557












4558



  if (pInfo->mSkipTables == NULL) {




3,314,420✔





4559



    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,




243,941✔





4560



                                      taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);










4561



    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);




243,941✔





4562



  }










4563



  int bSkip = 1;




3,314,420✔





4564



  if (pInfo->mSkipTables != NULL) {




3,314,420✔





4565



    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));




3,314,420✔





4566



    if (code == TSDB_CODE_DUP_KEY) {




3,314,420✔





4567



      code = TSDB_CODE_SUCCESS;




×







4568



    }










4569



    QUERY_CHECK_CODE(code, lino, _end);




3,314,420✔





4570



  }










4571












4572



_end:




3,314,420✔





4573



  if (code != TSDB_CODE_SUCCESS) {




3,314,420✔





4574



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4575



    pTaskInfo->code = code;




×







4576



    T_LONG_JMP(pTaskInfo->env, code);




×







4577



  }










4578



}




3,314,420✔





4579












4580



static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {




174,361,074✔





4581



  STableMergeScanInfo* pInfo = pOperator->info;




174,361,074✔





4582



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




174,379,594✔





4583



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




174,363,031✔





4584



  SSDataBlock*         pBlock = pInfo->pReaderBlock;




174,352,547✔





4585



  int32_t              code = 0;




174,368,241✔





4586



  bool                 hasNext = false;




174,368,241✔





4587



  STsdbReader*         reader = pInfo->base.dataReader;




174,378,841✔





4588












4589



  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);




174,368,985✔





4590



  if (code != 0) {




174,325,315✔





4591



    pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4592



    qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo));




×







4593



    pTaskInfo->code = code;




×







4594



    return code;




×







4595



  }










4596












4597



  if (!hasNext || isTaskKilled(pTaskInfo)) {




174,325,315✔





4598



    if (isTaskKilled(pTaskInfo)) {




31,486,480✔





4599



      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));




449✔





4600



      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




449✔





4601



    }










4602



    *pFinished = true;




31,474,317✔





4603



    return code;




31,470,265✔





4604



  }










4605












4606



  uint32_t status = 0;




142,859,905✔





4607



  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);




142,872,542✔





4608












4609



  if (code != TSDB_CODE_SUCCESS) {




142,860,684✔





4610



    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));




112,470✔





4611



    pTaskInfo->code = code;




112,470✔





4612



    return code;




112,470✔





4613



  }










4614












4615



  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




142,748,214✔





4616



    *pFinished = true;




×







4617



    return code;




×







4618



  }










4619












4620



  // current block is filter out according to filter condition, continue load the next block










4621



  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {




142,748,214✔





4622



    *pSkipped = true;




7,259,400✔





4623



    return code;




7,243,328✔





4624



  }










4625












4626



  return code;




135,480,691✔





4627



}










4628












4629



static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {




177,754,175✔





4630



  STableMergeScanSortSourceParam* source = param;




177,754,175✔





4631












4632



  SOperatorInfo*       pOperator = source->pOperator;




177,754,175✔





4633



  STableMergeScanInfo* pInfo = pOperator->info;




177,759,539✔





4634



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




177,758,881✔





4635



  SSDataBlock*         pBlock = NULL;




177,764,573✔





4636



  int64_t              st = taosGetTimestampUs();




177,756,878✔





4637



  int32_t              code = TSDB_CODE_SUCCESS;




177,756,878✔





4638












4639



  while (true) {










4640



    if (pInfo->rtnNextDurationBlocks) {




194,359,607✔





4641



      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",




19,990,693✔





4642



             GET_TASKID(pTaskInfo), pInfo->nextDurationBlocksIdx, pInfo->numNextDurationBlocks);










4643












4644



      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {




19,995,222✔





4645



        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];




9,361,027✔





4646



        ++pInfo->nextDurationBlocksIdx;




9,360,449✔





4647



      } else {










4648



        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




19,995,386✔





4649



          blockDataDestroy(pInfo->nextDurationBlocks[i]);




9,359,979✔





4650



          pInfo->nextDurationBlocks[i] = NULL;




9,359,979✔





4651



        }










4652












4653



        pInfo->rtnNextDurationBlocks = false;




10,634,829✔





4654



        pInfo->nextDurationBlocksIdx = 0;




10,635,407✔





4655



        pInfo->numNextDurationBlocks = 0;




10,634,829✔





4656



        continue;




10,635,407✔





4657



      }










4658



    } else {










4659



      bool bFinished = false;




174,364,670✔





4660



      bool bSkipped = false;




174,364,566✔





4661












4662



      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);




174,383,502✔





4663



      if (code != 0) {




174,326,974✔





4664



        return code;




112,470✔





4665



      }










4666












4667



      pBlock = pInfo->pReaderBlock;




174,214,504✔





4668



      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",




174,246,466✔





4669



             GET_TASKID(pTaskInfo), bFinished, bSkipped, pInfo->bNextDurationBlockEvent, pInfo->bNewFilesetEvent);










4670



      if (bFinished) {




174,235,715✔





4671



        pInfo->bNewFilesetEvent = false;




31,472,371✔





4672



        break;




31,472,371✔





4673



      }










4674












4675



      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {




142,763,344✔





4676



        if (!bSkipped) {




10,635,861✔





4677



          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);




9,361,027✔





4678



          if (code) {




9,361,027✔





4679



            *ppBlock = NULL;




×







4680



            return code;




×







4681



          }










4682












4683



          ++pInfo->numNextDurationBlocks;




9,361,027✔





4684



          if (pInfo->numNextDurationBlocks > 2) {




9,360,421✔





4685



            qError("%s table merge scan prefetch %d next duration blocks. end early.", GET_TASKID(pTaskInfo),




×







4686



                   pInfo->numNextDurationBlocks);










4687



            pInfo->bNewFilesetEvent = false;




×







4688



            break;




×







4689



          }










4690



        }










4691












4692



        if (pInfo->bNewFilesetEvent) {




10,635,255✔





4693



          pInfo->rtnNextDurationBlocks = true;




10,636,112✔





4694



          *ppBlock = NULL;




10,635,506✔





4695



          return code;




10,635,506✔





4696



        }










4697












4698



        if (pInfo->bNextDurationBlockEvent) {




×







4699



          pInfo->bNextDurationBlockEvent = false;




×







4700



          continue;




×







4701



        }










4702



      }










4703



      if (bSkipped) continue;




132,121,595✔





4704



    }










4705












4706



    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);




135,525,952✔





4707












4708



    pOperator->resultInfo.totalRows += pBlock->info.rows;




135,549,517✔





4709



    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;




135,521,403✔





4710



    *ppBlock = pBlock;




135,480,611✔





4711












4712



    return code;




135,520,146✔





4713



  }










4714












4715



  *ppBlock = NULL;




31,472,390✔





4716



  return code;




31,472,879✔





4717



}










4718












4719



int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {




27,733,636✔





4720



  int32_t code = TSDB_CODE_SUCCESS;




27,733,636✔





4721



  int32_t lino = 0;




27,733,636✔





4722



  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));




27,733,636✔





4723



  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);




27,667,832✔





4724



  SBlockOrderInfo biTs = {0};




27,667,832✔





4725



  SBlockOrderInfo biPk = {0};




27,669,067✔





4726












4727



  int32_t tsTargetSlotId = 0;




27,674,089✔





4728



  int32_t pkTargetSlotId = -1;




27,674,089✔





4729



  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {




103,546,542✔





4730



    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);




75,929,864✔





4731



    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);




75,940,305✔





4732



    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




75,940,305✔





4733



      tsTargetSlotId = colInfo->dstSlotId;




27,736,247✔





4734



      biTs.order = order;




27,688,957✔





4735



      biTs.slotId = tsTargetSlotId;




27,688,957✔





4736



      biTs.nullFirst = (order == TSDB_ORDER_ASC);




27,688,957✔





4737



      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);




27,688,957✔





4738



    }










4739



    // TODO: order by just ts










4740



    if (colInfo->isPk) {




75,926,708✔





4741



      pkTargetSlotId = colInfo->dstSlotId;




2,145,661✔





4742



      biPk.order = order;




2,145,661✔





4743



      biPk.slotId = pkTargetSlotId;




2,145,661✔





4744



      biPk.nullFirst = (order == TSDB_ORDER_ASC);




2,145,661✔





4745



      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);




2,145,661✔





4746



    }










4747



  }










4748












4749



  void* tmp = taosArrayPush(pSortInfo, &biTs);




27,751,964✔





4750



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




27,751,964✔





4751



  if (pkTargetSlotId != -1) {




27,751,964✔





4752



    tmp = taosArrayPush(pSortInfo, &biPk);




2,145,698✔





4753



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




2,145,698✔





4754



  }










4755












4756



  (*ppSortArray) = pSortInfo;




27,752,001✔





4757












4758



_end:




27,725,563✔





4759



  if (code != TSDB_CODE_SUCCESS) {




27,705,146✔





4760



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4761



  }










4762



  return code;




27,705,146✔





4763



}










4764












4765



void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {




39,316,447✔





4766



  STableMergeScanInfo* pTmsInfo = param;




39,316,447✔





4767



  if (type == TSD_READER_NOTIFY_DURATION_START) {




39,316,447✔





4768



    pTmsInfo->bNewFilesetEvent = true;




39,321,258✔





4769



  } else if (type == TSD_READER_NOTIFY_NEXT_DURATION_BLOCK) {




×







4770



    pTmsInfo->bNextDurationBlockEvent = true;




×







4771



  }










4772



  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);




39,325,117✔





4773












4774



  return;




39,336,769✔





4775



}










4776












4777



int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




42,176,629✔





4778



  STableMergeScanInfo* pInfo = pOperator->info;




42,176,629✔





4779



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




42,207,112✔





4780












4781



  int32_t code = TSDB_CODE_SUCCESS;




42,179,998✔





4782



  int32_t lino = 0;




42,179,998✔





4783



  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




42,179,998✔





4784












4785



  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));




42,188,143✔





4786



  pInfo->bNewFilesetEvent = false;




42,205,636✔





4787



  pInfo->bNextDurationBlockEvent = false;




42,203,841✔





4788












4789



  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;




42,197,448✔





4790



  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;




42,149,145✔





4791












4792



  pInfo->pSortHandle = NULL;




42,204,200✔





4793



  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,




84,339,132✔





4794



                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);




42,173,688✔





4795



  if (code) {




42,102,189✔





4796



    return code;




×







4797



  }










4798












4799



  if (pInfo->bSortRowId && numOfTable != 1) {




42,102,189✔





4800



    int32_t memSize = 512 * 1024 * 1024;




4,242,786✔





4801



    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);




4,242,786✔





4802



    QUERY_CHECK_CODE(code, lino, _end);




4,249,744✔





4803



  }










4804












4805



  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);




42,116,457✔





4806



  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);




42,087,281✔





4807



  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);




42,036,669✔





4808












4809



  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);




42,106,231✔





4810



  QUERY_CHECK_CODE(code, lino, _end);




42,076,121✔





4811












4812



  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));




42,076,121✔





4813



  QUERY_CHECK_NULL(param, code, lino, _end, terrno);




42,075,075✔





4814



  param->pOperator = pOperator;




42,075,075✔





4815












4816



  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));




42,081,997✔





4817



  if (ps == NULL) {




42,039,522✔





4818



    taosMemoryFree(param);




×







4819



    QUERY_CHECK_NULL(ps, code, lino, _end, terrno);




×







4820



  }










4821












4822



  ps->param = param;




42,039,522✔





4823



  ps->onlyRef = false;




42,146,277✔





4824



  code = tsortAddSource(pInfo->pSortHandle, ps);




42,147,830✔





4825



  QUERY_CHECK_CODE(code, lino, _end);




42,204,767✔





4826












4827



  if (numOfTable == 1) {




42,204,767✔





4828



    tsortSetSingleTableMerge(pInfo->pSortHandle);




27,818,582✔





4829



  } else {










4830



    code = tsortOpen(pInfo->pSortHandle);




14,386,185✔





4831



    QUERY_CHECK_CODE(code, lino, _end);




14,393,098✔





4832



  }










4833












4834



_end:




14,336,863✔





4835



  if (code != TSDB_CODE_SUCCESS) {




42,214,418✔





4836



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




56,235✔





4837



  }










4838



  return code;




42,214,010✔





4839



}










4840












4841



void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




42,083,721✔





4842



  STableMergeScanInfo* pInfo = pOperator->info;




42,083,721✔





4843



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




42,085,190✔





4844



  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));




42,085,131✔





4845












4846



  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);




42,085,131✔





4847



  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;




42,078,945✔





4848



  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;




42,086,026✔





4849



  pInfo->sortExecInfo.loops += sortExecInfo.loops;




42,076,903✔





4850



  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;




42,078,288✔





4851



  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;




42,081,007✔





4852












4853



  tsortDestroySortHandle(pInfo->pSortHandle);




42,077,804✔





4854



  pInfo->pSortHandle = NULL;




42,071,505✔





4855



}




42,071,056✔





4856












4857



void startGroupTableMergeScan(SOperatorInfo* pOperator) {




31,535,965✔





4858



  int32_t              code = TSDB_CODE_SUCCESS;




31,535,965✔





4859



  int32_t              lino = 0;




31,535,965✔





4860



  STableMergeScanInfo* pInfo = pOperator->info;




31,535,965✔





4861



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




31,555,279✔





4862



  SReadHandle*         pHandle = &pInfo->base.readHandle;




31,534,686✔





4863



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




31,549,903✔





4864



  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




31,487,009✔





4865












4866



  {










4867



    int32_t numOfTables = 0;




31,489,325✔





4868



    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




31,533,713✔





4869



    QUERY_CHECK_CODE(code, lino, _end);




31,465,849✔





4870












4871



    int32_t i = pInfo->tableStartIndex + 1;




31,465,849✔





4872



    for (; i < numOfTables; ++i) {




138,293,706✔





4873



      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




112,841,201✔





4874



      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);




112,838,353✔





4875



      if (tableKeyInfo->groupId != pInfo->groupId) {




112,838,353✔





4876



        break;




5,975,978✔





4877



      }










4878



    }










4879



    pInfo->tableEndIndex = i - 1;




31,428,483✔





4880



  }










4881



  pInfo->bGroupProcessed = false;




31,576,167✔





4882



  int32_t tableStartIdx = pInfo->tableStartIndex;




31,578,043✔





4883



  int32_t tableEndIdx = pInfo->tableEndIndex;




31,567,751✔





4884












4885



  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;




31,572,861✔





4886



  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);




31,572,861✔





4887



  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,




63,060,747✔





4888



                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);




31,522,031✔





4889



  QUERY_CHECK_CODE(code, lino, _end);




31,566,495✔





4890



  if (pInfo->filesetDelimited) {




31,566,495✔





4891



    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);




31,574,358✔





4892



  }










4893



  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);




31,555,518✔





4894












4895



  code = startDurationForGroupTableMergeScan(pOperator);




31,540,399✔





4896



  QUERY_CHECK_CODE(code, lino, _end);




31,578,991✔





4897












4898



_end:




31,522,756✔





4899



  if (code != TSDB_CODE_SUCCESS) {




31,577,147✔





4900



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




56,235✔





4901



    pTaskInfo->code = code;




56,235✔





4902



    T_LONG_JMP(pTaskInfo->env, code);




56,235✔





4903



  }










4904



}




31,520,912✔





4905












4906



void stopGroupTableMergeScan(SOperatorInfo* pOperator) {




31,446,817✔





4907



  STableMergeScanInfo* pInfo = pOperator->info;




31,446,817✔





4908



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




31,449,570✔





4909



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




31,448,672✔





4910












4911



  stopDurationForGroupTableMergeScan(pOperator);




31,450,531✔





4912












4913



  if (pInfo->base.dataReader != NULL) {




31,435,090✔





4914



    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);




31,440,200✔





4915



    pInfo->base.dataReader = NULL;




31,426,301✔





4916



  }










4917



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




31,429,644✔





4918



    if (pInfo->nextDurationBlocks[i]) {




1,048✔





4919



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




1,048✔





4920



      pInfo->nextDurationBlocks[i] = NULL;




1,048✔





4921



    }










4922



    pInfo->numNextDurationBlocks = 0;




1,048✔





4923



    pInfo->nextDurationBlocksIdx = 0;




1,048✔





4924



  }










4925



  resetLimitInfoForNextGroup(&pInfo->limitInfo);




31,437,889✔





4926



  taosHashCleanup(pInfo->mSkipTables);




31,421,909✔





4927



  pInfo->mSkipTables = NULL;




31,421,062✔





4928



  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




31,423,713✔





4929



}




31,431,403✔





4930












4931



// all data produced by this function only belongs to one group










4932



// slimit/soffset does not need to be concerned here, since this function only deal with data within one group.










4933



SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,




83,216,695✔





4934



                                              SOperatorInfo* pOperator) {










4935



  STableMergeScanInfo* pInfo = pOperator->info;




83,216,695✔





4936



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




83,229,303✔





4937



  STupleHandle*        pTupleHandle = NULL;




83,229,035✔





4938












4939



  blockDataCleanup(pResBlock);




83,228,686✔





4940












4941



  while (1) {




×







4942



    while (1) {




2,147,483,647✔





4943



      pTupleHandle = NULL;




2,147,483,647✔





4944



      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);




2,147,483,647✔





4945



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





4946



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




238,954✔





4947



        T_LONG_JMP(pOperator->pTaskInfo->env, code);




238,954✔





4948



      }










4949



      if (pTupleHandle == NULL) {




2,147,483,647✔





4950



        break;




70,789,397✔





4951



      }










4952












4953



      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);




2,147,483,647✔





4954



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





4955



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4956



        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







4957



      }










4958












4959



      if (pResBlock->info.rows >= capacity) {




2,147,483,647✔





4960



        break;




12,396,462✔





4961



      }










4962



    }










4963












4964



    if (tsortIsClosed(pHandle)) {




83,185,859✔





4965



      terrno = TSDB_CODE_TSC_QUERY_CANCELLED;




×







4966



      T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







4967



    }










4968












4969



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);




83,191,280✔





4970



    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,




83,189,462✔





4971



           pInfo->limitInfo.numOfOutputRows);










4972



    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {




83,187,545✔





4973



      break;










4974



    }










4975



  }










4976



  return (pResBlock->info.rows > 0) ? pResBlock : NULL;




83,187,545✔





4977



}










4978












4979



int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




69,298,512✔





4980



  if (pOperator->status == OP_EXEC_DONE) {




69,298,512✔





4981



    (*ppRes) = NULL;




25,155✔





4982



    return TSDB_CODE_SUCCESS;




25,155✔





4983



  }










4984












4985



  int32_t              code = TSDB_CODE_SUCCESS;




69,243,007✔





4986



  int32_t              lino = 0;




69,243,007✔





4987



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




69,243,007✔





4988



  STableMergeScanInfo* pInfo = pOperator->info;




69,198,732✔





4989












4990



  code = pOperator->fpSet._openFn(pOperator);




69,272,800✔





4991



  QUERY_CHECK_CODE(code, lino, _end);




69,199,882✔





4992












4993



  int64_t st = taosGetTimestampUs();




69,228,964✔





4994












4995



  int32_t tableListSize = 0;




69,228,964✔





4996



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




69,263,023✔





4997



  QUERY_CHECK_CODE(code, lino, _end);




69,274,513✔





4998












4999



  if (!pInfo->hasGroupId) {




69,274,513✔





5000



    pInfo->hasGroupId = true;




28,170,412✔





5001












5002



    if (tableListSize == 0) {




28,115,640✔





5003



      setOperatorCompleted(pOperator);




2,617,544✔





5004



      (*ppRes) = NULL;




2,617,544✔





5005



      return code;




2,617,544✔





5006



    }










5007



    pInfo->tableStartIndex = 0;




25,498,096✔





5008



    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




25,507,959✔





5009



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




25,495,726✔





5010



    pInfo->groupId = tmp->groupId;




25,495,726✔





5011



    startGroupTableMergeScan(pOperator);




25,559,520✔





5012



  }










5013












5014



  SSDataBlock* pBlock = NULL;




66,635,630✔





5015



  while (pInfo->tableStartIndex < tableListSize) {




83,247,457✔





5016



    if (isTaskKilled(pTaskInfo)) {




83,256,723✔





5017



      goto _end;




19,476✔





5018



    }










5019












5020



    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,




83,236,746✔





5021



                                              pOperator);










5022



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




83,185,650✔





5023



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,759,968✔





5024



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




1,759,968✔





5025



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




1,759,968✔





5026



    }










5027



    if (pBlock != NULL) {




83,184,693✔





5028



      pBlock->info.id.groupId = pInfo->groupId;




41,099,054✔





5029



      pOperator->resultInfo.totalRows += pBlock->info.rows;




41,098,227✔





5030



      pInfo->bGroupProcessed = true;




41,099,153✔





5031



      break;




41,097,398✔





5032



    } else {










5033



      if (pInfo->bNewFilesetEvent) {




42,085,639✔





5034



        stopDurationForGroupTableMergeScan(pOperator);




10,636,455✔





5035



        code = startDurationForGroupTableMergeScan(pOperator);




10,636,455✔





5036



        QUERY_CHECK_CODE(code, lino, _end);




10,635,849✔





5037



      } else {










5038



        // Data of this group are all dumped, let's try the next group










5039



        stopGroupTableMergeScan(pOperator);




31,448,676✔





5040



        if (pInfo->tableEndIndex >= tableListSize - 1) {




31,444,055✔





5041



          setOperatorCompleted(pOperator);




25,465,264✔





5042



          break;




25,471,838✔





5043



        }










5044












5045



        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




5,975,978✔





5046



        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




5,975,488✔





5047



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




5,975,978✔





5048



        pInfo->groupId = tmp->groupId;




5,975,978✔





5049



        startGroupTableMergeScan(pOperator);




5,975,978✔





5050



        resetLimitInfoForNextGroup(&pInfo->limitInfo);




5,975,978✔





5051



      }










5052



    }










5053



  }










5054












5055



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




66,567,161✔





5056












5057



_end:




66,593,932✔





5058



  if (code != TSDB_CODE_SUCCESS) {




66,594,893✔





5059



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5060



    pTaskInfo->code = code;




×







5061



    T_LONG_JMP(pTaskInfo->env, code);




×







5062



  } else {










5063



    (*ppRes) = pBlock;




66,594,893✔





5064



  }










5065












5066



  return code;




66,593,979✔





5067



}










5068












5069



static SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {




×







5070



  SSDataBlock* pRes = NULL;




×







5071



  int32_t      code = doTableMergeScanNext(pOperator, &pRes);




×







5072



  return pRes;




×







5073



}










5074












5075



void destroyTableMergeScanOperatorInfo(void* param) {




27,760,063✔





5076



  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;




27,760,063✔





5077












5078



  // start one reader variable










5079



  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {




27,760,063✔





5080



    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);




27,764,686✔





5081



    pTableScanInfo->base.dataReader = NULL;




27,760,511✔





5082



  }










5083












5084



  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {




27,761,683✔





5085



    if (pTableScanInfo->nextDurationBlocks[i] != NULL) {




×







5086



      blockDataDestroy(pTableScanInfo->nextDurationBlocks[i]);




×







5087



      pTableScanInfo->nextDurationBlocks[i] = NULL;




×







5088



    }










5089



  }










5090












5091



  tsortDestroySortHandle(pTableScanInfo->pSortHandle);




27,757,441✔





5092



  pTableScanInfo->pSortHandle = NULL;




27,750,450✔





5093



  taosHashCleanup(pTableScanInfo->mSkipTables);




27,752,262✔





5094



  pTableScanInfo->mSkipTables = NULL;




27,755,262✔





5095



  blockDataDestroy(pTableScanInfo->pSortInputBlock);




27,760,532✔





5096



  pTableScanInfo->pSortInputBlock = NULL;




27,760,116✔





5097



  // end one reader variable










5098












5099



  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);




27,760,605✔





5100












5101



  blockDataDestroy(pTableScanInfo->pResBlock);




27,768,646✔





5102



  pTableScanInfo->pResBlock = NULL;




27,768,686✔





5103












5104



  // remove it from the task->result list










5105



  blockDataDestroy(pTableScanInfo->pReaderBlock);




27,768,686✔





5106



  pTableScanInfo->pReaderBlock = NULL;




27,767,829✔





5107



  taosArrayDestroy(pTableScanInfo->pSortInfo);




27,767,829✔





5108












5109



  stopSubTablesTableMergeScan(pTableScanInfo);




27,767,801✔





5110












5111



  taosMemoryFreeClear(param);




27,765,477✔





5112



}




27,764,566✔





5113












5114



int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {




1,198,622✔





5115



  if (pOptr == NULL) {




1,198,622✔





5116



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));




×







5117



    return TSDB_CODE_INVALID_PARA;




×







5118



  }










5119



  // TODO: merge these two info into one struct










5120



  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));




1,198,622✔





5121



  if (!execInfo) {




1,198,622✔





5122



    return terrno;




×







5123



  }










5124



  STableMergeScanInfo* pInfo = pOptr->info;




1,198,622✔





5125



  execInfo->blockRecorder = pInfo->base.readRecorder;




1,198,622✔





5126



  execInfo->sortExecInfo = pInfo->sortExecInfo;




1,199,130✔





5127












5128



  *pOptrExplain = execInfo;




1,198,622✔





5129



  *len = sizeof(STableMergeScanExecInfo);




1,198,622✔





5130












5131



  return TSDB_CODE_SUCCESS;




1,198,622✔





5132



}










5133












5134



static int32_t resetTableMergeScanOperatorState(SOperatorInfo* pOper) {




2,270,811✔





5135



  int32_t         code = TSDB_CODE_SUCCESS;




2,270,811✔





5136



  STableMergeScanInfo*   pInfo = pOper->info;




2,270,811✔





5137



  pOper->status = OP_NOT_OPENED;




2,270,811✔





5138












5139



  pInfo->tableEndIndex = 0;




2,270,811✔





5140



  pInfo->tableStartIndex = 0;




2,270,811✔





5141



  pInfo->hasGroupId = false;




2,270,811✔





5142



  if (pInfo->base.readerAPI.tsdReaderClose) {




2,270,811✔





5143



    pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);




2,270,811✔





5144



  }










5145



  pInfo->base.dataReader = NULL;




2,270,811✔





5146



  pInfo->base.scanFlag = MAIN_SCAN;




2,270,811✔





5147












5148



  pInfo->base.limitInfo = (SLimitInfo){0};




2,270,811✔





5149



  pInfo->base.limitInfo.limit.limit = -1;




2,270,811✔





5150



  pInfo->base.limitInfo.slimit.limit = -1;




2,270,811✔





5151












5152



  tableListDestroy(pInfo->base.pTableListInfo);




2,270,811✔





5153



  pInfo->base.pTableListInfo = tableListCreate();




2,270,811✔





5154



  if (!pInfo->base.pTableListInfo) {




2,270,811✔





5155



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







5156



    return terrno;




×







5157



  }










5158



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




2,270,811✔





5159












5160



  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;




2,270,811✔





5161



  code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,




4,541,622✔





5162



                                  &pInfo->base.readHandle, pInfo->base.pTableListInfo, 










5163



                                  pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);




4,541,384✔





5164



  if (code) {




2,270,811✔





5165



    qError("%s failed to createScanTableListInfo, code:%s", __func__, tstrerror(code));




×







5166



    return code;




×







5167



  }










5168












5169



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




2,270,811✔





5170



  cleanupQueryTableDataCond(&pInfo->base.cond);




2,270,811✔





5171



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, false);




2,270,811✔





5172



  if (code) {




2,270,573✔





5173



    qError("%s failed to initQueryTableDataCond, code:%s", __func__, tstrerror(code));




×







5174



    return code;




×







5175



  }










5176












5177



  tsortDestroySortHandle(pInfo->pSortHandle);




2,270,573✔





5178



  pInfo->pSortHandle = NULL;




2,270,573✔





5179












5180



  taosHashCleanup(pInfo->mSkipTables);




2,270,573✔





5181



  pInfo->mSkipTables = NULL;




2,270,811✔





5182



  pOper->resultInfo.totalRows = 0;




2,270,811✔





5183



  










5184



  pInfo->bGroupProcessed = false;




2,270,811✔





5185



  pInfo->bNewFilesetEvent = false;




2,270,811✔





5186



  pInfo->bNextDurationBlockEvent = false;




2,270,811✔





5187



  pInfo->rtnNextDurationBlocks = false;




2,270,573✔





5188



  pInfo->nextDurationBlocksIdx = 0;




2,270,573✔





5189



  pInfo->bSortRowId = false;




2,270,811✔





5190












5191



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




2,270,811✔





5192



    if (pInfo->nextDurationBlocks[i] != NULL) {




×







5193



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




×







5194



      pInfo->nextDurationBlocks[i] = NULL;




×







5195



    }










5196



  }










5197



  pInfo->numNextDurationBlocks = 0;




2,270,811✔





5198












5199



  stopSubTablesTableMergeScan(pInfo);




2,270,811✔





5200



  return code;




2,270,573✔





5201



}










5202












5203



int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




27,711,414✔





5204



                                         STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










5205



                                         SOperatorInfo** pOptrInfo) {










5206



  QRY_PARAM_CHECK(pOptrInfo);




27,711,414✔





5207












5208



  int32_t              code = TSDB_CODE_SUCCESS;




27,721,801✔





5209



  int32_t              lino = 0;




27,721,801✔





5210



  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));




27,721,801✔





5211



  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




27,600,244✔





5212



  if (pInfo == NULL || pOperator == NULL) {




27,598,171✔





5213



    code = terrno;




153✔





5214



    goto _error;




×







5215



  }










5216












5217



  pOperator->pPhyNode = pTableScanNode;




27,599,141✔





5218



  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;




27,602,222✔





5219












5220



  int32_t numOfCols = 0;




27,652,879✔





5221



  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,




27,667,570✔





5222



                             &pInfo->base.matchInfo);










5223



  QUERY_CHECK_CODE(code, lino, _error);




27,718,385✔





5224












5225



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, false);




27,718,385✔





5226



  QUERY_CHECK_CODE(code, lino, _error);




27,674,204✔





5227












5228



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




27,674,204✔





5229



    SExprSupp* pSup = &pInfo->base.pseudoSup;




10,245,264✔





5230



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);




10,254,032✔





5231



    QUERY_CHECK_CODE(code, lino, _error);




10,255,879✔





5232












5233



    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,




10,255,879✔





5234



                                      &pTaskInfo->storageAPI.functionStore);










5235



    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);




10,250,238✔





5236



  }










5237












5238



  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};




27,663,862✔





5239












5240



  if (readHandle->streamRtInfo == NULL) {




27,586,614✔





5241



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(1024 * 128, -1, .5);




27,699,857✔





5242



    QUERY_CHECK_NULL(pInfo->base.metaCache.pTableMetaEntryCache, code, lino, _error, terrno);




27,745,114✔





5243



  }










5244



  










5245



  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;




27,708,196✔





5246



  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




27,738,661✔





5247



  pInfo->base.scanFlag = MAIN_SCAN;




27,646,427✔





5248



  pInfo->base.readHandle = *readHandle;




27,732,490✔





5249












5250



  pInfo->readIdx = -1;




27,696,046✔





5251












5252



  pInfo->base.limitInfo.limit.limit = -1;




27,678,883✔





5253



  pInfo->base.limitInfo.slimit.limit = -1;




27,708,508✔





5254



  pInfo->base.pTableListInfo = pTableListInfo;




27,728,798✔





5255












5256



  pInfo->sample.sampleRatio = pTableScanNode->ratio;




27,665,659✔





5257



  pInfo->sample.seed = taosGetTimestampSec();




27,703,015✔





5258












5259



  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,




27,679,575✔





5260



                            pTaskInfo->pStreamRuntimeInfo);




27,705,095✔





5261



  QUERY_CHECK_CODE(code, lino, _error);




27,679,251✔





5262












5263



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




27,679,251✔





5264












5265



  pInfo->mergeLimit = -1;




27,684,860✔





5266



  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;




27,695,792✔





5267



  if (hasLimit) {




27,739,682✔





5268



    pInfo->mergeLimit = pInfo->limitInfo.limit.offset != -1




2,866,450✔





5269



                            ? pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset




880,832✔





5270



                            : pInfo->limitInfo.limit.limit;




2,312,796✔





5271



    pInfo->mSkipTables = NULL;




1,432,973✔





5272



  }










5273












5274



  initResultSizeInfo(&pOperator->resultInfo, 1024);




27,739,816✔





5275



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




27,641,888✔





5276



  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);




27,753,001✔





5277



  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);




27,717,002✔





5278



  QUERY_CHECK_CODE(code, lino, _error);




27,738,434✔





5279



  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {




27,738,434✔





5280



    pInfo->bSortRowId = true;




5,189,786✔





5281



  } else {










5282



    pInfo->bSortRowId = false;




22,557,838✔





5283



  }










5284












5285



  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);




27,681,337✔





5286



  QUERY_CHECK_CODE(code, lino, _error);




27,713,749✔





5287












5288



  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo);




27,713,749✔





5289



  QUERY_CHECK_CODE(code, lino, _error);




27,684,028✔





5290












5291



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);




27,684,028✔





5292



  QUERY_CHECK_CODE(code, lino, _error);




27,728,676✔





5293












5294



  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;




27,728,676✔





5295












5296



  int32_t  rowSize = pInfo->pResBlock->info.rowSize;




27,736,372✔





5297



  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);




27,736,242✔





5298












5299



  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);




27,715,299✔





5300












5301



  // start one reader variable










5302



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);




27,737,652✔





5303



  QUERY_CHECK_CODE(code, lino, _error);




27,730,533✔





5304












5305



  if (!tsExperimental) {




27,730,533✔





5306



    pInfo->filesetDelimited = false;




×







5307



  } else {










5308



    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




27,730,533✔





5309



  }










5310



  // end one reader variable










5311



  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,




27,747,682✔





5312



                  pInfo, pTaskInfo);










5313



  pOperator->exprSupp.numOfExprs = numOfCols;




27,705,515✔





5314












5315



  pOperator->fpSet = createOperatorFpSet(




27,651,562✔





5316



      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,




27,735,222✔





5317



      destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn,










5318



      NULL);










5319



  setOperatorResetStateFn(pOperator, resetTableMergeScanOperatorState);     




27,662,732✔





5320



  pOperator->cost.openCost = 0;




27,681,752✔





5321












5322



  *pOptrInfo = pOperator;




27,678,141✔





5323



  return code;




27,613,302✔





5324












5325



_error:




×







5326



  if (code != TSDB_CODE_SUCCESS) {




×







5327



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5328



  }










5329



  pTaskInfo->code = code;




×







5330



  if (pInfo != NULL) {




×







5331



    pInfo->base.pTableListInfo = NULL;




×







5332



    destroyTableMergeScanOperatorInfo(pInfo);




×







5333



  }










5334



  if (pOperator != NULL) {




×







5335



    pOperator->info = NULL;




×







5336



    destroyOperator(pOperator);




×







5337



  }










5338



  return code;




×







5339



}










5340












5341



// ====================================================================================================================










5342



// TableCountScanOperator










5343



static void        destoryTableCountScanOperator(void* param);










5344



static int32_t     buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5345



                                                  SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI);










5346



static int32_t     buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5347



                                                  SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI);










5348



static int32_t     buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5349



                                             STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName);










5350



static int32_t     buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5351



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName);










5352



static int32_t     buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5353



                                          STableCountScanSupp* pSupp, SSDataBlock* pRes);










5354



static void        buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5355



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5356



                                               size_t perfdbTableNum);










5357



static void        buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,










5358



                                              size_t infodbTableNum, size_t perfdbTableNum);










5359



static const char* GROUP_TAG_DB_NAME = "db_name";










5360



static const char* GROUP_TAG_STABLE_NAME = "stable_name";










5361












5362



int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {




25,450✔





5363



  if (scanCols != NULL) {




25,450✔





5364



    SNode* pNode = NULL;




14,583✔





5365



    FOREACH(pNode, scanCols) {




34,060✔





5366



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




19,477✔





5367



        return TSDB_CODE_QRY_SYS_ERROR;




×







5368



      }










5369



      STargetNode* targetNode = (STargetNode*)pNode;




19,477✔





5370



      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {




19,477✔





5371



        return TSDB_CODE_QRY_SYS_ERROR;




×







5372



      }










5373



      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);




19,477✔





5374



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




19,477✔





5375



        supp->dbNameSlotId = targetNode->slotId;




9,624✔





5376



      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




9,853✔





5377



        supp->stbNameSlotId = targetNode->slotId;




9,853✔





5378



      }










5379



    }










5380



  }










5381



  return TSDB_CODE_SUCCESS;




25,450✔





5382



}










5383












5384



int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {




25,450✔





5385



  if (pseudoCols != NULL) {




25,450✔





5386



    SNode* pNode = NULL;




25,450✔





5387



    FOREACH(pNode, pseudoCols) {




50,900✔





5388



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




25,450✔





5389



        return TSDB_CODE_QRY_SYS_ERROR;




×







5390



      }










5391



      STargetNode* targetNode = (STargetNode*)pNode;




25,450✔





5392



      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {




25,450✔





5393



        return TSDB_CODE_QRY_SYS_ERROR;




×







5394



      }










5395



      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);




25,450✔





5396



      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {




25,450✔





5397



        supp->tbCountSlotId = targetNode->slotId;




25,450✔





5398



      }










5399



    }










5400



  }










5401



  return TSDB_CODE_SUCCESS;




25,450✔





5402



}










5403












5404



int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {




25,450✔





5405



  if (groupTags != NULL) {




25,450✔





5406



    SNode* pNode = NULL;




14,583✔





5407



    FOREACH(pNode, groupTags) {




34,060✔





5408



      if (nodeType(pNode) != QUERY_NODE_COLUMN) {




19,477✔





5409



        return TSDB_CODE_QRY_SYS_ERROR;




×







5410



      }










5411



      SColumnNode* colNode = (SColumnNode*)pNode;




19,477✔





5412



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




19,477✔





5413



        supp->groupByDbName = true;




9,624✔





5414



      }










5415



      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




19,477✔





5416



        supp->groupByStbName = true;




9,853✔





5417



      }










5418



    }










5419



  } else {










5420



    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);




10,867✔





5421



    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);




10,867✔





5422



  }










5423



  return TSDB_CODE_SUCCESS;




25,450✔





5424



}










5425












5426



int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,




25,450✔





5427



                              STableCountScanSupp* supp, SExecTaskInfo* taskInfo) {










5428



  int32_t code = 0;




25,450✔





5429



  code = tblCountScanGetInputs(groupTags, tableName, supp);




25,450✔





5430



  if (code != TSDB_CODE_SUCCESS) {




25,450✔





5431



    qError("%s get table count scan supp. get inputs error", GET_TASKID(taskInfo));




×







5432



    return code;




×







5433



  }










5434












5435



  supp->dbNameSlotId = -1;




25,450✔





5436



  supp->stbNameSlotId = -1;




25,450✔





5437



  supp->tbCountSlotId = -1;




25,450✔





5438












5439



  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);




25,450✔





5440



  if (code != TSDB_CODE_SUCCESS) {




25,450✔





5441



    qError("%s get table count scan supp. get group tags slot id error", GET_TASKID(taskInfo));




×







5442



    return code;




×







5443



  }










5444












5445



  code = tblCountScanGetCountSlotId(pseudoCols, supp);




25,450✔





5446



  if (code != TSDB_CODE_SUCCESS) {




25,450✔





5447



    qError("%s get table count scan supp. get count error", GET_TASKID(taskInfo));




×







5448



    return code;




×







5449



  }










5450



  return code;




25,450✔





5451



}










5452












5453



int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,




25,450✔





5454



                                         SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










5455



  QRY_PARAM_CHECK(pOptrInfo);




25,450✔





5456












5457



  int32_t                      code = TSDB_CODE_SUCCESS;




25,450✔





5458



  int32_t                      lino = 0;




25,450✔





5459



  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;




25,450✔





5460



  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));




25,450✔





5461



  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




25,450✔





5462



  if (!pInfo || !pOperator) {




25,450✔





5463



    code = terrno;




×







5464



    goto _error;




×







5465



  }










5466












5467



  pInfo->readHandle = *readHandle;




25,450✔





5468












5469



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




25,450✔





5470



  initResultSizeInfo(&pOperator->resultInfo, 1);




25,450✔





5471



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




25,450✔





5472



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




25,450✔





5473












5474



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




25,450✔





5475



  QUERY_CHECK_CODE(code, lino, _error);




25,450✔





5476












5477



  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,




25,450✔





5478



                               pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp,










5479



                               pTaskInfo);










5480



  QUERY_CHECK_CODE(code, lino, _error);




25,450✔





5481












5482



  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,




25,450✔





5483



                  pInfo, pTaskInfo);










5484



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,




25,450✔





5485



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










5486



  *pOptrInfo = pOperator;




25,450✔





5487



  return code;




25,450✔





5488












5489



_error:




×







5490



  if (pInfo != NULL) {




×







5491



    destoryTableCountScanOperator(pInfo);




×







5492



  }










5493



  if (pOperator != NULL) {




×







5494



    pOperator->info = NULL;




×







5495



    destroyOperator(pOperator);




×







5496



  }










5497



  pTaskInfo->code = code;




×







5498



  return code;




×







5499



}










5500












5501



int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,




35,439✔





5502



                                    SSDataBlock* pRes) {










5503



  int32_t code = TSDB_CODE_SUCCESS;




35,439✔





5504



  int32_t lino = 0;




35,439✔





5505



  if (pSupp->dbNameSlotId != -1) {




35,439✔





5506



    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




14,522✔





5507



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);




14,522✔





5508



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




14,522✔





5509












5510



    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




14,522✔





5511



    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);




14,522✔





5512












5513



    varDataSetLen(varDbName, strlen(dbName));




14,522✔





5514



    code = colDataSetVal(colInfoData, 0, varDbName, false);




14,522✔





5515



    QUERY_CHECK_CODE(code, lino, _end);




14,522✔





5516



  }










5517












5518



  if (pSupp->stbNameSlotId != -1) {




35,439✔





5519



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);




18,886✔





5520



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




18,886✔





5521



    if (strlen(stbName) != 0) {




18,886✔





5522



      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,600✔





5523



      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);




13,600✔





5524



      varDataSetLen(varStbName, strlen(stbName));




13,600✔





5525



      code = colDataSetVal(colInfoData, 0, varStbName, false);




13,600✔





5526



      QUERY_CHECK_CODE(code, lino, _end);




13,600✔





5527



    } else {










5528



      colDataSetNULL(colInfoData, 0);










5529



    }










5530



  }










5531












5532



  if (pSupp->tbCountSlotId != -1) {




35,439✔





5533



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);




35,439✔





5534



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




35,439✔





5535



    code = colDataSetVal(colInfoData, 0, (char*)&count, false);




35,439✔





5536



    QUERY_CHECK_CODE(code, lino, _end);




35,439✔





5537



  }










5538



  pRes->info.rows = 1;




35,439✔





5539












5540



_end:




35,439✔





5541



  if (code != TSDB_CODE_SUCCESS) {




35,439✔





5542



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5543



  }










5544



  return code;




35,439✔





5545



}










5546












5547



static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {




10,618✔





5548



  STableCountScanSupp* pSupp = &pInfo->supp;




10,618✔





5549



  SSDataBlock*         pRes = pInfo->pRes;




10,618✔





5550












5551



  size_t infodbTableNum;




10,618✔





5552



  getInfosDbMeta(NULL, &infodbTableNum);




10,618✔





5553



  infodbTableNum -= 1;




10,618✔





5554



  size_t perfdbTableNum;




10,618✔





5555



  getPerfDbMeta(NULL, &perfdbTableNum);




10,618✔





5556












5557



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




10,618✔





5558



    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);




9,135✔





5559



    return (pRes->info.rows > 0) ? pRes : NULL;




9,135✔





5560



  } else {










5561



    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);




1,483✔





5562



    return (pRes->info.rows > 0) ? pRes : NULL;




1,483✔





5563



  }










5564



}










5565












5566



static void buildSysDbFilterTableCount(SOperatorInfo* pOperator,




1,483✔





5567



                                       STableCountScanSupp* pSupp,










5568



                                       SSDataBlock* pRes,










5569



                                       size_t infodbTableNum,










5570



                                       size_t perfdbTableNum) {










5571



  int32_t        code = TSDB_CODE_SUCCESS;




1,483✔





5572



  int32_t        lino = 0;




1,483✔





5573



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,483✔





5574



  if (strlen(pSupp->stbNameFilter) != 0) {




1,483✔





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) {




982✔





5579



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB,




167✔





5580



                                       "", infodbTableNum, pRes);










5581



    QUERY_CHECK_CODE(code, lino, _end);




167✔





5582



  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {




815✔





5583



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB,




×







5584



                                       "", perfdbTableNum, pRes);










5585



    QUERY_CHECK_CODE(code, lino, _end);




×







5586



  } else if (strlen(pSupp->dbNameFilter) == 0) {




815✔





5587



    code = fillTableCountScanDataBlock(pSupp, "", "",




648✔





5588



                                       infodbTableNum + perfdbTableNum, pRes);




648✔





5589



    QUERY_CHECK_CODE(code, lino, _end);




648✔





5590



  } else {










5591



    // other dbs do not exist in sys dbs, so the count is always 0










5592



    code = fillTableCountScanDataBlock(pSupp, pSupp->dbNameFilter,




167✔





5593



                                       pSupp->stbNameFilter, 0, pRes);




167✔





5594



    QUERY_CHECK_CODE(code, lino, _end);




167✔





5595



  }










5596












5597



_end:




167✔





5598



  if (code != TSDB_CODE_SUCCESS) {




1,483✔





5599



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5600



    pTaskInfo->code = code;




×







5601



    T_LONG_JMP(pTaskInfo->env, code);




×







5602



  }










5603



  setOperatorCompleted(pOperator);




1,483✔





5604



}




1,483✔





5605












5606



static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




9,135✔





5607



                                        STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5608



                                        size_t perfdbTableNum) {










5609



  int32_t        code = TSDB_CODE_SUCCESS;




9,135✔





5610



  int32_t        lino = 0;




9,135✔





5611



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,135✔





5612



  if (pInfo->currGrpIdx == 0) {




9,135✔





5613



    uint64_t groupId = 0;




3,045✔





5614



    if (pSupp->groupByDbName) {




3,045✔





5615



      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));




2,078✔





5616



    } else {










5617



      groupId = calcGroupId("", 0);




967✔





5618



    }










5619












5620



    pRes->info.id.groupId = groupId;




3,045✔





5621



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




3,045✔





5622



    QUERY_CHECK_CODE(code, lino, _end);




3,045✔





5623



  } else if (pInfo->currGrpIdx == 1) {




6,090✔





5624



    uint64_t groupId = 0;




3,045✔





5625



    if (pSupp->groupByDbName) {




3,045✔





5626



      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));




2,078✔





5627



    } else {










5628



      groupId = calcGroupId("", 0);




967✔





5629



    }










5630












5631



    pRes->info.id.groupId = groupId;




3,045✔





5632



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




3,045✔





5633



    QUERY_CHECK_CODE(code, lino, _end);




3,045✔





5634



  } else {










5635



    setOperatorCompleted(pOperator);




3,045✔





5636



  }










5637



  pInfo->currGrpIdx++;




9,135✔





5638












5639



_end:




9,135✔





5640



  if (code != TSDB_CODE_SUCCESS) {




9,135✔





5641



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5642



    pTaskInfo->code = code;




×







5643



    T_LONG_JMP(pTaskInfo->env, code);




×







5644



  }










5645



}




9,135✔





5646












5647



static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




60,889✔





5648



  int32_t                      code = TSDB_CODE_SUCCESS;




60,889✔





5649



  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;




60,889✔





5650



  STableCountScanOperatorInfo* pInfo = pOperator->info;




60,889✔





5651



  STableCountScanSupp*         pSupp = &pInfo->supp;




60,889✔





5652



  SSDataBlock*                 pRes = pInfo->pRes;




60,889✔





5653












5654



  blockDataCleanup(pRes);




60,889✔





5655



  QRY_PARAM_CHECK(ppRes);




60,889✔





5656












5657



  if (pOperator->status == OP_EXEC_DONE) {




60,889✔





5658



    return code;




14,641✔





5659



  }










5660












5661



  if (pInfo->readHandle.mnd != NULL) {




46,248✔





5662



    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);




10,618✔





5663



    return code;




10,618✔





5664



  }










5665












5666



  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);




35,630✔





5667



  if (code != TSDB_CODE_SUCCESS) {




35,630✔





5668



    qError("%s failed since %s", __func__, tstrerror(code));




×







5669



    pTaskInfo->code = code;




×







5670



    T_LONG_JMP(pTaskInfo->env, code);




×







5671



  }










5672



  if (pRes->info.rows > 0) {




35,630✔





5673



    *ppRes = pRes;




27,866✔





5674



  }










5675












5676



  return code;




35,630✔





5677



}










5678












5679



static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




35,630✔





5680



                                      STableCountScanSupp* pSupp, SSDataBlock* pRes) {










5681



  int32_t        code = TSDB_CODE_SUCCESS;




35,630✔





5682



  int32_t        lino = 0;




35,630✔





5683



  const char*    db = NULL;




35,630✔





5684



  int32_t        vgId = 0;




35,630✔





5685



  char           dbName[TSDB_DB_NAME_LEN] = {0};




35,630✔





5686



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




35,630✔





5687



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




35,630✔





5688












5689



  // get dbname










5690



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);




35,630✔





5691



  SName sn = {0};




35,630✔





5692












5693



  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);




35,630✔





5694



  QUERY_CHECK_CODE(code, lino, _end);




35,630✔





5695












5696



  code = tNameGetDbName(&sn, dbName);




35,630✔





5697



  QUERY_CHECK_CODE(code, lino, _end);




35,630✔





5698












5699



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




35,630✔





5700



    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);




26,246✔





5701



  } else {










5702



    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);




9,384✔





5703



  }










5704












5705



_end:




35,630✔





5706



  if (code != TSDB_CODE_SUCCESS) {




35,630✔





5707



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5708



    pTaskInfo->code = code;




×







5709



  }










5710












5711



  return code;




35,630✔





5712



}










5713












5714



static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




26,246✔





5715



                                           STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) {










5716



  int32_t        code = TSDB_CODE_SUCCESS;




26,246✔





5717



  int32_t        lino = 0;




26,246✔





5718



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




26,246✔





5719



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




26,246✔





5720












5721



  if (pSupp->groupByStbName) {




26,246✔





5722



    if (pInfo->stbUidList == NULL) {




22,472✔





5723



      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));




7,764✔





5724



      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);




7,764✔





5725



      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);




7,764✔





5726



      QUERY_CHECK_CODE(code, lino, _end);




7,764✔





5727



    }










5728












5729



    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {




22,472✔





5730



      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);




13,600✔





5731



      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);




13,600✔





5732



      QUERY_CHECK_CODE(code, lino, _end);




13,600✔





5733












5734



      pInfo->currGrpIdx++;




13,600✔





5735



    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {




8,872✔





5736



      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);




7,764✔





5737



      QUERY_CHECK_CODE(code, lino, _end);




7,764✔





5738












5739



      pInfo->currGrpIdx++;




7,764✔





5740



    } else {










5741



      setOperatorCompleted(pOperator);




1,108✔





5742



    }










5743



  } else {










5744



    uint64_t groupId = calcGroupId(dbName, strlen(dbName));




3,774✔





5745



    pRes->info.id.groupId = groupId;




3,774✔





5746












5747



    int64_t dbTableCount = 0;




3,774✔





5748



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);




3,774✔





5749



    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);




3,774✔





5750



    QUERY_CHECK_CODE(code, lino, _end);




3,774✔





5751



    setOperatorCompleted(pOperator);




3,774✔





5752



  }










5753












5754



_end:




26,246✔





5755



  if (code != TSDB_CODE_SUCCESS) {




26,246✔





5756



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5757



    pTaskInfo->code = code;




×







5758



  }










5759



  return code;




26,246✔





5760



}










5761












5762



static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




9,384✔





5763



                                         STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) {










5764



  int32_t        code = TSDB_CODE_SUCCESS;




9,384✔





5765



  int32_t        lino = 0;




9,384✔





5766



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,384✔





5767



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




9,384✔





5768












5769



  if (strlen(pSupp->dbNameFilter) != 0 &&




9,384✔





5770



      strcmp(dbName, pSupp->dbNameFilter) != 0) {




6,418✔





5771



    // db name not match, return count 0










5772



    code = fillTableCountScanDataBlock(pSupp, dbName,




×







5773



                                       pSupp->stbNameFilter, 0, pRes);




×







5774



    QUERY_CHECK_CODE(code, lino, _end);




×







5775



  } else if (strlen(pSupp->stbNameFilter) != 0) {




9,384✔





5776



    uint64_t uid = 0;




2,966✔





5777



    code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode,




5,932✔





5778



                                          pSupp->stbNameFilter, &uid);




2,966✔





5779



    if (code == TSDB_CODE_TDB_TABLE_NOT_EXIST) {




2,966✔





5780



      // table not exist, return count 0










5781



      code = fillTableCountScanDataBlock(pSupp, dbName,




1,336✔





5782



                                         pSupp->stbNameFilter, 0, pRes);




1,336✔





5783



      QUERY_CHECK_CODE(code, lino, _end);




1,336✔





5784



    } else {










5785



      QUERY_CHECK_CODE(code, lino, _end);




1,630✔





5786












5787



      int64_t numOfChildTables = 0;




1,630✔





5788



      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid,




1,630✔





5789



                                              &numOfChildTables, NULL, NULL);










5790



      QUERY_CHECK_CODE(code, lino, _end);




1,630✔





5791












5792



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter,




1,630✔





5793



                                         numOfChildTables, pRes);










5794



      QUERY_CHECK_CODE(code, lino, _end);




1,630✔





5795



    }










5796



  } else {










5797



    int64_t tbNumVnode = 0;




6,418✔





5798



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode,




6,418✔





5799



                              NULL, NULL, &tbNumVnode, NULL);










5800



    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);




6,418✔





5801



    QUERY_CHECK_CODE(code, lino, _end);




6,418✔





5802



  }










5803












5804



_end:




9,384✔





5805



  if (code != TSDB_CODE_SUCCESS) {




9,384✔





5806



    pTaskInfo->code = code;




×







5807



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5808



  }










5809












5810



  setOperatorCompleted(pOperator);




9,384✔





5811



  return code;




9,384✔





5812



}










5813












5814



static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




7,764✔





5815



                                              SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) {










5816



  int32_t code = TSDB_CODE_SUCCESS;




7,764✔





5817



  int32_t lino = 0;




7,764✔





5818



  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




7,764✔





5819



  if (pSupp->groupByDbName) {




7,764✔





5820



    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");




3,772✔





5821



  }










5822












5823



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




7,764✔





5824



  pRes->info.id.groupId = groupId;




7,764✔





5825












5826



  int64_t numOfTables = 0;




7,764✔





5827



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);




7,764✔





5828












5829



  if (numOfTables != 0) {




7,764✔





5830



    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);




1,108✔





5831



  }










5832












5833



_end:




6,656✔





5834



  if (code != TSDB_CODE_SUCCESS) {




7,764✔





5835



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5836



  }










5837



  return code;




7,764✔





5838



}










5839












5840



static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




13,600✔





5841



                                              SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) {










5842



  int32_t code = TSDB_CODE_SUCCESS;




13,600✔





5843



  int32_t lino = 0;




13,600✔





5844



  char    stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,600✔





5845



  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);




13,600✔





5846



  QUERY_CHECK_CODE(code, lino, _end);




13,600✔





5847












5848



  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




13,600✔





5849



  if (pSupp->groupByDbName) {




13,600✔





5850



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));




6,284✔





5851



  } else {










5852



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));




7,316✔





5853



  }










5854












5855



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




13,600✔





5856



  pRes->info.id.groupId = groupId;




13,600✔





5857












5858



  int64_t ctbNum = 0;




13,600✔





5859



  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL, NULL);




13,600✔





5860



  QUERY_CHECK_CODE(code, lino, _end);




13,600✔





5861



  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);




13,600✔





5862



  QUERY_CHECK_CODE(code, lino, _end);




13,600✔





5863












5864



_end:




13,600✔





5865



  if (code != TSDB_CODE_SUCCESS) {




13,600✔





5866



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5867



  }










5868



  return code;




13,600✔





5869



}










5870












5871



static void destoryTableCountScanOperator(void* param) {




25,450✔





5872



  STableCountScanOperatorInfo* pTableCountScanInfo = param;




25,450✔





5873



  blockDataDestroy(pTableCountScanInfo->pRes);




25,450✔





5874












5875



  taosArrayDestroy(pTableCountScanInfo->stbUidList);




25,450✔





5876



  taosMemoryFreeClear(param);




25,450✔





5877



}




25,450✔



















    

  • 

    •