taosdata / TDengine / #4977

coverage: 68.456% (+0.01%) from 68.446%
#4977

push

travis-ci

web-flow 
feat(TDgpt): support multiple input data columns for anomaly detection. (#34606)

0 of 93 new or added lines in 9 files covered. (0.0%)

3178 existing lines in 120 files now uncovered.

211178 of 308486 relevant lines covered (68.46%)

135843202.71 hits per line

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

83.47
/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 "taoserror.h"










26



#include "tarray.h"










27



#include "tdef.h"










28



#include "tname.h"










29












30



#include "tdatablock.h"










31



#include "tmsg.h"










32



#include "ttime.h"










33












34



#include "operator.h"










35



#include "query.h"










36



#include "querytask.h"










37



#include "tcompare.h"










38



#include "thash.h"










39



#include "ttypes.h"










40












41



#include "function.h"










42



#include "storageapi.h"










43



#include "wal.h"










44












45



int32_t scanDebug = 0;










46












47



#define MULTI_READER_MAX_TABLE_NUM     5000










48



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










49



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










50



#define STREAM_SCAN_OP_NAME            "StreamScanOperator"










51



#define STREAM_SCAN_OP_STATE_NAME      "StreamScanFillHistoryState"










52



#define STREAM_SCAN_OP_CHECKPOINT_NAME "StreamScanOperator_Checkpoint"










53












54



typedef struct STableMergeScanExecInfo {










55



  SFileBlockLoadRecorder blockRecorder;










56



  SSortExecInfo          sortExecInfo;










57



} STableMergeScanExecInfo;










58












59



typedef struct STableMergeScanSortSourceParam {










60



  SOperatorInfo* pOperator;










61



  int32_t        readerIdx;










62



  uint64_t       uid;










63



  STsdbReader*   reader;










64



} STableMergeScanSortSourceParam;










65












66



typedef struct STableCountScanOperatorInfo {










67



  SReadHandle  readHandle;










68



  SSDataBlock* pRes;










69












70



  STableCountScanSupp supp;










71












72



  int32_t currGrpIdx;










73



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










74



} STableCountScanOperatorInfo;










75












76



static bool    processBlockWithProbability(const SSampleExecInfo* pInfo);










77



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










78












79



bool processBlockWithProbability(const SSampleExecInfo* pInfo) {




677,021,040✔





80



#if 0










81



  if (pInfo->sampleRatio == 1) {










82



    return true;










83



  }










84












85



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










86



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










87



#else










88



  return true;




677,021,040✔





89



#endif










90



}










91












92



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




67,835✔





93



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




67,835✔





94



    SWITCH_ORDER(pCtx[i].order);




×







95



  }










96



}




67,835✔





97












98



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




685,479,269✔





99



  int32_t     code = TSDB_CODE_SUCCESS;




685,479,269✔





100



  STimeWindow w = {0};




685,479,269✔





101












102



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










103



  if (pInterval->interval == 0) {




685,618,597✔





104



    *overlap = false;




648,237,743✔





105



    return code;




648,230,047✔





106



  }










107












108



  if (order == TSDB_ORDER_ASC) {




37,416,575✔





109



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




36,190,791✔





110



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




36,188,251✔





111



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




×







112



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







113



    }










114












115



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




36,182,896✔





116



      *overlap = true;




31,474,209✔





117



      return code;




31,474,727✔





118



    }










119












120



    while (1) {










121



      getNextTimeWindow(pInterval, &w, order);




4,716,182✔





122



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




4,723,106✔





123



        break;




4,445,296✔





124



      }










125












126



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




277,450✔





127



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




×







128



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







129



      }










130



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




277,450✔





131



        *overlap = true;




277,450✔





132



        return code;




277,450✔





133



      }










134



    }










135



  } else {










136



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




1,225,784✔





137



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




1,227,052✔





138



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




×







139



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







140



    }










141












142



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




1,225,996✔





143



      *overlap = true;




1,056,528✔





144



      return code;




1,056,528✔





145



    }










146












147



    while (1) {










148



      getNextTimeWindow(pInterval, &w, order);




169,250✔





149



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




170,524✔





150



        break;




168,527✔





151



      }










152












153



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




2,634✔





154



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




×







155



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







156



      }










157



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




2,634✔





158



        *overlap = true;




2,634✔





159



        return code;




2,634✔





160



      }










161



    }










162



  }










163












164



  *overlap = false;




4,613,823✔





165



  return code;




4,610,513✔





166



}










167












168



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










169



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




189,725,594✔





170



  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {




189,725,594✔





171



    return NULL;




×







172



  }










173












174



  int64_t buf[2] = {0};




189,747,412✔





175



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




189,743,082✔





176












177



  STableScanInfo* pTableScanInfo = pOperator->info;




189,740,217✔





178












179



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




189,748,334✔





180



                                                               buf, GET_RES_WINDOW_KEY_LEN(sizeof(groupId)));










181












182



  if (p1 == NULL) {




189,768,198✔





183



    return NULL;




49,972,991✔





184



  }










185












186



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




139,795,207✔





187



  if (NULL == *pPage) {




139,781,882✔





188



    return NULL;




×







189



  }










190












191



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




139,780,064✔





192



}










193












194



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




12,347,207✔





195



  if (NULL == pTableScanInfo->pIgnoreTables) {




12,347,207✔





196



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




1,394,638✔





197



    pTableScanInfo->pIgnoreTables =




1,394,050✔





198



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




1,394,050✔





199



    if (NULL == pTableScanInfo->pIgnoreTables) {




1,394,050✔





200



      return terrno;




×







201



    }










202



  }










203












204



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




12,347,207✔





205



                                sizeof(pTableScanInfo->scanTimes));










206



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




12,347,140✔





207



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




×







208



    return tempRes;




×







209



  }










210



  return TSDB_CODE_SUCCESS;




12,347,140✔





211



}










212












213



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




769,936,319✔





214



  STableScanInfo* pTableScanInfo = pOperator->info;




769,936,319✔





215



  int32_t         code = TSDB_CODE_SUCCESS;




770,181,756✔





216












217



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




770,181,756✔





218



    return TSDB_CODE_SUCCESS;




580,343,144✔





219



  }










220












221



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




189,731,736✔





222












223



  SFilePage*  pPage = NULL;




189,745,299✔





224



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




189,730,073✔





225












226



  if (pRow == NULL) {




189,743,569✔





227



    return TSDB_CODE_SUCCESS;




49,959,482✔





228



  }










229












230



  bool notLoadBlock = true;




139,784,087✔





231



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




2,147,483,647✔





232



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




2,147,483,647✔





233












234



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




2,147,483,647✔





235












236



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




2,147,483,647✔





237



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




2,147,483,647✔





238



      notLoadBlock = false;




127,434,532✔





239



      break;




127,434,532✔





240



    }










241



  }










242












243



  // release buffer pages










244



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




139,426,921✔





245












246



  if (notLoadBlock) {




139,787,539✔





247



    *status = FUNC_DATA_REQUIRED_NOT_LOAD;




12,347,795✔





248



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




12,347,795✔





249



  }










250












251



  return code;




139,764,254✔





252



}










253












254



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




9,886,977✔





255



                                  int32_t numOfRows, bool* keep) {










256



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




9,886,977✔





257



    *keep = true;




×







258



    return TSDB_CODE_SUCCESS;




×







259



  }










260












261



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




9,886,977✔





262



}










263












264



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




188,683,839✔





265



                              bool* pLoad) {










266



  SStorageAPI* pAPI = &pTaskInfo->storageAPI;




188,683,839✔





267



  bool         allColumnsHaveAgg = true;




188,738,490✔





268



  bool         hasNullSMA = false;




188,758,934✔





269



  if (pLoad != NULL) {




188,714,118✔





270



    *pLoad = false;




188,775,158✔





271



  }










272












273



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




188,716,775✔





274



                                                               &hasNullSMA);










275



  if (code != TSDB_CODE_SUCCESS) {




188,736,520✔





276



    return code;




×







277



  }










278












279



  if (!allColumnsHaveAgg || hasNullSMA) {




188,736,520✔





280



    *pLoad = false;




156,482,857✔





281



  } else {










282



    *pLoad = true;




32,253,663✔





283



  }










284












285



  return code;




188,706,470✔





286



}










287












288



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




758,937,793✔





289



                                  int32_t rows) {










290



  int32_t    code = 0;




758,937,793✔





291



  SExprSupp* pSup = &pTableScanInfo->pseudoSup;




758,937,793✔





292



  if (pSup->numOfExprs > 0) {




759,168,796✔





293



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




321,570,084✔





294



                                  pTaskInfo, &pTableScanInfo->metaCache);










295



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










296



    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




321,561,239✔





297



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




×







298



      code = 0;




×







299



    }










300



  }










301












302



  return code;




759,025,762✔





303



}










304












305



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




1,212,613,394✔





306



  SLimit*     pLimit = &pLimitInfo->limit;




1,212,613,394✔





307



  const char* id = GET_TASKID(pTaskInfo);




1,212,698,887✔





308












309



  if (pLimitInfo->remainOffset > 0) {




1,212,775,951✔





310



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




5,527,516✔





311



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




2,811,263✔





312



      blockDataEmpty(pBlock);




2,811,263✔





313



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




2,811,263✔





314



      return false;




2,811,263✔





315



    } else {










316



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




2,716,253✔





317



      if (code != TSDB_CODE_SUCCESS) {




2,716,253✔





318



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




×







319



        pTaskInfo->code = code;




×







320



        T_LONG_JMP(pTaskInfo->env, code);




×







321



      }










322



      pLimitInfo->remainOffset = 0;




2,716,253✔





323



    }










324



  }










325












326



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




1,209,992,487✔





327



    // limit the output rows










328



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




30,855,832✔





329



    blockDataKeepFirstNRows(pBlock, keep);




30,854,755✔





330












331



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




30,854,756✔





332



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




30,855,469✔





333



    return true;




30,855,488✔





334



  }










335












336



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




1,178,964,986✔





337



  return false;




1,179,083,030✔





338



}










339












340



static bool isDynVtbScan(SOperatorInfo* pOperator) {




×







341



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




×







342



}










343












344



static bool skipSetTagColumnData(SOperatorInfo* pOperator) {




800,954,525✔





345



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




1,464,273,132✔





346



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




663,215,450✔





347



}










348












349



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




816,899,134✔





350



                             uint32_t* status) {










351



  int32_t        code = TSDB_CODE_SUCCESS;




816,899,134✔





352



  int32_t        lino = 0;




816,899,134✔





353



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




816,899,134✔





354



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




817,072,067✔





355



  bool           loadSMA = false;




816,990,949✔





356












357



  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;




816,990,949✔





358












359



  pCost->totalBlocks += 1;




817,007,235✔





360



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




816,969,803✔





361



  *status = pTableScanInfo->dataBlockLoadFlag;




817,037,265✔





362












363



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




816,971,082✔





364



    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




131,268,922✔





365



  } else {










366



    bool overlap = false;




685,630,986✔





367



    int  ret =










368



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




685,722,855✔





369



    if (ret != TSDB_CODE_SUCCESS) {




685,411,905✔





370



      return ret;




×







371



    }










372



    if (overlap) {




685,411,905✔





373



      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




32,806,085✔





374



    }










375



  }










376












377



  SDataBlockInfo* pBlockInfo = &pBlock->info;




816,739,579✔





378



  taosMemoryFreeClear(pBlock->pBlockAgg);




816,892,166✔





379












380



  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {




817,043,269✔





381



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




×







382



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










383



    pCost->filterOutBlocks += 1;




×







384



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




×







385



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




×







386



    return TSDB_CODE_SUCCESS;




×







387



  } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




816,664,799✔





388



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




20,981,136✔





389



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










390



           pBlockInfo->id.uid);










391



    if (!skipSetTagColumnData(pOperator)) {




20,985,008✔





392



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




20,981,587✔





393



    }










394



    pCost->skipBlocks += 1;




20,979,462✔





395



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




20,980,511✔





396



    return code;




20,977,283✔





397



  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {




795,673,729✔





398



    pCost->loadBlockStatis += 1;




57,495,168✔





399



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




57,479,666✔





400



    bool success = true;




57,479,666✔





401



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




57,487,542✔





402



    if (code) {




57,457,172✔





403



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




×







404



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




×








UNCOV

405



      QUERY_CHECK_CODE(code, lino, _end);




×







406



    }










407












408



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




57,435,109✔





409



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




22,343,495✔





410



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










411



      if (!skipSetTagColumnData(pOperator)) {




22,343,885✔





412



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




5,527,805✔





413



      }










414



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




22,355,709✔





415



      return code;




22,329,225✔





416



    } else {










417



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




35,091,614✔





418



      *status = FUNC_DATA_REQUIRED_DATA_LOAD;




35,108,899✔





419



    }










420



  }










421












422



  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {




773,303,010✔





423



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




×







424



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




×







425



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







426



  }










427












428



  // try to filter data block according to sma info










429



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




773,364,926✔





430



    bool success = true;




131,277,111✔





431



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




131,277,332✔





432



    if (code) {




131,241,664✔





433



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




×







434



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




×







435



      QUERY_CHECK_CODE(code, lino, _end);




15,217✔





436



    }










437












438



    if (success) {




131,256,881✔





439



      size_t size = taosArrayGetSize(pBlock->pDataBlock);




9,886,977✔





440



      bool   keep = false;




9,886,977✔





441



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




9,886,977✔





442



      if (code) {




9,887,042✔





443



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




×







444



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




×







445



        QUERY_CHECK_CODE(code, lino, _end);




×







446



      }










447












448



      if (!keep) {




9,887,042✔





449



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




3,425,717✔





450



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










451



        pCost->filterOutBlocks += 1;




3,425,717✔





452



        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;




3,425,717✔





453



        taosMemoryFreeClear(pBlock->pBlockAgg);




3,425,717✔





454












455



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




3,425,717✔





456



        return TSDB_CODE_SUCCESS;




3,425,717✔





457



      }










458



    }










459



  }










460












461



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










462



  taosMemoryFreeClear(pBlock->pBlockAgg);




770,092,967✔





463












464



  // try to filter data block according to current results










465



  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);




769,967,781✔





466



  if (code) {




770,039,596✔






UNCOV

467



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




×







468



    QUERY_CHECK_CODE(code, lino, _end);




×







469



  }










470












471



  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




770,039,596✔





472



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




12,347,140✔





473



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










474



    pCost->skipBlocks += 1;




12,347,562✔





475



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




12,347,984✔





476












477



    STableScanInfo* p1 = pOperator->info;




12,347,984✔





478



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




12,347,984✔





479



      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;




3,409,103✔





480



    } else {










481



      *status = FUNC_DATA_REQUIRED_FILTEROUT;




8,939,469✔





482



    }










483



    return TSDB_CODE_SUCCESS;




12,347,583✔





484



  }










485












486



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




757,570,667✔





487



  pCost->loadBlocks += 1;




757,714,919✔





488












489



  SSDataBlock* p = NULL;




757,757,838✔





490



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




757,861,210✔





491



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




757,777,099✔





492



    return code;




×







493



  }










494












495



  if (!skipSetTagColumnData(pOperator)) {




757,777,099✔





496



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




685,191,278✔





497



    QUERY_CHECK_CODE(code, lino, _end);




685,071,273✔





498



  }










499












500



  // restore the previous value










501



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




757,670,771✔





502












503



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




757,768,624✔





504



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




127,815,989✔





505



    QUERY_CHECK_CODE(code, lino, _end);




127,801,664✔





506












507



    int64_t st = taosGetTimestampUs();




126,887,549✔





508



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




126,882,464✔





509



    pTableScanInfo->readRecorder.filterTime += el;




126,882,464✔





510












511



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




126,871,501✔





512



      pCost->filterOutBlocks += 1;




35,256,610✔





513



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




35,244,870✔





514



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










515



    } else {










516



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




91,602,914✔





517



    }










518



  }










519












520



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




756,816,670✔





521



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




756,814,810✔





522



    setOperatorCompleted(pOperator);




3,581,935✔





523



  }










524












525



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




756,814,810✔





526












527



_end:




757,790,650✔





528



  if (code != TSDB_CODE_SUCCESS) {




757,794,391✔





529



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




931,432✔





530



  }










531



  return code;




757,654,262✔





532



}










533












534



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




67,835✔





535



  SET_REVERSE_SCAN_FLAG(pTableScanInfo);




67,835✔





536












537



  switchCtxOrder(pCtx, numOfOutput);




67,835✔





538



  pTableScanInfo->cond.order = TSDB_ORDER_DESC;




67,835✔





539



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










540



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










541



}




67,835✔





542












543



typedef struct STableCachedVal {










544



  const char* pName;










545



  STag*       pTags;










546



} STableCachedVal;










547












548



static void freeTableCachedVal(void* param) {




×







549



  if (param == NULL) {




×







550



    return;




×







551



  }










552












553



  STableCachedVal* pVal = param;




×







554



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




×







555



  taosMemoryFree(pVal->pTags);




×







556



  taosMemoryFree(pVal);




×







557



}










558












559



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




×







560



  int32_t          code = TSDB_CODE_SUCCESS;




×







561



  int32_t          lino = 0;




×







562



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




×







563



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




×







564












565



  pVal->pTags = NULL;




×







566



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




×







567



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




×







568












569



  // only child table has tag value










570



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




×







571



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




×







572



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




×







573



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




×







574



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




×







575



  }










576












577



  (*ppResVal) = pVal;




×







578












579



_end:




×







580



  if (code != TSDB_CODE_SUCCESS) {




×







581



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




×







582



    freeTableCachedVal(pVal);




×







583



  }










584



  return code;




×







585



}










586












587



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










588



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




×







589



  (void)key;










590



  (void)keyLen;










591



  (void)ud;










592



  freeTableCachedVal(value);




×







593



}




×







594












595



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




×







596



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




×







597



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




×







598












599



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




×







600



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




×







601



  }










602



}




×







603












604



static void freeTableCachedValObj(STableCachedVal* pVal) {




×







605



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




×







606



  taosMemoryFree(pVal->pTags);




×







607



}




×







608












609



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




321,845,356✔





610



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










611



  int32_t          code = TSDB_CODE_SUCCESS;




321,845,356✔





612



  int32_t          lino = 0;




321,845,356✔





613



  bool             freeReader = false;




321,845,356✔





614



  LRUHandle*       h = NULL;




321,845,356✔





615



  STableCachedVal  val = {0};




321,845,356✔





616



  SMetaReader      mr = {0};




321,845,356✔





617



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




321,837,893✔





618



  int32_t          insertRet = TAOS_LRU_STATUS_OK;




321,875,059✔





619



  STableCachedVal* pVal = NULL;




321,875,059✔





620












621



  // currently only the tbname pseudo column










622



  if (numOfExpr <= 0) {




321,936,506✔





623



    return TSDB_CODE_SUCCESS;




268,253✔





624



  }










625












626



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










627












628



  // backup the rows










629



  int32_t backupRows = pBlock->info.rows;




321,668,253✔





630



  pBlock->info.rows = rows;




321,627,598✔





631












632



  // todo refactor: extract method










633



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










634












635



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










636



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




321,713,273✔





637



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




321,699,406✔





638



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




321,767,977✔





639



    if (code != TSDB_CODE_SUCCESS) {




321,501,402✔





640



      // when encounter the TSDB_CODE_PAR_TABLE_NOT_EXIST error, we proceed.










641



      if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







642



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




×







643



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










644












645



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










646



        doSetNullValue(pBlock, pExpr, numOfExpr);




×







647



      } else {










648



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




×







649



      }










650



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




×







651



      return code;




×







652



    }










653












654



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




321,501,402✔





655












656



    val.pName = mr.me.name;




321,691,334✔





657



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




321,691,334✔





658












659



    freeReader = true;




321,691,334✔





660



  } else {










661



    pCache->metaFetch += 1;




×







662












663



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




×







664



    if (h == NULL) {




×







665



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




×







666



      freeReader = true;




×







667



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




×







668



      if (code != TSDB_CODE_SUCCESS) {




×







669



        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







670



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




×







671



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










672



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










673



          doSetNullValue(pBlock, pExpr, numOfExpr);




×







674



        } else {










675



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




×







676



                 idStr);










677



        }










678



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




×







679



        return code;




×







680



      }










681












682



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




×







683












684



      code = createTableCacheVal(&mr, &pVal);




×







685



      QUERY_CHECK_CODE(code, lino, _end);




×







686












687



      val = *pVal;




×







688



    } else {










689



      pCache->cacheHit += 1;




×







690



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




×







691



      val = *pValTmp;




×







692












693



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




×







694



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




×







695



    }










696












697



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




×







698



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










699



  }










700












701



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




1,229,504,592✔





702



    const SExprInfo* pExpr1 = &pExpr[j];




907,769,644✔





703



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




907,768,359✔





704












705



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




907,901,153✔





706



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




907,978,447✔





707



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




907,978,447✔





708












709



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




908,002,350✔





710












711



    // this is to handle the tbname










712



    if (fmIsScanPseudoColumnFunc(functionId)) {




908,060,506✔





713



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




129,769,941✔





714



      if (fType == FUNCTION_TYPE_TBNAME) {




129,778,183✔





715



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




129,778,183✔





716



        QUERY_CHECK_CODE(code, lino, _end);




129,752,614✔





717



      } else if (fType == FUNCTION_TYPE_VGID) {




×







718



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




×







719



        QUERY_CHECK_CODE(code, lino, _end);




×







720



      } else if (fType == FUNCTION_TYPE_VGVER) {




×







721



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




×







722



        QUERY_CHECK_CODE(code, lino, _end);




×







723



      }










724



    } else {  // these are tags










725



      STagVal tagVal = {0};




777,980,600✔





726



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




778,013,475✔





727



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




778,238,811✔





728












729



      char* data = NULL;




778,242,165✔





730



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




778,242,165✔





731



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




772,529,657✔





732



      } else {










733



        data = (char*)p;




5,754,683✔





734



      }










735












736



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




778,220,098✔





737



      if (isNullVal) {




778,229,359✔





738



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




5,264,016✔





739



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




772,965,343✔





740



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




772,460,298✔





741



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




772,527,083✔





742



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




277,045,171✔





743



          if (tmp != NULL) {




277,070,653✔





744



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




277,070,653✔





745



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




277,030,875✔





746



                   pBlock->info.id.uid);










747



            taosMemoryFree(tmp);




277,133,848✔





748



          }










749



          taosMemoryFree(data);




277,132,549✔





750



        }










751



        QUERY_CHECK_CODE(code, lino, _end);




772,356,111✔





752



      } else {  // todo opt for json tag










753



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




3,057,171✔





754



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




2,564,174✔





755



          QUERY_CHECK_CODE(code, lino, _end);




2,565,338✔





756



        }










757



      }










758



    }










759



  }










760












761



  // restore the rows










762



  pBlock->info.rows = backupRows;




321,734,948✔





763












764



_end:




321,754,540✔





765












766



  if (NULL != pVal) {




321,738,548✔





767



    insertRet =




×







768



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




×







769



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










770



    if (insertRet != TAOS_LRU_STATUS_OK) {




×







771



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




×







772



    }










773



  }










774












775



  if (freeReader) {




321,738,548✔





776



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




321,661,873✔





777



  }










778



  if (code != TSDB_CODE_SUCCESS) {




321,714,328✔





779



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




×







780



  }










781



  return code;




321,644,951✔





782



}










783












784



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




129,748,364✔





785



                         const char* name) {










786



  int32_t                     code = TSDB_CODE_SUCCESS;




129,748,364✔





787



  int32_t                     lino = 0;




129,748,364✔





788



  struct SScalarFuncExecFuncs fpSet = {0};




129,748,364✔





789



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




129,763,284✔





790



  QUERY_CHECK_CODE(code, lino, _end);




129,773,539✔





791












792



  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;




129,773,539✔





793



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




129,773,539✔





794



  STR_TO_VARSTR(buf, name)




129,780,546✔





795












796



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




129,747,056✔





797












798



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




129,735,088✔





799



  QUERY_CHECK_CODE(code, lino, _end);




129,781,581✔





800












801



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




129,781,581✔





802



  QUERY_CHECK_CODE(code, lino, _end);




129,756,424✔





803












804



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




129,756,424✔





805



  SScalarParam param = {.columnData = pColInfoData};




129,772,218✔





806












807



  if (fpSet.process != NULL) {




129,757,776✔





808



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




129,757,776✔





809



    QUERY_CHECK_CODE(code, lino, _end);




129,775,265✔





810



  } else {










811



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




×







812



  }










813












814



  colDataDestroy(&infoData);




129,775,265✔





815












816



_end:




129,740,668✔





817



  if (code != TSDB_CODE_SUCCESS) {




129,756,914✔





818



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




×







819



  }










820



  return code;




129,756,914✔





821



}










822












823



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




×







824



  int32_t                     code = TSDB_CODE_SUCCESS;




×







825



  int32_t                     lino = 0;




×







826



  struct SScalarFuncExecFuncs fpSet = {0};




×







827



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







828



  QUERY_CHECK_CODE(code, lino, _end);




×







829












830



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




×







831












832



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




×







833



  QUERY_CHECK_CODE(code, lino, _end);




×







834












835



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




×







836



  QUERY_CHECK_CODE(code, lino, _end);




×







837












838



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




×







839



  SScalarParam param = {.columnData = pColInfoData};




×







840












841



  if (fpSet.process != NULL) {




×







842



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




×







843



    QUERY_CHECK_CODE(code, lino, _end);




×







844



  } else {










845



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




×







846



  }










847












848



_end:




×







849



  colDataDestroy(&infoData);




×







850



  if (code != TSDB_CODE_SUCCESS) {




×







851



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




×







852



  }










853



  return code;




×







854



}










855












856



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




×







857



  int32_t                     code = TSDB_CODE_SUCCESS;




×







858



  int32_t                     lino = 0;




×







859



  struct SScalarFuncExecFuncs fpSet = {0};




×







860



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







861



  QUERY_CHECK_CODE(code, lino, _end);




×







862












863



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




×







864












865



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




×







866



  QUERY_CHECK_CODE(code, lino, _end);




×







867












868



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




×







869



  QUERY_CHECK_CODE(code, lino, _end);




×







870












871



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




×







872



  SScalarParam param = {.columnData = pColInfoData};




×







873












874



  if (fpSet.process != NULL) {




×







875



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




×







876



    QUERY_CHECK_CODE(code, lino, _end);




×







877



  } else {










878



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




×







879



  }










880












881



_end:




×







882



  colDataDestroy(&infoData);




×







883



  if (code != TSDB_CODE_SUCCESS) {




×







884



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




×







885



  }










886



  return code;




×







887



}










888












889



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




251,886,415✔





890



  int32_t code = TSDB_CODE_SUCCESS;




251,886,415✔





891



  int32_t lino = 0;




251,886,415✔





892



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




251,886,415✔





893



  QUERY_CHECK_CODE(code, lino, _end);




251,851,847✔





894












895



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




251,851,847✔





896



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




251,948,030✔





897



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




251,752,037✔





898



  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);




251,852,506✔





899












900



  if (!pInfo->needCountEmptyTable) {




251,784,852✔





901



    pInfo->countState = TABLE_COUNT_STATE_END;




233,795,178✔





902



  } else {










903



    pInfo->countState = TABLE_COUNT_STATE_SCAN;




18,086,875✔





904



  }










905












906



_end:




251,869,654✔





907



  if (code != TSDB_CODE_SUCCESS) {




251,869,654✔





908



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




×







909



  }










910



  return code;




251,873,032✔





911



}










912












913



void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {




676,018,897✔





914



  if (pInfo->countState == TABLE_COUNT_STATE_END) {




676,018,897✔





915



    return;




567,755,194✔





916



  }










917



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




108,416,410✔





918



    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;




231,808✔





919



  } else {










920



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




108,186,472✔





921



    if (code != TSDB_CODE_SUCCESS) {




108,191,069✔





922



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




43,081,055✔





923



    }










924



  }










925



}










926












927



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




47,434,390✔





928



                                         const STableKeyInfo* tbInfo) {










929



  blockDataEmpty(pBlock);




47,434,390✔





930



  pBlock->info.rows = 1;




47,435,941✔





931



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




47,435,424✔





932



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




47,435,424✔





933



  pBlock->info.blankFill = true;




47,436,458✔





934












935



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










936



  int32_t col_num = blockDataGetNumOfCols(pBlock);




47,434,390✔





937



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




196,137,585✔





938



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




148,700,610✔





939



    colDataSetNULL(pColInfoData, 0);










940



  }










941












942



  // set tag/tbname










943



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




47,436,975✔





944












945



  return pBlock;




47,431,805✔





946



}










947












948



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




45,587,379✔





949



  STableScanInfo* pTableScanInfo = pOperator->info;




45,587,379✔





950



  SSDataBlock*    pBlock =










951



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




45,589,447✔





952












953



  pOperator->resultInfo.totalRows++;




45,578,590✔





954



  return pBlock;




45,582,726✔





955



}










956












957



/**










958



  @brief prepare table scan, if the get param contains notify info,










959



  notify the table scan operator's reader that current step is done










960



*/










961



static int32_t prepareTableScan(SOperatorInfo* pOperator) {




905,258,712✔





962



  int32_t code = TSDB_CODE_SUCCESS;




905,258,712✔





963



  int32_t lino = 0;




905,258,712✔





964












965



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




905,258,712✔





966



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




905,409,294✔





967



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




905,479,321✔





968



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




33,034,378✔





969



         NOTIFY_TYPE_SCAN_PARAM &&




3,067,445✔





970



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




3,067,445✔





971



    STableScanOperatorParam* pNotify =




3,067,445✔





972



      (STableScanOperatorParam*)pGetParam->value;










973












974



    STableScanInfo* pTableScanInfo = pOperator->info;




3,067,445✔





975



    SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




3,067,445✔





976



    SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




3,067,445✔





977



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




3,067,445✔





978



                                             pNotify->notifyTs);










979



    QUERY_CHECK_CODE(code, lino, _end);




3,067,445✔





980












981



    if (!pGetParam->reUse) {




3,067,445✔





982



      freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




97,988✔





983



    } else {










984



      /**










985



        The param is referenced by getParam, and it will be freed by










986



        the parent operator after getting next block.










987



      */










988



      pGetParam->reUse = false;




2,969,457✔





989



    }










990



    /**










991



      Set getParam to NULL to avoid impacting following table scan operation.










992



    */










993



    pOperator->pOperatorGetParam = NULL;




3,067,445✔





994



  }










995












996



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




905,477,650✔





997



_end:




270,562,081✔





998



  if (code != TSDB_CODE_SUCCESS) {




905,471,744✔





999



    qError("%s, %s failed at line %d since %s",




×







1000



           GET_TASKID(pOperator->pTaskInfo), __func__, lino, tstrerror(code));










1001



  }










1002



  return code;




905,472,145✔





1003



}










1004












1005



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




866,041,576✔





1006



  int32_t         code = TSDB_CODE_SUCCESS;




866,041,576✔





1007



  int32_t         lino = 0;




866,041,576✔





1008



  STableScanInfo* pTableScanInfo = pOperator->info;




866,041,576✔





1009



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




866,162,965✔





1010



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




866,197,900✔





1011



  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;




866,103,427✔





1012



  bool            hasNext = false;




866,107,647✔





1013



  int64_t         st = taosGetTimestampUs();




866,186,050✔





1014












1015



  QRY_PARAM_CHECK(ppRes);




866,186,050✔





1016



  pBlock->info.dataLoad = false;




866,147,448✔





1017












1018



  while (true) {




42,266,661✔





1019



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




908,409,703✔





1020



    if (code != TSDB_CODE_SUCCESS) {




908,164,256✔





1021



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




×








UNCOV

1022



      QUERY_CHECK_CODE(code, lino, _end);




×







1023



    }










1024












1025



    if (!hasNext) {




908,110,720✔





1026



      break;




230,897,523✔





1027



    }










1028












1029



    if (isTaskKilled(pTaskInfo)) {




677,213,197✔





1030



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




38,447✔





1031



      code = pTaskInfo->code;




38,447✔





1032



      QUERY_CHECK_CODE(code, lino, _end);




38,447✔





1033



    }










1034












1035



    if (pOperator->status == OP_EXEC_DONE) {




677,475,336✔





1036



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




241,472✔





1037



      break;




241,472✔





1038



    }










1039












1040



    // process this data block based on the probabilities










1041



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




677,147,387✔





1042



    if (!processThisBlock) {




677,043,739✔





1043



      continue;




×







1044



    }










1045












1046



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




677,043,739✔





1047



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




677,074,802✔





1048



    }










1049












1050



    uint32_t status = 0;




677,295,089✔





1051



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




677,355,470✔





1052



    QUERY_CHECK_CODE(code, lino, _end);




677,049,925✔





1053












1054



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




676,135,709✔





1055



      break;




3,408,515✔





1056



    }










1057












1058



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










1059



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




672,727,194✔





1060



      continue;




42,268,224✔





1061



    }










1062












1063



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




630,586,467✔





1064



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




630,613,039✔





1065












1066



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




630,664,896✔





1067



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




630,659,780✔





1068












1069



    (*ppRes) = pBlock;




630,610,928✔





1070



    return code;




630,469,253✔





1071



  }










1072












1073



_end:




235,512,405✔





1074



  if (code != TSDB_CODE_SUCCESS) {




235,524,209✔





1075



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




970,720✔





1076



    pTaskInfo->code = code;




970,720✔





1077



    T_LONG_JMP(pTaskInfo->env, code);




952,663✔





1078



  }










1079



  return code;




234,553,489✔





1080



}










1081












1082



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




914,481,914✔





1083



  int32_t         code = TSDB_CODE_SUCCESS;




914,481,914✔





1084



  int32_t         lino = 0;




914,481,914✔





1085



  STableScanInfo* pTableScanInfo = pOperator->info;




914,481,914✔





1086



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




914,583,891✔





1087



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




914,571,776✔





1088












1089



  QRY_PARAM_CHECK(pBlock);




914,525,724✔





1090












1091



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










1092



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




914,517,636✔





1093



    return code;




2,964,119✔





1094



  }










1095












1096



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










1097



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




1,131,270,524✔





1098



    SSDataBlock* p = NULL;




777,846,158✔





1099



    code = doTableScanImplNext(pOperator, &p);




777,816,430✔





1100



    QUERY_CHECK_CODE(code, lino, _end);




776,670,394✔





1101












1102



    if (p != NULL) {




776,670,394✔





1103



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




556,977,963✔





1104



      *pBlock = p;




557,031,331✔





1105



      return code;




557,019,358✔





1106



    }










1107












1108



    pTableScanInfo->scanTimes += 1;




219,692,431✔





1109



    taosHashClear(pTableScanInfo->pIgnoreTables);




219,714,177✔





1110












1111



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




219,677,891✔





1112



      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




85,060✔





1113



      pTableScanInfo->base.scanFlag = MAIN_SCAN;




85,060✔





1114



      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




85,060✔





1115



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




85,060✔





1116












1117



      // do prepare for the next round table scan operation










1118



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




85,060✔





1119



      QUERY_CHECK_CODE(code, lino, _end);




82,598✔





1120



    }










1121



  }










1122












1123



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




353,464,796✔





1124



  if (pTableScanInfo->scanTimes < total) {




353,471,069✔





1125



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




88,318,729✔





1126



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




67,835✔





1127



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




67,835✔





1128



      QUERY_CHECK_CODE(code, lino, _end);




67,835✔





1129



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




67,835✔





1130



    }










1131












1132



    while (pTableScanInfo->scanTimes < total) {




103,174,146✔





1133



      SSDataBlock* p = NULL;




88,319,686✔





1134



      code = doTableScanImplNext(pOperator, &p);




88,313,540✔





1135



      QUERY_CHECK_CODE(code, lino, _end);




88,281,629✔





1136












1137



      if (p != NULL) {




88,281,629✔





1138



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




73,427,667✔





1139



        *pBlock = p;




73,445,267✔





1140



        return code;




73,449,378✔





1141



      }










1142












1143



      pTableScanInfo->scanTimes += 1;




14,853,962✔





1144



      taosHashClear(pTableScanInfo->pIgnoreTables);




14,854,229✔





1145












1146



      if (pTableScanInfo->scanTimes < total) {




14,850,382✔





1147



        setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




×







1148



        pTableScanInfo->base.scanFlag = MAIN_SCAN;




×







1149












1150



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




×







1151



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




×







1152



        QUERY_CHECK_CODE(code, lino, _end);




3,507✔





1153



      }










1154



    }










1155



  }










1156












1157



  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {




279,983,405✔





1158



    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;




62,972,190✔





1159



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




62,972,786✔





1160



      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {




135,597✔





1161



        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;




8,962✔





1162



        STableKeyInfo* pStart =










1163



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




8,962✔





1164












1165



        if (NULL == pStart) {




8,962✔





1166



          return code;




×







1167



        }










1168












1169



        *pBlock = getBlockForEmptyTable(pOperator, pStart);




8,962✔





1170



        return code;




8,962✔





1171



      }










1172



    } else {  // group by tag + no sort










1173



      int32_t numOfTables = 0;




62,835,638✔





1174



      code = tableListGetSize(pTableListInfo, &numOfTables);




62,834,525✔





1175



      QUERY_CHECK_CODE(code, lino, _end);




62,837,229✔





1176












1177



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




62,837,229✔





1178



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










1179



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




61,845,769✔





1180



        if (pIte != NULL) {




61,844,099✔





1181



          size_t        keySize = 0;




45,579,451✔





1182



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




45,579,451✔





1183



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




45,579,968✔





1184



          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);




45,577,900✔





1185



          markGroupProcessed(pTableScanInfo, *pGroupId);




45,578,934✔





1186



          *pBlock = getBlockForEmptyTable(pOperator, &info);




45,577,900✔





1187












1188



          return code;




45,576,349✔





1189



        }










1190



      }










1191



    }










1192



    pTableScanInfo->countState = TABLE_COUNT_STATE_END;




17,382,743✔





1193



  }










1194












1195



_end:




217,025,050✔





1196



  if (code != TSDB_CODE_SUCCESS) {




234,399,195✔





1197



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




×







1198



    pTaskInfo->code = code;




×







1199



  }










1200












1201



  return code;




234,399,195✔





1202



}










1203












1204



static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {




1,613,651✔





1205



  STableScanInfo*          pInfo = pOperator->info;




1,613,651✔





1206



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




1,614,040✔





1207



  int32_t                  code = 0;




1,614,040✔





1208



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




1,614,040✔





1209



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




1,614,040✔





1210



  int32_t                  num = taosArrayGetSize(pParam->pUidList);




1,614,040✔





1211



  if (num <= 0) {




1,614,040✔





1212



    qError("empty table scan uid list");




×







1213



    return TSDB_CODE_INVALID_PARA;




×







1214



  }










1215












1216



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




1,614,040✔





1217



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










1218



         pOperator->status);










1219












1220



  if (pParam->tableSeq) {




1,614,040✔





1221



    pListInfo->oneTableForEachGroup = true;




1,363,491✔





1222



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




1,363,491✔





1223



      taosHashClear(pListInfo->map);




×







1224



      taosArrayClear(pListInfo->pTableList);




×







1225



      pOperator->status = OP_EXEC_DONE;




×







1226



    }










1227



  } else {










1228



    pListInfo->oneTableForEachGroup = false;




250,549✔





1229



    pListInfo->numOfOuputGroups = 1;




250,549✔





1230



  }










1231



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




1,614,040✔





1232



    // do nothing










1233



  } else {










1234



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




1,358,955✔





1235



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




1,358,955✔





1236



  }










1237












1238



  STableKeyInfo info = {.groupId = 0};




1,614,040✔





1239



  int32_t       tableIdx = 0;




1,614,040✔





1240



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




10,398,776✔





1241



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




8,784,736✔





1242



    if (!pUid) {




8,778,015✔





1243



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




×







1244



      return terrno;




×







1245



    }










1246












1247



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




8,778,015✔





1248



      if (TSDB_CODE_DUP_KEY == terrno) {




6,825,127✔





1249



        continue;




6,818,923✔





1250



      }










1251



      return terrno;




×







1252



    }










1253












1254



    info.uid = *pUid;




1,967,881✔





1255



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




1,967,881✔





1256



    if (p == NULL) {




1,967,881✔





1257



      return terrno;




×







1258



    }










1259












1260



    tableIdx++;




1,967,881✔





1261



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




1,967,881✔





1262



  }










1263












1264



  return code;




1,614,040✔





1265



}










1266












1267



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




236,506,449✔





1268



                            STableKeyInfo** pList) {










1269



  const char* idStr = GET_TASKID(pTaskInfo);




236,506,449✔





1270



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




236,566,243✔





1271



  if (code) {




236,475,779✔





1272



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




×







1273



    return code;




×







1274



  }










1275












1276



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




236,475,779✔





1277



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




×







1278



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







1279



  }










1280












1281



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




472,980,560✔





1282



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




236,482,965✔





1283



  if (code) {




236,456,737✔





1284



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




2,035✔





1285



  }










1286












1287



  return code;




236,347,114✔





1288



}










1289












1290



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




307,621,066✔





1291



  SColIdPair* node1 = (SColIdPair*)elem1;




307,621,066✔





1292



  SColIdPair* node2 = (SColIdPair*)elem2;




307,621,066✔





1293












1294



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




307,621,066✔





1295



    return 0;




110,874✔





1296



  }










1297












1298



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




307,529,225✔





1299



}










1300












1301



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




408,530,087✔





1302



  SColIdSlotIdPair* node1 = (SColIdSlotIdPair*)elem1;




408,530,087✔





1303



  SColIdSlotIdPair* node2 = (SColIdSlotIdPair*)elem2;




408,530,087✔





1304












1305



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




408,530,087✔





1306



    return 0;




169,362✔





1307



  }










1308












1309



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




408,365,113✔





1310



}










1311












1312



static int compareColMatchItemByColId(const void* elem1, const void* elem2) {




×







1313



  const SColMatchItem* node1 = (const SColMatchItem*)elem1;




×







1314



  const SColMatchItem* node2 = (const SColMatchItem*)elem2;




×







1315












1316



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




×







1317



    return 0;




×







1318



  }










1319












1320



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




×







1321



}










1322












1323



static SColMatchItem* findMatchItemByColId(SArray* pList, col_id_t colId) {




92,431,907✔





1324



  if (pList == NULL) {




92,431,907✔





1325



    return NULL;




×







1326



  }










1327












1328



  int32_t left = 0;




92,431,907✔





1329



  int32_t right = taosArrayGetSize(pList) - 1;




92,431,907✔





1330



  while (left <= right) {




286,359,995✔





1331



    int32_t mid = left + (right - left) / 2;




286,359,995✔





1332



    SColMatchItem* pItem = taosArrayGet(pList, mid);




286,359,995✔





1333



    if (pItem->colId == colId) {




286,359,995✔





1334



      // return the first matched item in sorted order










1335



      while (mid > 0) {




92,431,907✔





1336



        SColMatchItem* pPrev = taosArrayGet(pList, mid - 1);




69,269,203✔





1337



        if (pPrev->colId != colId) {




69,269,203✔





1338



          break;




69,269,203✔





1339



        }










1340



        mid--;




×







1341



      }










1342



      return taosArrayGet(pList, mid);




92,431,907✔





1343



    }










1344












1345



    if (pItem->colId < colId) {




193,928,088✔





1346



      left = mid + 1;




91,120,967✔





1347



    } else {










1348



      right = mid - 1;




102,807,121✔





1349



    }










1350



  }










1351












1352



  return NULL;




×







1353



}










1354












1355



static bool isNewScanParam(STableScanOperatorParam* pParam) {




39,608,254✔





1356



  return pParam->isNewParam;




39,608,254✔





1357



}










1358












1359



static int32_t createVTableScanInfoFromBatchParam(SOperatorInfo* pOperator) {




81,257,212✔





1360



  int32_t                  code = 0;




81,257,212✔





1361



  int32_t                  lino = 0;




81,257,212✔





1362



  STableScanInfo*          pInfo = pOperator->info;




81,257,212✔





1363



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




81,304,875✔





1364



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




81,291,432✔





1365



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




81,304,072✔





1366



  SMetaReader              orgTable = {0};




81,294,999✔





1367



  SMetaReader              superTable = {0};




81,325,797✔





1368



  SSchemaWrapper*          schema = NULL;




81,312,409✔





1369



  SArray*                  pColArray = NULL;




81,312,409✔





1370



  SArray*                  pBlockColArray = NULL;




81,312,409✔





1371



  int32_t                  num = 0;




81,312,409✔





1372



  STableKeyInfo*           pList = NULL;




81,312,297✔





1373



  SOrgTbInfo*              pOrgTbInfo;










1374



  bool                     isNewTable;










1375












1376



  cleanupQueryTableDataCond(&pInfo->base.cond);




81,312,249✔





1377












1378



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




81,308,351✔





1379



  if (pGetParam &&




81,307,844✔





1380



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




5,180,337✔





1381



    STableScanOperatorParam* pParam =




5,186,895✔





1382



      (STableScanOperatorParam*)pGetParam->value;










1383



    pInfo->pBatchColMap = pParam->pBatchTbInfo;




5,187,279✔





1384



    pParam->pBatchTbInfo = NULL;




5,180,515✔





1385



    pInfo->cachedTimeWindow = pParam->window;




5,169,113✔





1386



    pInfo->currentBatchIdx = 0;




5,177,454✔





1387



    pInfo->lastBatchIdx = -1;




5,178,547✔





1388



    pInfo->cachedTagList = pParam->pTagList;




5,160,614✔





1389



    pParam->pTagList = NULL;




5,185,660✔





1390



    pInfo->cachedGroupId = pParam->groupid;




5,183,415✔





1391












1392



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




5,187,139✔





1393



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










1394



    taosHashClear(pInfo->pIgnoreTables);




5,187,139✔





1395












1396



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




5,184,546✔





1397



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




4,984,160✔





1398



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




62,408,280✔





1399



        SqlFunctionCtx ctx = pSup->pCtx[i];




57,431,304✔





1400



        ctx.skipDynDataCheck = false;




57,422,936✔





1401



      }










1402



    }










1403



  }










1404












1405



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




81,294,636✔





1406



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




81,332,792✔





1407












1408



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




81,332,792✔





1409



    isNewTable = false;




73,039,879✔





1410



  } else {










1411



    isNewTable = true;




8,295,970✔





1412



    pInfo->lastBatchIdx = pInfo->currentBatchIdx;




8,295,970✔





1413



  }










1414












1415



  if (isNewTable) {




81,301,519✔





1416



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




8,296,039✔





1417



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




8,300,748✔





1418



    pAPI->metaReaderFn.readerReleaseLock(&orgTable);




8,284,601✔





1419



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




8,294,657✔





1420



    QUERY_CHECK_CODE(code, lino, _return);




8,285,037✔





1421



    switch (orgTable.me.type) {




8,285,037✔





1422



      case TSDB_CHILD_TABLE:




285,916✔





1423



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




285,916✔





1424



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




285,916✔





1425



        pAPI->metaReaderFn.readerReleaseLock(&superTable);




285,916✔





1426



        QUERY_CHECK_CODE(code, lino, _return);




285,916✔





1427



        schema = &superTable.me.stbEntry.schemaRow;




285,916✔





1428



        break;




285,916✔





1429



      case TSDB_NORMAL_TABLE:




7,955,359✔





1430



        schema = &orgTable.me.ntbEntry.schemaRow;




7,955,359✔





1431



        break;




7,955,359✔





1432



      default:




43,762✔





1433



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




43,762✔





1434



        return TSDB_CODE_INVALID_PARA;




×







1435



        break;










1436



    }










1437












1438



    pListInfo->oneTableForEachGroup = true;




8,241,275✔





1439



    taosHashClear(pListInfo->map);




8,285,061✔





1440



    taosArrayClear(pListInfo->pTableList);




8,304,877✔





1441












1442



    uint64_t      pUid = orgTable.me.uid;




8,303,553✔





1443



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




8,303,553✔





1444



    int32_t       tableIdx = 0;




8,303,198✔





1445



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




8,303,553✔





1446



    QUERY_CHECK_CODE(code, lino, _return);




8,304,509✔





1447



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




16,606,386✔





1448



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




8,301,877✔





1449












1450



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




8,301,877✔





1451



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




8,295,684✔





1452



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




8,295,684✔





1453



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




8,295,186✔





1454












1455



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










1456



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




8,295,186✔





1457



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




8,303,908✔





1458












1459



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




31,761,264✔





1460



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




23,450,836✔





1461



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




186,824,911✔





1462



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




186,490,115✔





1463



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




23,468,102✔





1464



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




23,471,688✔





1465



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




23,471,688✔





1466



                 pPair.vtbColId, GET_TASKID(pTaskInfo));










1467



          break;




23,459,704✔





1468



        }










1469



      }










1470



    }










1471












1472



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




40,073,640✔





1473



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




31,763,161✔





1474



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




190,639,284✔





1475



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




190,457,953✔





1476



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




190,487,772✔





1477



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




31,761,902✔





1478



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




31,772,248✔





1479



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




31,772,248✔





1480



                 colIdSlotIdPair.vtbSlotId, GET_TASKID(pTaskInfo));










1481



          break;




31,758,922✔





1482



        }










1483



      }










1484



    }










1485












1486



    taosArraySort(pColArray, compareColIdPair);




8,302,340✔





1487



    taosArraySort(pBlockColArray, compareColIdSlotIdPair);




8,297,513✔





1488



    if (pInfo->pBlockColMap) {




8,296,559✔





1489



      taosArrayDestroy(pInfo->pBlockColMap);




5,818,300✔





1490



      pInfo->pBlockColMap = NULL;




5,817,124✔





1491



    }










1492



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




8,293,354✔





1493



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




8,296,021✔





1494












1495












1496



    taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




8,290,550✔





1497



    taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




8,288,322✔





1498












1499



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




8,300,565✔





1500



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




7,567,785✔





1501



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




93,122,099✔





1502



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




85,575,742✔





1503



        bool           needScan = false;




85,574,555✔





1504



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




172,409,537✔





1505



          SFunctParam pParam = ctx->param[j];




86,788,028✔





1506



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




417,430,223✔





1507



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




351,020,641✔





1508



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




351,744,980✔





1509



              needScan |= true;




21,599,635✔





1510



              break;




21,599,635✔





1511



            }










1512



          }










1513



        }










1514



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




85,566,300✔





1515



        if (!needScan) {




85,609,248✔





1516



          ctx->skipDynDataCheck = true;




64,022,160✔





1517



        } else {










1518



          ctx->skipDynDataCheck = false;




21,587,088✔





1519



        }










1520



      }










1521



    }










1522












1523












1524



  } else {










1525



    pColArray = pInfo->lastColArray;




73,005,480✔





1526



    pBlockColArray = pInfo->lastBlockColArray;




73,005,112✔





1527



  }










1528












1529



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




81,330,989✔





1530



  QUERY_CHECK_CODE(code, lino, _return);




81,348,287✔





1531












1532



  if (pInfo->pResBlock) {




81,348,287✔





1533



    blockDataDestroy(pInfo->pResBlock);




76,147,959✔





1534



    pInfo->pResBlock = NULL;




76,105,690✔





1535



  }










1536












1537



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




81,330,859✔





1538



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










1539



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










1540



         isNewTable, pInfo->base.orgCond.order,










1541



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










1542



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










1543



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










1544












1545



  if (isNewTable) {




81,273,303✔





1546



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




8,293,300✔





1547



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




7,565,634✔





1548



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




7,542,144✔





1549



    } else {










1550



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




734,131✔





1551



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




726,496✔





1552



    }










1553



  } else {










1554



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




72,980,003✔





1555



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




1,698,065✔





1556



    else {










1557



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




71,291,282✔





1558



    }










1559



  }










1560












1561



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




81,287,762✔





1562



  pInfo->currentGroupId = 0;




81,296,288✔





1563



  pInfo->ignoreTag = true;




81,296,947✔





1564












1565



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




81,278,798✔





1566



  QUERY_CHECK_CODE(code, lino, _return);




81,319,964✔





1567












1568



  if (isNewTable) {




81,319,964✔





1569



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




8,292,224✔





1570



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




5,822,034✔





1571



    }










1572



    pInfo->base.dataReader = NULL;




8,273,224✔





1573












1574



    taosRLockLatch(&pTaskInfo->lock);




8,266,066✔





1575



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




8,305,232✔





1576



    taosRUnLockLatch(&pTaskInfo->lock);




8,263,749✔





1577



    QUERY_CHECK_CODE(code, lino, _return);




8,290,654✔





1578












1579



    pInfo->newReader = true;




8,290,654✔





1580



    if (pInfo->lastColArray) {




8,291,009✔





1581



      taosArrayDestroy(pInfo->lastColArray);




3,105,829✔





1582



      pInfo->lastColArray = NULL;




3,104,857✔





1583



    }










1584



    if (pInfo->lastBlockColArray) {




8,275,791✔





1585



      taosArrayDestroy(pInfo->lastBlockColArray);




3,104,889✔





1586



      pInfo->lastBlockColArray = NULL;




3,107,140✔





1587



    }










1588



    pInfo->lastColArray = pColArray;




8,275,381✔





1589



    pInfo->lastBlockColArray = pBlockColArray;




8,265,481✔





1590



  } else {










1591



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




73,027,740✔





1592



    QUERY_CHECK_CODE(code, lino, _return);




73,034,351✔





1593












1594



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




73,034,351✔





1595



    pInfo->newReader = false;




73,015,776✔





1596



    pInfo->scanTimes = 0;




73,038,708✔





1597



  }










1598












1599



  pOperator->status = OP_OPENED;




81,321,868✔





1600












1601



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




81,309,035✔





1602



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




×







1603



  }










1604












1605



  pInfo->currentGroupId = -1;




81,315,832✔





1606



_return:




81,331,507✔





1607



  if (code) {




81,279,737✔





1608



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




×







1609



  }










1610



  pAPI->metaReaderFn.clearReader(&superTable);




81,279,737✔





1611



  pAPI->metaReaderFn.clearReader(&orgTable);




81,295,217✔





1612



  return code;




81,315,288✔





1613



}










1614












1615



static int32_t createVTableScanInfoFromParam(SOperatorInfo* pOperator) {




23,162,704✔





1616



  int32_t                  code = 0;




23,162,704✔





1617



  int32_t                  lino = 0;




23,162,704✔





1618



  STableScanInfo*          pInfo = pOperator->info;




23,162,704✔





1619



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




23,162,704✔





1620



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




23,162,704✔





1621



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




23,162,704✔





1622



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




23,162,704✔





1623



  SMetaReader              orgTable = {0};




23,162,704✔





1624



  SMetaReader              superTable = {0};




23,162,704✔





1625



  SSchemaWrapper*          schema = NULL;




23,162,704✔





1626



  SArray*                  pColArray = NULL;




23,162,704✔





1627



  SArray*                  pBlockColArray = NULL;




23,162,704✔





1628



  int32_t                  num = 0;




23,162,704✔





1629



  STableKeyInfo*           pList = NULL;




23,162,704✔





1630



  SOrgTbInfo*              pOrgTbInfo;










1631



  SArray*                  pMatchList = NULL;




23,162,704✔





1632












1633



  cleanupQueryTableDataCond(&pInfo->base.cond);




23,162,704✔





1634












1635



  pOrgTbInfo = pParam->pOrgTbInfo;




23,162,704✔





1636












1637



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




23,162,704✔





1638












1639



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




23,162,704✔





1640



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




23,162,704✔





1641



  pAPI->metaReaderFn.readerReleaseLock(&orgTable);




23,162,704✔





1642



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




23,162,704✔





1643



  QUERY_CHECK_CODE(code, lino, _return);




23,162,704✔





1644



  switch (orgTable.me.type) {




23,162,704✔





1645



    case TSDB_CHILD_TABLE:




6,513,248✔





1646



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




6,513,248✔





1647



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




6,513,248✔





1648



      pAPI->metaReaderFn.readerReleaseLock(&superTable);




6,513,248✔





1649



      QUERY_CHECK_CODE(code, lino, _return);




6,513,248✔





1650



      schema = &superTable.me.stbEntry.schemaRow;




6,513,248✔





1651



      break;




6,513,248✔





1652



    case TSDB_NORMAL_TABLE:




16,649,456✔





1653



      schema = &orgTable.me.ntbEntry.schemaRow;




16,649,456✔





1654



      break;




16,649,456✔





1655



    default:




×







1656



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




×







1657



      return TSDB_CODE_INVALID_PARA;




×







1658



      break;










1659



  }










1660












1661



  pListInfo->oneTableForEachGroup = true;




23,162,704✔





1662



  taosHashClear(pListInfo->map);




23,162,704✔





1663



  taosArrayClear(pListInfo->pTableList);




23,162,704✔





1664












1665



  uint64_t      pUid = orgTable.me.uid;




23,162,704✔





1666



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




23,162,704✔





1667



  int32_t       tableIdx = 0;




23,162,704✔





1668



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




23,162,704✔





1669



  QUERY_CHECK_CODE(code, lino, _return);




23,162,704✔





1670



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




46,325,408✔





1671



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




23,162,704✔





1672












1673



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




23,162,704✔





1674



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




23,162,704✔





1675



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




23,162,704✔





1676



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




23,162,704✔





1677



  if (pInfo->pBlockColMap) {




23,162,704✔





1678



    taosArrayDestroy(pInfo->pBlockColMap);




20,784,474✔





1679



    pInfo->pBlockColMap = NULL;




20,784,474✔





1680



  }










1681



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




23,162,704✔





1682



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




23,162,704✔





1683












1684



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










1685



  SColIdPair tsPair = {.vtbColId = PRIMARYKEY_TIMESTAMP_COL_ID,




23,162,704✔





1686



                       .orgColId = PRIMARYKEY_TIMESTAMP_COL_ID,










1687



                       .type.type = TSDB_DATA_TYPE_TIMESTAMP,










1688



                       .type.bytes = 8};










1689



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




23,162,704✔





1690












1691



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




92,431,907✔





1692



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




69,269,203✔





1693



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




583,669,649✔





1694



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




583,669,649✔





1695



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




69,269,203✔





1696



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




69,269,203✔





1697



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




69,269,203✔





1698



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




69,269,203✔





1699



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




69,269,203✔





1700



        break;




69,269,203✔





1701



      }










1702



    }










1703



  }










1704












1705



  if (pInfo->base.matchInfo.pList) {




23,162,704✔





1706



    if (!pInfo->base.matchInfo.colIdOrdered) {




23,162,704✔





1707



      pMatchList = taosArrayDup(pInfo->base.matchInfo.pList, NULL);




×







1708



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




×







1709



      taosArraySort(pMatchList, compareColMatchItemByColId);




×







1710



    } else {










1711



      pMatchList = pInfo->base.matchInfo.pList;




23,162,704✔





1712



    }










1713



  }










1714












1715



  // skip ts pair










1716



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




115,593,968✔





1717



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




92,431,907✔





1718



    SColMatchItem* pItem = findMatchItemByColId(pMatchList, pPair->vtbColId);




92,431,907✔





1719



    if (pItem) {




92,431,907✔





1720



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




92,431,907✔





1721



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




643✔





1722



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










1723



        code = TSDB_CODE_VTABLE_COLUMN_TYPE_MISMATCH;




643✔





1724



        goto _return;




643✔





1725



      }










1726



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




92,431,264✔





1727



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




92,431,264✔





1728



      if (i > 0) {




92,431,264✔





1729



        QUERY_CHECK_NULL(taosArrayPush(pInfo->pBlockColMap, &colIdSlotIdPair), code, lino, _return, terrno);




138,537,120✔





1730



      }










1731



    }










1732



  }










1733












1734



  taosArraySort(pColArray, compareColIdPair);




23,162,061✔





1735



  taosArraySort(pBlockColArray, compareColIdSlotIdPair);




23,162,061✔





1736



  taosArraySort(pInfo->pBlockColMap, compareColIdSlotIdPair);




23,162,061✔





1737












1738



  taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




23,162,061✔





1739



  taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




23,162,061✔





1740












1741



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




23,162,061✔





1742



  QUERY_CHECK_CODE(code, lino, _return);




23,162,061✔





1743












1744



  if (pInfo->pResBlock) {




23,162,061✔





1745



    blockDataDestroy(pInfo->pResBlock);




16,448,505✔





1746



    pInfo->pResBlock = NULL;




16,448,505✔





1747



  }










1748












1749



  if (isNewScanParam(pParam)) {




23,162,061✔





1750



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




6,720,284✔





1751



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




6,720,284✔





1752



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




6,720,284✔





1753



    } else {










1754



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




×







1755



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




×







1756



    }










1757



  } else {










1758



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




16,441,777✔





1759



  }










1760



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




23,162,061✔





1761



  pInfo->currentGroupId = 0;




23,162,061✔





1762



  pInfo->ignoreTag = true;




23,162,061✔





1763












1764



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




23,162,061✔





1765



  QUERY_CHECK_CODE(code, lino, _return);




23,162,061✔





1766












1767



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




23,162,061✔





1768



  if (reader) {




23,162,061✔





1769



    if (isNewScanParam(pParam)) {




16,446,193✔





1770



      pAPI->tsdReader.tsdReaderClose(*reader);




4,416✔





1771



      pInfo->base.dataReader = NULL;




4,416✔





1772












1773



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




4,416✔





1774



      QUERY_CHECK_CODE(code, lino, _return);




4,416✔





1775












1776



      taosRLockLatch(&pTaskInfo->lock);




4,416✔





1777



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




4,416✔





1778



      taosRUnLockLatch(&pTaskInfo->lock);




4,416✔





1779



      QUERY_CHECK_CODE(code, lino, _return);




4,416✔





1780












1781



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




4,416✔





1782



      QUERY_CHECK_CODE(code, lino, _return);




4,416✔





1783



      pInfo->newReader = true;




4,416✔





1784



    } else {










1785



      pInfo->base.dataReader = *reader;




16,441,777✔





1786



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




16,441,777✔





1787



      QUERY_CHECK_CODE(code, lino, _return);




16,441,777✔





1788












1789



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




16,441,777✔





1790



      pInfo->newReader = false;




16,441,777✔





1791



      pInfo->scanTimes = 0;




16,441,777✔





1792



    }










1793



  } else {










1794



    pInfo->base.dataReader = NULL;




6,715,868✔





1795












1796



    taosRLockLatch(&pTaskInfo->lock);




6,715,868✔





1797



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




6,715,868✔





1798



    taosRUnLockLatch(&pTaskInfo->lock);




6,715,868✔





1799



    QUERY_CHECK_CODE(code, lino, _return);




6,715,868✔





1800












1801



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




6,715,868✔





1802



    QUERY_CHECK_CODE(code, lino, _return);




6,715,868✔





1803



    pInfo->newReader = true;




6,715,868✔





1804



  }










1805



  pOperator->status = OP_OPENED;




23,162,061✔





1806












1807



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




23,162,061✔





1808



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




×







1809



  }










1810












1811



  pInfo->currentGroupId = -1;




23,162,061✔





1812



_return:




23,162,704✔





1813



  if (code) {




23,162,704✔





1814



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




643✔





1815



  }










1816



  if (!pInfo->base.matchInfo.colIdOrdered) {




23,162,704✔





1817



    taosArrayDestroy(pMatchList);




×







1818



  }










1819



  taosArrayDestroy(pColArray);




23,162,704✔





1820



  taosArrayDestroy(pBlockColArray);




23,162,704✔





1821



  pAPI->metaReaderFn.clearReader(&superTable);




23,162,704✔





1822



  pAPI->metaReaderFn.clearReader(&orgTable);




23,162,704✔





1823



  return code;




23,162,704✔





1824



}










1825












1826



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




231,695,156✔





1827



  int32_t         code = TSDB_CODE_SUCCESS;




231,695,156✔





1828



  int32_t         lino = 0;




231,695,156✔





1829



  STableScanInfo* pInfo = pOperator->info;




231,695,156✔





1830



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




231,710,845✔





1831



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




231,683,050✔





1832



  int32_t         numOfTables = 0;




231,690,746✔





1833












1834



  QRY_PARAM_CHECK(pResult);




231,658,303✔





1835












1836



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




231,682,795✔





1837



  QUERY_CHECK_CODE(code, lino, _end);




231,711,856✔





1838












1839



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




231,711,856✔





1840



    setOperatorCompleted(pOperator);




216,301,542✔





1841



    if (pOperator->dynamicTask) {




216,285,639✔





1842



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




1,612,520✔





1843



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




1,612,138✔





1844



    }










1845



    return code;




216,288,516✔





1846



  }










1847












1848



  // reset value for the next group data output










1849



  pOperator->status = OP_OPENED;




15,328,930✔





1850



  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);




15,389,078✔





1851












1852



  int32_t        num = 0;




15,378,797✔





1853



  STableKeyInfo* pList = NULL;




15,379,507✔





1854



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




15,378,383✔





1855



  QUERY_CHECK_CODE(code, lino, _end);




15,389,851✔





1856












1857



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




15,389,851✔





1858



  QUERY_CHECK_CODE(code, lino, _end);




15,386,534✔





1859












1860



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




15,386,534✔





1861



  QUERY_CHECK_CODE(code, lino, _end);




15,391,334✔





1862



  pInfo->scanTimes = 0;




15,391,334✔





1863












1864



  code = doGroupedTableScan(pOperator, pResult);




15,398,880✔





1865



  QUERY_CHECK_CODE(code, lino, _end);




15,405,237✔





1866












1867



  if (*pResult != NULL) {




15,405,237✔





1868



    if (pOperator->dynamicTask) {




12,813,515✔





1869



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




12,552,443✔





1870



    }










1871



    return code;




12,813,515✔





1872



  }










1873












1874



_end:




2,592,813✔





1875



  if (code != TSDB_CODE_SUCCESS) {




2,596,709✔





1876



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




×







1877



    pTaskInfo->code = code;




×







1878



  }










1879



  return code;




2,593,398✔





1880



}










1881












1882



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




798,010,856✔





1883



  int32_t         code = TSDB_CODE_SUCCESS;




798,010,856✔





1884



  int32_t         lino = 0;




798,010,856✔





1885



  STableScanInfo* pInfo = pOperator->info;




798,010,856✔





1886



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




798,055,508✔





1887



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




798,025,879✔





1888



  int32_t         num = 0;




798,067,332✔





1889



  STableKeyInfo*  pList = NULL;




798,020,465✔





1890



  SSDataBlock*    pResult = NULL;




798,009,782✔





1891



  const char*     idStr = GET_TASKID(pTaskInfo);




797,985,991✔





1892












1893



  QRY_PARAM_CHECK(pResBlock);




797,951,493✔





1894












1895



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




798,012,504✔





1896



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




221,481,313✔





1897



      setOperatorCompleted(pOperator);




×







1898



      return code;




×







1899



    }










1900












1901



    taosRLockLatch(&pTaskInfo->lock);




221,451,110✔





1902



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




221,567,132✔





1903



    taosRUnLockLatch(&pTaskInfo->lock);




221,461,257✔





1904



    QUERY_CHECK_CODE(code, lino, _end);




221,541,947✔





1905












1906



    if (pInfo->filesetDelimited) {




221,539,912✔





1907



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




252,047✔





1908



    }










1909












1910



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




221,471,798✔





1911



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




×







1912



    }










1913



  }










1914












1915



  code = doGroupedTableScan(pOperator, &pResult);




798,045,398✔





1916



  QUERY_CHECK_CODE(code, lino, _end);




796,849,241✔





1917












1918



  if (pResult != NULL) {




796,849,241✔





1919



    if (pOperator->dynamicTask) {




580,439,582✔





1920



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




3,411,274✔





1921



    }










1922












1923



    *pResBlock = pResult;




580,444,130✔





1924



    return code;




580,213,468✔





1925



  }










1926












1927



  while (true) {










1928



    code = startNextGroupScan(pOperator, &pResult);




216,488,791✔





1929



    QUERY_CHECK_CODE(code, lino, _end);




216,655,824✔





1930












1931



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




216,655,824✔





1932



      *pResBlock = pResult;




216,581,091✔





1933



      return code;




216,567,810✔





1934



    }










1935



  }










1936












1937



_end:




2,035✔





1938



  if (code != TSDB_CODE_SUCCESS) {




2,035✔





1939



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




2,035✔





1940



    pTaskInfo->code = code;




2,035✔





1941



  }










1942












1943



  return code;




2,035✔





1944



}










1945












1946



static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {




23,162,061✔





1947



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




23,162,061✔





1948



}










1949












1950



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




1,614,040✔





1951



  int32_t                  code = TSDB_CODE_SUCCESS;




1,614,040✔





1952



  int32_t                  lino = 0;




1,614,040✔





1953



  STableScanInfo*          pInfo = pOperator->info;




1,614,040✔





1954



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




1,614,040✔





1955



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




1,614,040✔





1956



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




1,614,040✔





1957












1958



  code = createTableListInfoFromParam(pOperator);




1,614,040✔





1959



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




1,614,040✔





1960



  pOperator->pOperatorGetParam = NULL;




1,614,040✔





1961



  QUERY_CHECK_CODE(code, lino, _end);




1,614,040✔





1962












1963



  if (pOperator->status == OP_EXEC_DONE) {




1,614,040✔





1964



    pInfo->currentGroupId = -1;




42,633✔





1965



    pOperator->status = OP_OPENED;




42,633✔





1966



    SSDataBlock* result = NULL;




42,633✔





1967












1968



    while (true) {










1969



      code = startNextGroupScan(pOperator, &result);




42,633✔





1970



      QUERY_CHECK_CODE(code, lino, _end);




42,633✔





1971












1972



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




42,633✔





1973



        (*ppRes) = result;




42,633✔





1974



        return code;




42,633✔





1975



      }










1976



    }










1977



  }










1978



_end:




1,571,407✔





1979



  if (code) {




1,571,407✔





1980



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




×







1981



  }










1982



  return code;




1,571,407✔





1983



}










1984












1985



static int32_t blockSetVstbSlotId(const SSDataBlock* pSrcBlock,SArray* pColMap) {




16,451,025✔





1986



  int32_t      code = TSDB_CODE_SUCCESS;




16,451,025✔





1987



  int32_t      lino = 0;




16,451,025✔





1988



  bool         found = false;




16,451,025✔





1989












1990



  QUERY_CHECK_NULL(pSrcBlock, code, lino, _return, TSDB_CODE_INVALID_PARA);




16,451,025✔





1991



  QUERY_CHECK_NULL(pColMap, code, lino, _return, TSDB_CODE_INVALID_PARA);




16,451,025✔





1992












1993



  for (int32_t i = 0; i < taosArrayGetSize(pSrcBlock->pDataBlock); i++) {




81,723,724✔





1994



    SColumnInfoData* pSrcCol = taosArrayGet(pSrcBlock->pDataBlock, i);




65,272,699✔





1995



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




65,272,699✔





1996



    for (int32_t j = 0; j < taosArrayGetSize(pColMap); j++) {




186,896,419✔





1997



      SColIdSlotIdPair* pColPair = taosArrayGet(pColMap, j);




170,448,439✔





1998



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




170,448,439✔





1999



      if (pSrcCol->info.colId == pColPair->orgColId) {




170,448,439✔





2000



        pSrcCol->info.slotId = (int16_t)pColPair->vtbSlotId;




48,824,719✔





2001



        found = true;




48,824,719✔





2002



        break;




48,824,719✔





2003



      }










2004



    }










2005



    if (!found) {




65,272,699✔





2006



      if (pSrcCol->info.colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




16,447,980✔





2007



        pSrcCol->info.slotId = -1;




16,447,980✔





2008



      } else {










2009



        qError("cannot find vstb slotId for org colId:%d (pColMap size:%d)", pSrcCol->info.colId,




×







2010



               (int32_t)taosArrayGetSize(pColMap));










2011



        code = TSDB_CODE_QRY_VSTB_SLOTID_NOT_FOUND;




×







2012



      }










2013



    }










2014



  }










2015












2016



  return code;




16,451,025✔





2017



_return:




×







2018



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




×







2019



  return code;




×







2020



}










2021












2022



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




23,162,704✔





2023



  int32_t                  code = TSDB_CODE_SUCCESS;




23,162,704✔





2024



  int32_t                  lino = 0;




23,162,704✔





2025



  STableScanInfo*          pInfo = pOperator->info;




23,162,704✔





2026



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




23,162,704✔





2027



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




23,162,704✔





2028



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




23,162,704✔





2029












2030



  QRY_PARAM_CHECK(ppRes);




23,162,704✔





2031



  qTrace("%s call", __FUNCTION__);




23,162,704✔





2032












2033



  code = createVTableScanInfoFromParam(pOperator);




23,162,704✔





2034



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




23,162,704✔





2035



  pOperator->pOperatorGetParam = NULL;




23,162,704✔





2036












2037



  QUERY_CHECK_CODE(code, lino, _end);




23,162,704✔





2038












2039



  SSDataBlock* result = NULL;




23,162,061✔





2040



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




23,162,061✔





2041



    (*ppRes) = result;




19,304✔





2042



    return code;




19,304✔





2043



  }










2044












2045



  if (pInfo->newReader) {




23,142,757✔





2046



    code = startNextGroupScan(pOperator, &result);




6,720,284✔





2047



    QUERY_CHECK_CODE(code, lino, _end);




6,720,284✔





2048



  } else {










2049



    code = doGroupedTableScan(pOperator, &result);




16,422,473✔





2050



    QUERY_CHECK_CODE(code, lino, _end);




16,422,473✔





2051



  }










2052












2053



  if (result) {




23,142,757✔





2054



    SSDataBlock* res = NULL;




16,451,025✔





2055



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




16,451,025✔





2056



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




16,451,025✔





2057



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




16,451,025✔





2058












2059



    code = blockSetVstbSlotId(result, pInfo->pBlockColMap);




16,451,025✔





2060



    QUERY_CHECK_CODE(code, lino, _end);




16,451,025✔





2061



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










2062



    //QUERY_CHECK_CODE(code, lino, _end);










2063












2064



    //pInfo->pResBlock = res;










2065



    //blockDataDestroy(result);










2066



    (*ppRes) = result;




16,451,025✔





2067



  } else {










2068



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




6,691,732✔





2069



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




6,691,732✔





2070












2071



    blockDataDestroy(pInfo->pResBlock);




6,691,732✔





2072



    pInfo->pResBlock = NULL;




6,691,732✔





2073












2074



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




6,691,732✔





2075



    if (reader) {




6,691,732✔





2076



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




6,691,732✔





2077



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




6,691,732✔





2078



        pInfo->base.dataReader = NULL;




6,691,732✔





2079



      }










2080



      if (pAPI->tsdReader.tsdReaderClose) {




6,691,732✔





2081



        pAPI->tsdReader.tsdReaderClose(*reader);




6,691,732✔





2082



      }










2083



    }










2084












2085



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




6,691,732✔





2086



    QUERY_CHECK_CODE(code, lino, _end);




6,691,732✔





2087



  }










2088



_end:




23,143,400✔





2089



  if (code) {




23,143,400✔





2090



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




643✔





2091



  }










2092



  return code;




23,143,400✔





2093



}










2094












2095



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




16,234,274✔





2096



  int32_t                  code = TSDB_CODE_SUCCESS;




16,234,274✔





2097



  int32_t                  lino = 0;




16,234,274✔





2098



  STableScanInfo*          pInfo = pOperator->info;




16,234,274✔





2099



  int32_t                  index = 0;




16,234,274✔





2100



  char*                    tagVal = NULL;




16,234,274✔





2101












2102



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




115,836,068✔





2103



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




99,600,255✔





2104



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




99,600,022✔





2105












2106



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




99,598,475✔





2107



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




99,598,475✔





2108












2109



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




2,147,483,647✔





2110



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




2,147,483,647✔





2111



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




2,147,483,647✔





2112



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




2,147,483,647✔





2113












2114



        varDataSetLen(tagVal, pTagVal->nData);




2,147,483,647✔





2115



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




2,147,483,647✔





2116



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




2,147,483,647✔





2117



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2118



        taosMemoryFreeClear(tagVal);




2,147,483,647✔





2119



      } else {










2120



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




2,147,483,647✔





2121



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2122



      }










2123



    }










2124



    index++;




99,601,794✔





2125



  }










2126



  return code;




16,234,862✔





2127



_end:




×







2128



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




×







2129



  taosMemoryFreeClear(tagVal);




×







2130



  return code;




×







2131



}










2132












2133



static void clearVstbBatchDynamicTableScanInfo(STableScanInfo* pInfo) {




5,195,962✔





2134



  if (pInfo->pBatchColMap) {




5,195,962✔





2135



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




13,500,129✔





2136



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




8,302,392✔





2137



      taosArrayDestroy(pOrgTbInfo->colMap);




8,303,102✔





2138



    }










2139



    taosArrayDestroy(pInfo->pBatchColMap);




5,196,317✔





2140



    pInfo->pBatchColMap = NULL;




5,194,897✔





2141



  }










2142



  if (pInfo->cachedTagList) {




5,195,252✔





2143



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




16,270,495✔





2144



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




13,835,128✔





2145



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




13,836,548✔





2146



        taosMemoryFreeClear(pTagVal->pData);




6,074,467✔





2147



      }










2148



    }










2149



    taosArrayDestroy(pInfo->cachedTagList);




2,438,562✔





2150



    pInfo->cachedTagList = NULL;




2,437,497✔





2151



  }










2152



  if (pInfo->lastColArray) {




5,192,767✔





2153



    taosArrayDestroy(pInfo->lastColArray);




5,195,252✔





2154



    pInfo->lastColArray = NULL;




5,195,252✔





2155



  }










2156



  if (pInfo->lastBlockColArray) {




5,193,832✔





2157



    taosArrayDestroy(pInfo->lastBlockColArray);




5,195,962✔





2158



    pInfo->lastBlockColArray = NULL;




5,197,027✔





2159



  }










2160












2161



  blockDataDestroy(pInfo->pResBlock);




5,195,252✔





2162



  pInfo->pResBlock = NULL;




5,197,027✔





2163



}




5,197,382✔





2164












2165



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




78,160,609✔





2166



  int32_t                  code = TSDB_CODE_SUCCESS;




78,160,609✔





2167



  int32_t                  lino = 0;




78,160,609✔





2168



  STableScanInfo*          pInfo = pOperator->info;




78,160,609✔





2169



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




78,188,558✔





2170



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




78,195,687✔





2171



  SSDataBlock*             result = NULL;




78,198,166✔





2172












2173



  QRY_PARAM_CHECK(ppRes);




78,199,471✔





2174



  qTrace("%s call", __FUNCTION__);




78,187,429✔





2175












2176



  while (!result) {




154,234,490✔





2177



    code = createVTableScanInfoFromBatchParam(pOperator);




81,288,804✔





2178



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




81,303,632✔





2179



    pOperator->pOperatorGetParam = NULL;




81,264,577✔





2180



    QUERY_CHECK_CODE(code, lino, _end);




81,281,472✔





2181












2182



    if (pInfo->newReader) {




81,281,472✔





2183



      code = startNextGroupScan(pOperator, &result);




8,258,609✔





2184



      QUERY_CHECK_CODE(code, lino, _end);




8,298,576✔





2185



    } else {










2186



      code = doGroupedTableScan(pOperator, &result);




73,032,253✔





2187



      QUERY_CHECK_CODE(code, lino, _end);




72,936,852✔





2188



    }










2189



    if (!result) {




81,235,428✔





2190



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




8,298,025✔





2191



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










2192



      pInfo->currentBatchIdx++;




8,298,025✔





2193



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




8,294,659✔





2194



        // all batch scan finished










2195



        break;




5,197,027✔





2196



      }










2197



    }










2198



  }










2199












2200



  if (result) {




78,142,713✔





2201



    SSDataBlock* res = NULL;




72,946,751✔





2202



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




72,969,175✔





2203



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




72,990,946✔





2204



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




73,004,126✔





2205












2206



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




73,004,243✔





2207



    QUERY_CHECK_CODE(code, lino, _end);




73,033,183✔





2208












2209



    if (pInfo->cachedTagList) {




73,033,183✔





2210



      code = setTagValFromTagList(pOperator, res);




16,234,274✔





2211



      QUERY_CHECK_CODE(code, lino, _end);




16,234,862✔





2212



    }










2213












2214



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




73,035,535✔





2215



    pInfo->pResBlock = res;




73,030,179✔





2216



    blockDataDestroy(result);




73,040,843✔





2217



    (*ppRes) = res;




73,028,447✔





2218












2219



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




73,027,271✔





2220



  } else {










2221



    clearVstbBatchDynamicTableScanInfo(pInfo);




5,195,962✔





2222



    setOperatorCompleted(pOperator);




5,195,607✔





2223



  }










2224












2225



_end:




78,214,471✔





2226



  return code;




78,226,650✔





2227



}










2228












2229



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




102,968,987✔





2230



  int32_t                  code = TSDB_CODE_SUCCESS;




102,968,987✔





2231



  int32_t                  lino = 0;




102,968,987✔





2232



  STableScanInfo*          pInfo = pOperator->info;




102,968,987✔





2233



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




102,997,735✔





2234



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




102,980,000✔





2235












2236



  QRY_PARAM_CHECK(ppRes);




103,006,316✔





2237



  qTrace("%s call", __FUNCTION__);




103,003,414✔





2238












2239



  pOperator->dynamicTask = true;




103,003,414✔





2240












2241



  switch (type) {




102,988,944✔





2242



    case DYN_TYPE_VSTB_WIN_SCAN:




1,614,040✔





2243



    case DYN_TYPE_STB_JOIN: {










2244



      code = doStbJoinDynamicTableScanNext(pOperator, ppRes);




1,614,040✔





2245



      QUERY_CHECK_CODE(code, lino, _end);




1,614,040✔





2246



      break;




1,614,040✔





2247



    }










2248



    case DYN_TYPE_VSTB_SINGLE_SCAN: {




23,162,704✔





2249



      code = doVstbSingleDynamicTableScanNext(pOperator, ppRes);




23,162,704✔





2250



      QUERY_CHECK_CODE(code, lino, _end);




23,162,704✔





2251



      break;




23,162,061✔





2252



    }










2253



    case DYN_TYPE_VSTB_BATCH_SCAN:




78,212,200✔





2254



      code = doVstbBatchDynamicTableScanNext(pOperator, ppRes);




78,212,200✔





2255



      QUERY_CHECK_CODE(code, lino, _end);




78,192,540✔





2256



      break;




78,192,540✔





2257



    default:




×







2258



      code = TSDB_CODE_INVALID_PARA;




×







2259



      QUERY_CHECK_CODE(code, lino, _end);




×







2260



      break;




×







2261



  }










2262












2263



_end:




102,969,284✔





2264



  return code;




102,969,284✔





2265



}










2266












2267



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




905,282,371✔





2268



  int32_t         code = TSDB_CODE_SUCCESS;




905,282,371✔





2269



  int32_t         lino = 0;




905,282,371✔





2270



  STableScanInfo* pInfo = pOperator->info;




905,282,371✔





2271



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




905,503,805✔





2272



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




905,453,376✔





2273



  QRY_PARAM_CHECK(ppRes);




905,477,769✔





2274



  qTrace("%s call", __FUNCTION__);




905,505,216✔





2275












2276



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




905,505,980✔





2277



  QUERY_CHECK_CODE(code, lino, _end);




905,499,640✔





2278












2279



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




905,499,640✔





2280



  if (pGetParam || pInfo->pBatchColMap) {




905,512,831✔





2281



    ETableScanDynType type = pGetParam ?




102,975,642✔





2282



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




102,978,982✔





2283



      DYN_TYPE_VSTB_BATCH_SCAN;










2284












2285



    code = doDynamicTableScanNext(pOperator, type, ppRes);




102,975,642✔





2286



    QUERY_CHECK_CODE(code, lino, _end);




102,970,817✔





2287












2288



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




102,970,174✔





2289



      return code;




101,424,529✔





2290



    }










2291



  }










2292












2293



  // scan table one by one sequentially










2294



  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {




804,071,872✔





2295



    int32_t       numOfTables = 0;




6,076,439✔





2296



    STableKeyInfo tInfo = {0};




6,076,439✔





2297



    pInfo->countState = TABLE_COUNT_STATE_END;




6,076,439✔





2298












2299



    while (1) {




5,665,392✔





2300



      SSDataBlock* result = NULL;




11,741,831✔





2301



      code = doGroupedTableScan(pOperator, &result);




11,741,833✔





2302



      QUERY_CHECK_CODE(code, lino, _end);




11,739,291✔





2303












2304



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




11,739,291✔





2305



        (*ppRes) = result;




6,026,044✔





2306



        return code;




6,032,116✔





2307



      }










2308












2309



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










2310



      pInfo->currentTable++;




5,710,158✔





2311












2312



      taosRLockLatch(&pTaskInfo->lock);




5,707,173✔





2313



      numOfTables = 0;




5,713,890✔





2314



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




5,713,890✔





2315



      if (code != TSDB_CODE_SUCCESS) {




5,712,599✔





2316



        taosRUnLockLatch(&pTaskInfo->lock);




×







2317



        TSDB_CHECK_CODE(code, lino, _end);




×







2318



      }










2319












2320



      if (pInfo->currentTable >= numOfTables) {




5,712,599✔





2321



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




43,681✔





2322



        taosRUnLockLatch(&pTaskInfo->lock);




43,681✔





2323



        (*ppRes) = NULL;




43,681✔





2324



        return code;




43,681✔





2325



      }










2326












2327



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




5,658,435✔





2328



      if (!tmp) {




5,664,559✔





2329



        taosRUnLockLatch(&pTaskInfo->lock);




×







2330



        (*ppRes) = NULL;




×







2331



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




×







2332



      }










2333












2334



      tInfo = *tmp;




5,664,559✔





2335



      taosRUnLockLatch(&pTaskInfo->lock);




5,662,541✔





2336












2337



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




5,669,601✔





2338



      QUERY_CHECK_CODE(code, lino, _end);




5,664,455✔





2339



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




5,664,455✔





2340



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










2341












2342



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




5,671,480✔





2343



      QUERY_CHECK_CODE(code, lino, _end);




5,662,841✔





2344



      pInfo->scanTimes = 0;




5,662,841✔





2345



    }










2346



  } else {  // scan table group by group sequentially










2347



    code = groupSeqTableScan(pOperator, ppRes);




797,933,321✔





2348



    QUERY_CHECK_CODE(code, lino, _end);




796,836,497✔





2349



  }










2350












2351



_end:




796,834,462✔





2352



  if (code != TSDB_CODE_SUCCESS) {




796,849,336✔





2353



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




2,678✔





2354



    pTaskInfo->code = code;




2,678✔





2355



    T_LONG_JMP(pTaskInfo->env, code);




2,678✔





2356



  }










2357












2358



  return code;




796,846,658✔





2359



}










2360












2361



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




1,902,952✔





2362



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




1,902,952✔





2363



  if (!pRecorder) {




1,902,952✔





2364



    return terrno;




×







2365



  }










2366



  STableScanInfo* pTableScanInfo = pOptr->info;




1,902,952✔





2367



  *pRecorder = pTableScanInfo->base.readRecorder;




1,902,952✔





2368



  *pOptrExplain = pRecorder;




1,902,952✔





2369



  *len = sizeof(SFileBlockLoadRecorder);




1,902,952✔





2370



  return 0;




1,902,952✔





2371



}










2372












2373



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




259,222,183✔





2374



  cleanupQueryTableDataCond(&pBase->cond);




259,222,183✔





2375



  cleanupQueryTableDataCond(&pBase->orgCond);




259,191,719✔





2376












2377



  if (pAPI->tsdReaderClose) {




259,217,460✔





2378



    pAPI->tsdReaderClose(pBase->dataReader);




259,224,040✔





2379



  }










2380



  pBase->dataReader = NULL;




259,175,820✔





2381












2382



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




259,182,701✔





2383



    taosArrayDestroy(pBase->matchInfo.pList);




259,199,960✔





2384



  }










2385












2386



  tableListDestroy(pBase->pTableListInfo);




259,149,758✔





2387



  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);




259,221,968✔





2388



  cleanupExprSupp(&pBase->pseudoSup);




259,214,612✔





2389



}




259,237,835✔





2390












2391



static void cleanReaderForVTable(STableScanInfo* pInfo){




5,964,559✔





2392



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




5,964,559✔





2393



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




5,966,924✔





2394



    while (pIter != NULL) {




5,991,654✔





2395



      void **reader = pIter;




24,136✔





2396



      if (*reader) {




24,136✔





2397



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




24,136✔





2398



          pInfo->base.dataReader = NULL;




21,824✔





2399



        }










2400



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




24,136✔





2401



      }










2402



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




24,136✔





2403



    }










2404



  }










2405



}




5,966,109✔





2406












2407



static void destroyTableScanOperatorInfo(void* param) {




232,584,629✔





2408



  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;




232,584,629✔





2409



  blockDataDestroy(pTableScanInfo->pResBlock);




232,584,629✔





2410



  blockDataDestroy(pTableScanInfo->pOrgBlock);




232,572,989✔





2411



  taosHashCleanup(pTableScanInfo->pIgnoreTables);




232,574,128✔





2412



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




232,562,306✔





2413



    cleanReaderForVTable(pTableScanInfo);




5,964,699✔





2414



    taosHashCleanup(pTableScanInfo->readerCache);




5,968,106✔





2415



  }










2416



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




232,570,444✔





2417



  taosArrayDestroy(pTableScanInfo->pBlockColMap);




232,584,882✔





2418



  taosMemoryFreeClear(param);




232,582,100✔





2419



}




232,534,757✔





2420












2421



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




232,433,271✔





2422



  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {




232,433,271✔





2423



    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);




7,746,611✔





2424



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




19,589,541✔





2425



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




11,847,828✔





2426



      if (pCol) {




11,847,490✔





2427



        pCol->info.noData = true;




11,846,911✔





2428



      }










2429



    }










2430



  }










2431



}




232,428,373✔





2432












2433



static int32_t resetTableScanOperatorState(SOperatorInfo* pOper) {




282,261✔





2434



  int32_t         code = TSDB_CODE_SUCCESS;




282,261✔





2435



  STableScanInfo*   pInfo = pOper->info;




282,261✔





2436



  pOper->status = OP_NOT_OPENED;




282,261✔





2437












2438



  pInfo->scanTimes = 0;




282,261✔





2439



  pInfo->currentGroupId = -1;




282,261✔





2440



  pInfo->tableEndIndex = -1;




282,261✔





2441



  pInfo->tableStartIndex = 0;




282,261✔





2442



  pInfo->currentTable = 0;




282,261✔





2443



  pInfo->scanMode = 0;




282,261✔





2444



  pInfo->countState = 0;




282,261✔





2445



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




282,261✔





2446












2447



  if (!pInfo->virtualStableScan) {




282,261✔





2448



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










2449



  //   cleanReaderForVTable(pInfo);










2450



  //   taosHashClear(pInfo->readerCache);










2451



  //   pInfo->readerCache = false;










2452



  // } else {










2453



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




131,733✔





2454



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




131,733✔





2455



    }










2456



    pInfo->base.dataReader = NULL;




131,733✔





2457



  }










2458



  tableListDestroy(pInfo->base.pTableListInfo);




282,261✔





2459



  pInfo->base.pTableListInfo = tableListCreate();




282,261✔





2460



  if (!pInfo->base.pTableListInfo) {




282,261✔





2461



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




×







2462



    return terrno;




×







2463



  }










2464



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




282,261✔





2465












2466



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




282,261✔





2467



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




282,261✔





2468



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




260,525✔





2469



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










2470



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




260,525✔





2471



    if (code) {




130,693✔





2472



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




×







2473



      return code;




×







2474



    }










2475



  }










2476












2477



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




282,261✔





2478



  cleanupQueryTableDataCond(&pInfo->base.cond);




282,261✔





2479



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




282,261✔





2480



  if (code) {




282,261✔





2481



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




×







2482



    return code;




×







2483



  }










2484



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




282,261✔





2485



    cleanupQueryTableDataCond(&pInfo->base.orgCond);




150,528✔





2486



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




150,528✔





2487



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




150,528✔





2488



  } 










2489












2490



  pOper->resultInfo.totalRows = 0;




282,261✔





2491



  blockDataEmpty(pInfo->pResBlock);




282,261✔





2492



  blockDataEmpty(pInfo->pOrgBlock);




282,261✔





2493



  taosHashClear(pInfo->pIgnoreTables);




282,261✔





2494



  taosArrayDestroy(pInfo->pBlockColMap);




282,261✔





2495



  pInfo->pBlockColMap = NULL;




282,261✔





2496



  return code;




282,261✔





2497



}










2498












2499



int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




232,569,361✔





2500



                                    STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










2501



                                    SOperatorInfo** pOptrInfo) {










2502



  QRY_PARAM_CHECK(pOptrInfo);




232,569,361✔





2503












2504



  int32_t         code = TSDB_CODE_SUCCESS;




232,585,481✔





2505



  int32_t         lino = 0;




232,585,481✔





2506



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




232,585,481✔





2507



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




232,517,172✔





2508



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




232,519,879✔






UNCOV

2509



    code = terrno;




×







2510



    goto _error;




×







2511



  }










2512












2513



  pOperator->pPhyNode = pTableScanNode;




232,521,853✔





2514



  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;




232,525,040✔





2515



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




232,528,174✔





2516












2517



  int32_t numOfCols = 0;




232,536,303✔





2518



  code =










2519



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




232,562,739✔





2520



  QUERY_CHECK_CODE(code, lino, _error);




232,482,700✔





2521












2522



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




232,482,700✔





2523



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




232,460,192✔





2524



  QUERY_CHECK_CODE(code, lino, _error);




232,437,257✔





2525












2526



  if (pScanNode->pScanPseudoCols != NULL) {




232,437,257✔





2527



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




52,591,327✔





2528



    pSup->pExprInfo = NULL;




52,601,947✔





2529



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




52,612,769✔





2530



    QUERY_CHECK_CODE(code, lino, _error);




52,564,809✔





2531












2532



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




52,564,809✔





2533



                                      &pTaskInfo->storageAPI.functionStore);










2534



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




52,617,992✔





2535



  }










2536












2537



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




232,449,149✔





2538



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




232,328,270✔





2539












2540



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




232,450,267✔





2541



  pInfo->base.readHandle = *readHandle;




232,223,975✔





2542



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




232,424,428✔





2543












2544



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




232,384,316✔





2545



  pInfo->sample.seed = taosGetTimestampSec();




232,471,535✔





2546












2547



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




232,446,929✔





2548



  initResultSizeInfo(&pOperator->resultInfo, 4096);




232,439,076✔





2549



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




232,381,826✔





2550



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




232,405,944✔





2551



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




232,225,473✔





2552












2553



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




232,239,770✔





2554



  QUERY_CHECK_CODE(code, lino, _error);




232,295,102✔





2555












2556



  pInfo->virtualStableScan = pScanNode->virtualStableScan;




232,295,102✔





2557



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




232,296,184✔





2558



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




5,966,187✔





2559



    pInfo->pResBlock = NULL;




5,959,135✔





2560



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




5,965,607✔





2561



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




5,959,107✔





2562



  }










2563












2564



  if (pInfo->virtualStableScan) {




232,251,028✔





2565



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




5,961,623✔





2566



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




5,968,691✔





2567



  }










2568












2569



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




232,498,185✔





2570



                            pTaskInfo->pStreamRuntimeInfo);




232,418,971✔





2571



  QUERY_CHECK_CODE(code, lino, _error);




232,324,765✔





2572












2573



  pInfo->currentGroupId = -1;




232,301,701✔





2574












2575



  pInfo->tableEndIndex = -1;




232,306,183✔





2576



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




232,382,192✔





2577



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




232,272,002✔





2578












2579



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




232,453,194✔





2580



                  pTaskInfo);










2581



  pOperator->exprSupp.numOfExprs = numOfCols;




232,157,266✔





2582












2583



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




232,365,958✔





2584



  pInfo->ignoreTag = false;




232,438,262✔





2585












2586



  pInfo->lastBatchIdx = -1;




232,362,564✔





2587



  pInfo->currentBatchIdx = 0;




232,269,961✔





2588



  pInfo->base.pTableListInfo = pTableListInfo;




232,460,095✔





2589



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




232,394,992✔





2590



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




×







2591



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




×







2592



      code = terrno;




×







2593



      QUERY_CHECK_CODE(code, lino, _error);




×







2594



    }










2595












2596



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




×







2597



  }










2598












2599



  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




232,394,992✔





2600












2601



  pOperator->fpSet = createOperatorFpSet(prepareTableScan, doTableScanNext,




232,408,262✔





2602



                                         NULL, destroyTableScanOperatorInfo,










2603



                                         optrDefaultBufFn,










2604



                                         getTableScannerExecInfo,










2605



                                         optrDefaultGetNextExtFn, NULL);










2606












2607



  setOperatorResetStateFn(pOperator, resetTableScanOperatorState); 




232,279,119✔





2608



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










2609



  pOperator->cost.openCost = 0;




232,246,602✔





2610



  *pOptrInfo = pOperator;




232,253,987✔





2611



  return TSDB_CODE_SUCCESS;




232,180,071✔





2612












2613



_error:




23,064✔





2614



  if (pInfo != NULL) {




23,064✔





2615



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




23,064✔





2616



    destroyTableScanOperatorInfo(pInfo);




23,064✔





2617



  }










2618












2619



  if (pOperator != NULL) {




23,064✔





2620



    pOperator->info = NULL;




23,064✔





2621



    destroyOperator(pOperator);




23,064✔





2622



  }










2623



  pTaskInfo->code = code;




23,064✔





2624



  return code;




23,064✔





2625



}










2626












2627



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




×







2628



  QRY_PARAM_CHECK(pOptrInfo);




×







2629












2630



  int32_t         code = 0;




×







2631



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




×







2632



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




×







2633



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




×







2634



    code = terrno;




×







2635



    goto _end;




×







2636



  }










2637












2638



  pInfo->base.dataReader = pReadHandle;




×







2639



  //  pInfo->prevGroupId       = -1;










2640












2641



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




×







2642



                  pInfo, pTaskInfo);










2643



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




×







2644



                                         optrDefaultGetNextExtFn, NULL);










2645



  *pOptrInfo = pOperator;




×







2646



  return code;




×







2647












2648



_end:




×







2649



  if (pInfo != NULL) {




×







2650



    taosMemoryFree(pInfo);




×







2651



  }










2652












2653



  if (pOperator != NULL) {




×







2654



    taosMemoryFree(pOperator);




×







2655



  }










2656












2657



  pTaskInfo->code = code;




×







2658



  return code;




×







2659



}










2660












2661



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




13,763✔





2662



  int32_t code = TSDB_CODE_SUCCESS;




13,763✔





2663



  int32_t lino = 0;




13,763✔





2664



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




13,763✔





2665



    return code;




1,685✔





2666



  }










2667



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




12,078✔





2668



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




12,078✔





2669



  bool hasUnqualified = false;




12,078✔





2670












2671



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




12,078✔





2672



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




12,078✔





2673












2674



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




12,078✔





2675



         VALUE_GET_TRIVIAL_DATUM(&offset->primaryKey));










2676



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




12,078✔





2677



                        TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);










2678












2679



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




12,078✔





2680



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




12,078✔





2681



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




43,322,222✔





2682



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




43,310,144✔





2683



    void*    data = colDataGetData(pColPk, i);




43,310,144✔





2684



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




43,312,488✔





2685



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




2,344✔





2686



        QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY, lino, _end);




×







2687



      }










2688



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




2,344✔





2689



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




2,344✔





2690



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




2,344✔





2691



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




2,344✔





2692



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




2,344✔





2693



      taosMemoryFree(tmq);




2,344✔





2694



    } else {










2695



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




43,307,800✔





2696



    }










2697












2698



    if (!p[i]) {




43,310,144✔





2699



      hasUnqualified = true;




15,389,258✔





2700



    }










2701



  }










2702












2703



  if (hasUnqualified) {




12,078✔





2704



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




4,050✔





2705



    QUERY_CHECK_CODE(code, lino, _end);




4,050✔





2706



  }










2707












2708



_end:




12,078✔





2709



  taosMemoryFree(p);




12,078✔





2710



  if (code != TSDB_CODE_SUCCESS) {




12,078✔





2711



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




×







2712



  }










2713



  return code;




12,078✔





2714



}










2715












2716



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




×







2717



  int32_t p1 = *(int32_t*)param1;




×







2718



  int32_t p2 = *(int32_t*)param2;




×







2719












2720



  if (p1 == p2) {




×







2721



    return 0;




×







2722



  } else {










2723



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




×







2724



  }










2725



}










2726












2727



static int32_t processBlock(SStreamScanInfo* pInfo) {




23,309,566✔





2728



  int32_t         code = TSDB_CODE_SUCCESS;




23,309,566✔





2729



  int32_t         lino = 0;




23,309,566✔





2730



  SOperatorInfo*  pOperator = pInfo->pStreamScanOp;




23,309,566✔





2731












2732



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




23,309,921✔





2733



  QUERY_CHECK_CODE(code, lino, _end);




23,309,921✔





2734












2735



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




23,309,921✔





2736



  QUERY_CHECK_CODE(code, lino, _end);




23,309,566✔





2737












2738



_end:




23,309,566✔





2739



  if (code != TSDB_CODE_SUCCESS) {




23,309,566✔





2740



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




×







2741



  }










2742



  return code;




23,309,566✔





2743



}










2744












2745



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




6,773,958✔





2746



  int32_t code = TSDB_CODE_SUCCESS;




6,773,958✔





2747



  int32_t lino = 0;




6,773,958✔





2748



  SValue  val = {0};




6,773,958✔





2749



  if (hasPrimaryKey) {




6,774,864✔





2750



    code = doBlockDataPrimaryKeyFilter(pBlock, offset);




13,763✔





2751



    if (code != TSDB_CODE_SUCCESS) {




13,763✔





2752



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




×







2753



      return code;




×







2754



    }










2755



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




13,763✔





2756












2757



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




13,763✔





2758



      return code;




3,757✔





2759



    }










2760



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




10,006✔





2761



    val.type = pColPk->info.type;




10,006✔





2762



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




10,006✔





2763



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




641✔





2764



        return TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY;




×







2765



      }










2766



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




641✔





2767



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




641✔





2768



      val.nData = varDataLen(tmp);




641✔





2769



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




641✔





2770



    } else {










2771



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




9,365✔





2772



    }










2773



  }










2774



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




6,771,107✔





2775












2776



_end:




6,770,841✔





2777



  if (code != TSDB_CODE_SUCCESS) {




6,771,143✔





2778



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




×







2779



  }










2780



  return code;




6,769,889✔





2781



}










2782












2783



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




23,496,163✔





2784



  int32_t        code = TSDB_CODE_SUCCESS;




23,496,163✔





2785



  int32_t        lino = 0;




23,496,163✔





2786



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




23,496,163✔





2787



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




23,498,921✔





2788












2789



  SStreamScanInfo* pInfo = pOperator->info;




23,497,836✔





2790



  const char*      id = GET_TASKID(pTaskInfo);




23,498,567✔





2791












2792



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




23,497,168✔





2793












2794



  if (isTaskKilled(pTaskInfo)) {




23,502,037✔





2795



    (*ppRes) = NULL;




×







2796



    return pTaskInfo->code;




×







2797



  }










2798












2799



  blockDataCleanup(pInfo->pRes);




23,499,589✔





2800



  int64_t st = taosGetTimestampMs();




23,498,554✔





2801



  










2802



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




23,498,554✔





2803



    while (1) {




5,758,452✔





2804



      SSDataBlock* pResult = NULL;




6,074,123✔





2805



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




6,074,837✔





2806



      QUERY_CHECK_CODE(code, lino, _end);




6,075,477✔





2807












2808



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




6,075,477✔





2809



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




6,032,758✔





2810



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




6,032,438✔





2811



        QUERY_CHECK_CODE(code, lino, _end);




6,031,156✔





2812



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




6,031,156✔





2813



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




6,032,438✔





2814



          code = blockDataMerge(pInfo->pRes, pResult);




6,029,001✔





2815



          QUERY_CHECK_CODE(code, lino, _end);




6,028,359✔





2816



        }










2817



      } else {










2818



        break;










2819



      }










2820












2821



      if (pInfo->pRes->info.rows >= pTaskInfo->streamInfo.minPollRows){




6,032,116✔





2822



        (*ppRes) = pInfo->pRes;




264,723✔





2823



        return code;




264,723✔





2824



      }










2825



      int64_t elapsed = taosGetTimestampMs() - st;




5,766,432✔





2826



      if (elapsed > pTaskInfo->streamInfo.timeout || elapsed < 0) {




5,766,432✔





2827



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




8,941✔





2828



          terrno = TSDB_CODE_TMQ_FETCH_TIMEOUT ;




×







2829



        }










2830



        (*ppRes) = pInfo->pRes;




8,302✔





2831



        return code;




8,302✔





2832



      }   










2833



    }










2834












2835



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




43,681✔





2836



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




43,681✔





2837












2838



    pTSInfo->base.dataReader = NULL;




43,681✔





2839



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




43,681✔





2840



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




43,681✔





2841



    code = pAPI->tqReaderFn.tqReaderSeek(pInfo->tqReader, validVer, pTaskInfo->id.str);




43,681✔





2842



    if (code == TSDB_CODE_WAL_LOG_NOT_EXIST) {




43,681✔





2843



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




13,079✔





2844



        (*ppRes) = NULL;




5,731✔





2845



      } else {










2846



        (*ppRes) = pInfo->pRes;




7,348✔





2847



      }










2848



      return 0;




13,079✔





2849



    }










2850



    QUERY_CHECK_CODE(code, lino, _end);




30,602✔





2851












2852



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




30,602✔





2853



  }










2854












2855



  while (1) {




96,436✔





2856



    code = pAPI->tqReaderFn.tqReaderNextBlockInWal(pInfo->tqReader, pInfo->pRes, 




69,927,714✔





2857



                                                              pInfo->pCol2SlotId,










2858



                                                              pInfo->pPseudoExpr,










2859



                                                              pInfo->numOfPseudoExpr,










2860



                                                              pTaskInfo->streamInfo.sourceExcluded,




23,309,576✔





2861



                                                              pTaskInfo->streamInfo.minPollRows,










2862



                                                              pTaskInfo->streamInfo.timeout,










2863



                                                              pTaskInfo->streamInfo.enableReplay);




23,309,576✔





2864



    if (code != 0 && code != TSDB_CODE_TMQ_FETCH_TIMEOUT && code != TSDB_CODE_WAL_LOG_NOT_EXIST) {




23,309,231✔





2865



      goto _end;




×







2866



    }                                                              










2867



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




23,309,231✔





2868












2869



    // curVersion move to next










2870



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




23,308,886✔





2871












2872



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










2873



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




23,308,532✔





2874












2875



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




23,308,877✔





2876



            pTaskInfo->streamInfo.currentOffset.version);










2877



    int32_t ret = processBlock(pInfo);




23,309,921✔





2878



    if (ret != 0) {




23,309,233✔





2879



      code = ret;




×







2880



      goto _end;




×







2881



    }










2882



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




23,309,233✔





2883



            pTaskInfo->streamInfo.currentOffset.version, tstrerror(code));










2884



    










2885



    if (code != 0) {




23,309,921✔





2886



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




22,730,794✔





2887



        (*ppRes) = NULL;




10,350,609✔





2888



      } else {










2889



        (*ppRes) = pInfo->pRes;




12,380,185✔





2890



      }










2891



      return 0;




22,730,794✔





2892



    }










2893












2894



    if (pInfo->pRes->info.rows >= pTaskInfo->streamInfo.minPollRows || 




579,127✔





2895



        (pInfo->pRes->info.rows > 0 && pTaskInfo->streamInfo.enableReplay)) {




101,566✔





2896



      (*ppRes) = pInfo->pRes;




482,691✔





2897



      return 0;




482,691✔





2898



    }










2899



  }










2900












2901



_end:




×







2902



  if (code != TSDB_CODE_SUCCESS) {




×







2903



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




×







2904



    pTaskInfo->code = code;




×







2905



    T_LONG_JMP(pTaskInfo->env, code);




×







2906



  }










2907



  (*ppRes) = NULL;




×







2908



  return code;




×







2909



}










2910












2911



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




326,062✔





2912



  int32_t code = TSDB_CODE_SUCCESS;




326,062✔





2913



  int32_t lino = 0;




326,062✔





2914



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




326,062✔





2915



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




327,080✔





2916












2917



  // Transfer the Array of STableKeyInfo into uid list.










2918



  int32_t size = 0;




327,080✔





2919



  code = tableListGetSize(pTableListInfo, &size);




326,772✔





2920



  QUERY_CHECK_CODE(code, lino, _end);




327,080✔





2921



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




9,660,289✔





2922



    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);




9,333,596✔





2923



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




9,332,855✔





2924



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




9,332,855✔





2925



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




9,333,209✔





2926



  }










2927












2928



  (*ppArrayRes) = tableIdList;




326,693✔





2929












2930



_end:




326,450✔





2931



  if (code != TSDB_CODE_SUCCESS) {




326,758✔





2932



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




×







2933



  }










2934



  return code;




326,758✔





2935



}










2936












2937



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




1,539,234✔





2938



  int32_t        code = TSDB_CODE_SUCCESS;




1,539,234✔





2939



  int32_t        lino = 0;




1,539,234✔





2940



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,539,234✔





2941



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,539,234✔





2942












2943



  SStreamRawScanInfo* pInfo = pOperator->info;




1,539,234✔





2944



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




1,539,234✔





2945



  pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL;




1,539,234✔





2946












2947



  qDebug("tmqsnap doRawScan called");




1,539,234✔





2948



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




1,539,234✔





2949



    bool hasNext = false;




1,533,576✔





2950



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




1,533,576✔





2951



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




1,532,704✔





2952



      if (code != TSDB_CODE_SUCCESS) {




1,531,194✔





2953



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




×







2954



        QUERY_CHECK_CODE(code, lino, _end);




×







2955



      }










2956



    }










2957












2958



    if (pInfo->dataReader && hasNext) {




1,532,066✔





2959



      if (isTaskKilled(pTaskInfo)) {




744,312✔





2960



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




×







2961



        return code;




×







2962



      }










2963












2964



      SSDataBlock* pBlock = NULL;




744,312✔





2965



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




744,312✔





2966



      QUERY_CHECK_CODE(code, lino, _end);




743,406✔





2967












2968



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




743,406✔





2969



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




743,406✔





2970



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




743,708✔





2971



        QUERY_CHECK_CODE(code, lino, _end);




742,802✔





2972



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




742,802✔





2973



        (*ppRes) = pBlock;




744,614✔





2974



        return code;




744,312✔





2975



      }










2976



    }










2977












2978



    SMetaTableInfo mtInfo = {0};




788,039✔





2979



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




789,264✔





2980



    QUERY_CHECK_CODE(code, lino, _end);




788,341✔





2981



    if (code != 0) {




788,341✔





2982



      destroyMetaTableInfo(&mtInfo);










2983



      QUERY_CHECK_CODE(code, lino, _end);




×







2984



    }










2985



    STqOffsetVal offset = {0};




788,341✔





2986



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




788,039✔





2987



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




11,555✔





2988



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




11,555✔





2989



    } else {










2990



      SValue val = {0};




777,726✔





2991



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




777,726✔





2992



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




776,803✔





2993



    }










2994



    destroyMetaTableInfo(&mtInfo);










2995



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




789,264✔





2996



    QUERY_CHECK_CODE(code, lino, _end);




789,264✔





2997



    (*ppRes) = NULL;




789,264✔





2998



    return code;




789,264✔





2999



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




5,658✔





3000



    SSnapContext* sContext = pInfo->sContext;




5,658✔





3001



    int64_t st = taosGetTimestampMs();




5,658✔





3002



    for (int32_t i = 0; i < pTaskInfo->streamInfo.minPollRows; i++) {




42,158✔





3003



      void*   data = NULL;




41,462✔





3004



      int32_t dataLen = 0;




41,462✔





3005



      int16_t type = 0;




41,462✔





3006



      int64_t uid = 0;




41,462✔





3007



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




41,462✔





3008



        qError("tmqsnap getTableInfoFromSnapshot error");




×







3009



        taosMemoryFreeClear(data);




×







3010



        break;




×







3011



      }










3012












3013



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




41,462✔





3014



        STqOffsetVal offset = {0};




4,962✔





3015



        SValue       val = {0};




4,962✔





3016



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




×







3017



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




4,962✔





3018



        QUERY_CHECK_CODE(code, lino, _end);




4,962✔





3019



        break;




4,962✔





3020



      } else {










3021



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




36,500✔





3022



        SMqMetaRsp tmpMetaRsp = {0};




36,500✔





3023



        tmpMetaRsp.resMsgType = type;




36,500✔





3024



        tmpMetaRsp.metaRspLen = dataLen;




36,500✔





3025



        tmpMetaRsp.metaRsp = data;




36,500✔





3026



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




36,500✔





3027



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




4,412✔





3028



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




4,412✔





3029












3030



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




4,412✔





3031



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




4,412✔





3032



        }










3033



        int32_t  tempRes = TSDB_CODE_SUCCESS;




36,500✔





3034



        uint32_t len = 0;




36,500✔





3035



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




36,500✔





3036



        if (TSDB_CODE_SUCCESS != tempRes) {




36,225✔





3037



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3038



          taosMemoryFreeClear(data);




×







3039



          break;




×







3040



        }










3041












3042



        int32_t tLen = sizeof(SMqRspHead) + len;




36,225✔





3043



        void*   tBuf = taosMemoryCalloc(1, tLen);




36,225✔





3044



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




36,500✔





3045












3046



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




36,500✔





3047



        SEncoder encoder = {0};




36,500✔





3048



        tEncoderInit(&encoder, metaBuff, len);




36,500✔





3049



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




36,500✔





3050



        if (tempLen < 0) {




36,500✔





3051



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3052



          tEncoderClear(&encoder);




×







3053



          taosMemoryFreeClear(tBuf);




×







3054



          taosMemoryFreeClear(data);




×







3055



          break;




×







3056



        }










3057



        taosMemoryFreeClear(data);




36,500✔





3058



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




36,500✔





3059



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




36,500✔





3060












3061



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




36,500✔





3062



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




36,500✔





3063












3064



        int64_t elapsed = taosGetTimestampMs() - st;




36,500✔





3065



        if (elapsed > pTaskInfo->streamInfo.timeout || elapsed < 0) {




36,500✔





3066



          break;










3067



        }










3068



      }










3069



    }










3070












3071



    (*ppRes) = NULL;




5,658✔





3072



    return code;




5,658✔





3073



  }










3074












3075



_end:




×







3076



  if (code != TSDB_CODE_SUCCESS) {




×







3077



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




×







3078



    pTaskInfo->code = code;




×







3079



    T_LONG_JMP(pTaskInfo->env, code);




×







3080



  }










3081












3082



  (*ppRes) = NULL;




×







3083



  return code;




×







3084



}










3085












3086



static void destroyTmqRawScanOperatorInfo(void* param) {




121,699✔





3087



  SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;




121,699✔





3088



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




121,699✔





3089



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




121,699✔





3090



  tableListDestroy(pRawScan->pTableListInfo);




121,699✔





3091



  taosMemoryFree(pRawScan);




121,699✔





3092



}




121,699✔





3093












3094



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










3095



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










3096



// and schemas are decided when scanning










3097



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




121,699✔





3098



  // create operator










3099



  // create tb reader










3100



  // create meta reader










3101



  // create tq reader










3102












3103



  QRY_PARAM_CHECK(pOptrInfo);




121,699✔





3104



  int32_t code = TSDB_CODE_SUCCESS;




121,699✔





3105



  int32_t lino = 0;




121,699✔





3106












3107



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




121,699✔





3108



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




121,699✔





3109



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




121,699✔





3110



    code = terrno;




×







3111



    lino = __LINE__;




×







3112



    goto _end;




×







3113



  }










3114












3115



  pInfo->pTableListInfo = tableListCreate();




121,699✔





3116



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




121,699✔





3117



  pInfo->vnode = pHandle->vnode;




121,699✔





3118



  pInfo->pAPI = &pTaskInfo->storageAPI;




121,699✔





3119












3120



  pInfo->sContext = pHandle->sContext;




121,699✔





3121



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




121,699✔





3122



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




121,699✔





3123



                  pTaskInfo);










3124












3125



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




121,699✔





3126



                                         NULL, optrDefaultGetNextExtFn, NULL);










3127



  *pOptrInfo = pOperator;




121,699✔





3128



  return code;




121,699✔





3129












3130



_end:




×







3131



  if (code != TSDB_CODE_SUCCESS) {




×







3132



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




×







3133



  }










3134



  taosMemoryFree(pInfo);




×







3135



  taosMemoryFree(pOperator);




×







3136



  pTaskInfo->code = code;




×







3137



  return code;




×







3138



}










3139












3140



void destroyTmqScanOperatorInfo(void* param) {




327,080✔





3141



  if (param == NULL) {




327,080✔





3142



    return;




×







3143



  }










3144












3145



  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;




327,080✔





3146



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




327,080✔





3147



    destroyOperator(pStreamScan->pTableScanOp);




327,080✔





3148



  }










3149












3150



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




327,080✔





3151



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




327,080✔





3152



  }










3153



  if (pStreamScan->pVtableMergeHandles) {




327,080✔





3154



    taosHashCleanup(pStreamScan->pVtableMergeHandles);




×







3155



    pStreamScan->pVtableMergeHandles = NULL;




×







3156



  }










3157



  if (pStreamScan->pVtableMergeBuf) {




327,080✔





3158



    destroyDiskbasedBuf(pStreamScan->pVtableMergeBuf);




×







3159



    pStreamScan->pVtableMergeBuf = NULL;




×







3160



  }










3161



  if (pStreamScan->pVtableReadyHandles) {




327,080✔





3162



    taosArrayDestroy(pStreamScan->pVtableReadyHandles);




×







3163



    pStreamScan->pVtableReadyHandles = NULL;




×







3164



  }










3165



  if (pStreamScan->pTableListInfo) {




327,080✔





3166



    tableListDestroy(pStreamScan->pTableListInfo);




×







3167



    pStreamScan->pTableListInfo = NULL;




×







3168



  }










3169



  if (pStreamScan->pPseudoExpr) {




327,080✔





3170



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




186,817✔





3171



    taosMemoryFree(pStreamScan->pPseudoExpr);




186,817✔





3172



  }










3173












3174



  taosHashCleanup(pStreamScan->pCol2SlotId);




326,803✔





3175



  pStreamScan->pCol2SlotId = NULL;




326,803✔





3176












3177



  cleanupExprSupp(&pStreamScan->tbnameCalSup);




326,803✔





3178



  cleanupExprSupp(&pStreamScan->tagCalSup);




327,080✔





3179












3180



  blockDataDestroy(pStreamScan->pRes);




327,080✔





3181



  blockDataDestroy(pStreamScan->pDeleteDataRes);




327,080✔





3182



  blockDataDestroy(pStreamScan->pUpdateDataRes);




326,803✔





3183



  blockDataDestroy(pStreamScan->pCreateTbRes);




326,752✔





3184



  taosArrayDestroy(pStreamScan->pBlockLists);




326,803✔





3185



  blockDataDestroy(pStreamScan->pCheckpointRes);




327,080✔





3186












3187



  taosMemoryFree(pStreamScan);




326,803✔





3188



}










3189












3190



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




×







3191



  int32_t code = TSDB_CODE_SUCCESS;




×







3192



  int32_t lino = 0;




×







3193



  pBlock->info.rowSize += bytes;




×







3194



  SColumnInfoData infoData = {0};




×







3195



  infoData.info.type = type;




×







3196



  infoData.info.bytes = bytes;




×







3197



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




×







3198



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




×







3199












3200



_end:




×







3201



  if (code != TSDB_CODE_SUCCESS) {




×







3202



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




×







3203



  }










3204



  return code;




×







3205



}










3206












3207



static void getTsSlotId(SNodeList* pNodeList, int32_t* pTsSlotId) {




325,395✔





3208



  size_t  numOfCols = LIST_LENGTH(pNodeList);




325,395✔





3209



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




2,040,465✔





3210



    STargetNode* pNode = (STargetNode*)nodesListGetNode(pNodeList, i);




1,715,070✔





3211



    if (pNode && nodeType(pNode->pExpr) == QUERY_NODE_COLUMN && ((SColumnNode*)pNode->pExpr)->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




1,715,070✔





3212



      *pTsSlotId = pNode->slotId;




327,080✔





3213



    }










3214



  }










3215



}




325,395✔





3216












3217



static int32_t buildCol2SlotId(SNodeList* pNodeList, SHashObj* pCol2SlotId) {




326,038✔





3218



  size_t  numOfCols = LIST_LENGTH(pNodeList);




326,038✔





3219



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




2,040,749✔





3220



    STargetNode* pNode = (STargetNode*)nodesListGetNode(pNodeList, i);




1,713,387✔





3221



    if (pNode == NULL) {




1,714,002✔





3222



      return TSDB_CODE_INVALID_PARA;




×







3223



    }










3224



    if (nodeType(pNode->pExpr) == QUERY_NODE_COLUMN) {




1,714,002✔





3225



      SColumnNode* pColNode = (SColumnNode*)pNode->pExpr;




1,713,669✔





3226



      int32_t code = taosHashPut(pCol2SlotId, (const void*)&pColNode->colId, sizeof(pColNode->colId), (const void*)&pNode->slotId, sizeof(pNode->slotId));




1,713,669✔





3227



      if (code != TSDB_CODE_SUCCESS) {




1,714,378✔





3228



        return code;




×







3229



      }










3230



    }










3231



  }










3232



  return TSDB_CODE_SUCCESS;




327,362✔





3233



}










3234












3235



int32_t createTmqScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,




326,747✔





3236



                                                  SNode* pTagCond, STableListInfo* pTableListInfo,










3237



                                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3238



  QRY_PARAM_CHECK(pOptrInfo);




326,747✔





3239












3240



  int32_t          code = TSDB_CODE_SUCCESS;




327,080✔





3241



  int32_t          lino = 0;




327,080✔





3242



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




327,080✔





3243



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




327,080✔





3244



  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;




326,747✔





3245



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




327,080✔





3246












3247



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




326,747✔





3248



    code = terrno;




284✔





3249



    goto _error;




×







3250



  }










3251












3252



  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;




326,463✔





3253



  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;




326,796✔





3254












3255



  pInfo->pTagCond = pTagCond;




326,463✔





3256



  pInfo->pGroupTags = pTableScanNode->pGroupTags;




327,080✔





3257












3258



  pInfo->primaryTsIndex = -1;




327,080✔





3259



  getTsSlotId(pScanPhyNode->pScanCols, &pInfo->primaryTsIndex);




326,796✔





3260



  pInfo->pCol2SlotId = taosHashInit(LIST_LENGTH(pScanPhyNode->pScanCols), taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_ENTRY_LOCK);




327,080✔





3261



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




326,038✔





3262



  code = buildCol2SlotId(pScanPhyNode->pScanCols, pInfo->pCol2SlotId);




325,730✔





3263



  QUERY_CHECK_CODE(code, lino, _error);




327,080✔





3264












3265



  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pDescNode;




327,080✔





3266



  if (LIST_LENGTH(pNode->pSlots) != LIST_LENGTH(pScanPhyNode->pScanCols) + LIST_LENGTH(pScanPhyNode->pScanPseudoCols)) {




327,080✔





3267



    qError("%s column num mismatch between desc and scan node", __func__);




×







3268



    code = TSDB_CODE_TMQ_INVALID_MSG;




×







3269



    goto _error;




×







3270



  }










3271












3272



  pInfo->pPartTbnameSup = NULL;




326,439✔





3273



  if (pTableScanNode->pSubtable != NULL) {




326,439✔





3274



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




×







3275



    if (pSubTableExpr == NULL) {




×







3276



      code = terrno;




×







3277



      goto _error;




×







3278



    }










3279












3280



    pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;




×







3281



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




×







3282



    QUERY_CHECK_CODE(code, lino, _error);




×







3283












3284



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




×







3285



      goto _error;




×







3286



    }










3287



  }










3288












3289



  if (pTableScanNode->pTags != NULL) {




326,439✔





3290



    int32_t    numOfTags;




×







3291



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




×







3292



    if (pTagExpr == NULL) {




×







3293



      goto _error;




×







3294



    }










3295



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




×







3296



    if (code != 0) {




×







3297



      goto _error;




×







3298



    }










3299



  }










3300












3301



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




326,439✔





3302



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




326,747✔





3303












3304



  SOperatorInfo* pTableScanOp = NULL;




326,439✔





3305



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




326,772✔





3306



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




326,226✔





3307



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




974✔





3308



    goto _error;




×







3309



  }










3310












3311



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




325,252✔





3312



  if (pHandle->version > 0) {




326,131✔





3313



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




325,512✔





3314



  }










3315












3316



  STableKeyInfo* pList = NULL;




326,265✔





3317



  int32_t        num = 0;




326,536✔





3318



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




326,276✔





3319



  QUERY_CHECK_CODE(code, lino, _error);




326,450✔





3320












3321



  if (pHandle->initTableReader) {




326,450✔





3322



    pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;




325,870✔





3323



    pTSInfo->base.dataReader = NULL;




326,498✔





3324



  }










3325












3326



  if (pHandle->initTqReader) {




326,010✔





3327



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




325,432✔





3328



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




327,080✔





3329



  } else {










3330



    pInfo->tqReader = pHandle->tqReader;




×







3331



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




×







3332



  }










3333












3334



  pInfo->pUpdateInfo = NULL;




326,820✔





3335



  pInfo->pTableScanOp = pTableScanOp;




326,820✔





3336












3337



  pInfo->readHandle = *pHandle;




327,080✔





3338



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




326,820✔





3339



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




327,080✔





3340



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




326,772✔





3341



  pInfo->hasPart = false;




326,772✔





3342












3343



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




326,772✔





3344



  QUERY_CHECK_CODE(code, lino, _error);




326,772✔





3345












3346



  SArray* tableIdList = NULL;




326,772✔





3347



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




326,772✔





3348



  QUERY_CHECK_CODE(code, lino, _error);




326,772✔





3349



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




326,772✔





3350



  QUERY_CHECK_CODE(code, lino, _error);




327,080✔





3351



  taosArrayDestroy(tableIdList);




327,080✔





3352



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




327,080✔





3353












3354



  // create the pseduo columns info










3355



  code = createExprInfo(pScanPhyNode->pScanPseudoCols, NULL, &pInfo->pPseudoExpr, &pInfo->numOfPseudoExpr);




327,080✔





3356



  QUERY_CHECK_CODE(code, lino, _error);




326,758✔





3357












3358



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




326,758✔





3359



  QUERY_CHECK_CODE(code, lino, _error);




327,080✔





3360












3361



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




327,080✔





3362



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




327,080✔





3363












3364



  pInfo->groupId = 0;




327,080✔





3365



  pInfo->igCheckGroupId = false;




327,080✔





3366



  pInfo->pStreamScanOp = pOperator;




327,080✔





3367



  pInfo->deleteDataIndex = 0;




327,080✔





3368



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




327,080✔





3369



  QUERY_CHECK_CODE(code, lino, _error);




326,772✔





3370












3371



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




326,772✔





3372



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




326,450✔





3373



  QUERY_CHECK_CODE(code, lino, _error);




327,080✔





3374












3375



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




327,080✔





3376



  pInfo->partitionSup.needCalc = false;




326,757✔





3377



  pInfo->igCheckUpdate = pTableScanNode->igCheckUpdate;




327,080✔





3378



  pInfo->igExpired = pTableScanNode->igExpired;




326,772✔





3379



  pInfo->twAggSup.maxTs = INT64_MIN;




327,080✔





3380



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




326,758✔





3381



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




326,450✔





3382



  pInfo->pFillSup = NULL;




326,758✔





3383



  pInfo->useGetResultRange = false;




326,772✔





3384



  pInfo->pRangeScanRes = NULL;




326,450✔





3385












3386



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




326,450✔





3387



  QUERY_CHECK_CODE(code, lino, _error);




327,080✔





3388












3389



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




327,080✔





3390



                  pTaskInfo);










3391



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




327,080✔





3392












3393



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




326,772✔





3394



                                         NULL, optrDefaultGetNextExtFn, NULL);










3395












3396



  *pOptrInfo = pOperator;




326,772✔





3397



  return code;




326,772✔





3398












3399



_error:




×







3400



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




×







3401



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




×







3402



    if (p != NULL) {




×







3403



      p->base.pTableListInfo = NULL;




×







3404



    }










3405



    destroyTmqScanOperatorInfo(pInfo);




×







3406



  }










3407












3408



  if (pOperator != NULL) {




×







3409



    pOperator->info = NULL;




×







3410



    destroyOperator(pOperator);




×







3411



  }










3412



  pTaskInfo->code = code;




×







3413



  return code;




×







3414



}










3415












3416



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




10,324,269✔





3417



  int32_t        code = TSDB_CODE_SUCCESS;




10,324,269✔





3418



  int32_t        lino = 0;




10,324,269✔





3419



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




10,324,269✔





3420



  STagScanInfo*  pInfo = pOperator->info;




10,325,212✔





3421



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




10,323,552✔





3422



  int32_t        count = pRes->info.rows;




10,323,170✔





3423












3424



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




10,325,212✔





3425



  if (!item) {




10,323,364✔





3426



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




×







3427



           GET_TASKID(pTaskInfo));










3428



    tDecoderClear(&(*mr).coder);




×







3429



    goto _end;




×







3430



  }










3431












3432



  code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid);




10,323,364✔





3433



  tDecoderClear(&(*mr).coder);




10,326,072✔





3434



  if (code != TSDB_CODE_SUCCESS) {




10,325,349✔





3435



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3436



           GET_TASKID(pTaskInfo));










3437



    goto _end;




×







3438



  }










3439












3440



  char str[512];




10,325,253✔





3441



  for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




46,516,501✔





3442



    SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




36,192,968✔





3443












3444



    // refactor later










3445



    if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) {




36,194,243✔





3446



      STR_TO_VARSTR(str, (*mr).me.name);




4,150,257✔





3447



      code = colDataSetVal(pDst, (count), str, false);




4,150,257✔





3448



      QUERY_CHECK_CODE(code, lino, _end);




4,150,980✔





3449



    } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) {




32,042,340✔





3450



      code = colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false);




6,260,828✔





3451



      QUERY_CHECK_CODE(code, lino, _end);




6,260,706✔





3452



    } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) {




25,781,279✔





3453



      code = colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false);




15,598✔





3454



      QUERY_CHECK_CODE(code, lino, _end);




15,598✔





3455



    } else {  // it is a tag value










3456



      STagVal val = {0};




25,766,645✔





3457



      val.cid = pExprInfo[j].base.pParam[0].pCol->colId;




25,769,029✔





3458



      const char* p = pAPI->metaFn.extractTagVal((*mr).me.ctbEntry.pTags, pDst->info.type, &val);




25,770,133✔





3459












3460



      char* data = NULL;




25,768,454✔





3461



      if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {




25,768,454✔





3462



        data = tTagValToData((const STagVal*)p, false);




25,766,476✔





3463



      } else {










3464



        data = (char*)p;




1,395✔





3465



      }










3466












3467



      code = colDataSetVal(pDst, (count), data,




25,768,104✔





3468



                           (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));




25,768,104✔





3469



      QUERY_CHECK_CODE(code, lino, _end);




25,767,008✔





3470












3471



      if ((pDst->info.type != TSDB_DATA_TYPE_JSON) && (p != NULL) && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) &&




25,767,008✔





3472



          (data != NULL)) {










3473



        taosMemoryFree(data);




9,130,864✔





3474



      }










3475



    }










3476



  }










3477












3478



_end:




10,330,005✔





3479



  if (code != TSDB_CODE_SUCCESS) {




10,326,305✔





3480



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3481



    pTaskInfo->code = code;




×







3482



  } else {










3483



    pRes->info.rows++;




10,326,305✔





3484



  }










3485












3486



  return code;




10,325,360✔





3487



}










3488












3489



static void tagScanFreeUidTag(void* p) {




7,214,606✔





3490



  STUidTagInfo* pInfo = p;




7,214,606✔





3491



  if (pInfo->pTagVal != NULL) {




7,214,606✔





3492



    taosMemoryFree(pInfo->pTagVal);




7,214,374✔





3493



  }










3494



}




7,213,307✔





3495












3496



static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) {




1,582,176✔





3497



  SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData));




1,582,176✔





3498



  if (pColumnData == NULL) {




1,581,681✔





3499



    return terrno;




×







3500



  }










3501












3502



  pColumnData->info.type = pType->type;




1,581,681✔





3503



  pColumnData->info.bytes = pType->bytes;




1,581,681✔





3504



  pColumnData->info.scale = pType->scale;




1,576,924✔





3505



  pColumnData->info.precision = pType->precision;




1,579,475✔





3506












3507



  int32_t code = colInfoDataEnsureCapacity(pColumnData, numOfRows, true);




1,578,392✔





3508



  if (code != TSDB_CODE_SUCCESS) {




1,580,726✔





3509



    terrno = code;




×







3510



    taosMemoryFree(pColumnData);




×







3511



    return terrno;




×







3512



  }










3513












3514



  pParam->columnData = pColumnData;




1,580,726✔





3515



  pParam->colAlloced = true;




1,581,108✔





3516



  return TSDB_CODE_SUCCESS;




1,580,958✔





3517



}










3518












3519



static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {




9,788,046✔





3520



  int32_t                code = TSDB_CODE_SUCCESS;




9,788,046✔





3521



  int32_t                lino = 0;




9,788,046✔





3522



  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;




9,788,046✔





3523



  SColumnNode*           pSColumnNode = NULL;




9,788,046✔





3524



  if (QUERY_NODE_COLUMN == nodeType((*pNode))) {




9,787,212✔





3525



    pSColumnNode = *(SColumnNode**)pNode;




2,760,660✔





3526



  } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {




7,028,628✔





3527



    SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);




520✔





3528



    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {




520✔





3529



      pSColumnNode = NULL;




×







3530



      pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);




×







3531



      if (NULL == pSColumnNode) {




×







3532



        return DEAL_RES_ERROR;




×







3533



      }










3534



      pSColumnNode->colId = -1;




×







3535



      pSColumnNode->colType = COLUMN_TYPE_TBNAME;




×







3536



      pSColumnNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




×







3537



      pSColumnNode->node.resType.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;




×







3538



      nodesDestroyNode(*pNode);




×







3539



      *pNode = (SNode*)pSColumnNode;




×







3540



    } else {










3541



      return DEAL_RES_CONTINUE;




520✔





3542



    }










3543



  } else {










3544



    return DEAL_RES_CONTINUE;




7,028,464✔





3545



  }










3546












3547



  void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));




2,762,995✔





3548



  if (!data) {




2,761,498✔





3549



    code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));




1,582,354✔





3550



    if (code == TSDB_CODE_DUP_KEY) {




1,584,214✔





3551



      code = TSDB_CODE_SUCCESS;




×







3552



    }










3553



    QUERY_CHECK_CODE(code, lino, _end);




1,584,214✔





3554



    pSColumnNode->slotId = pCtx->index++;




1,584,214✔





3555



    SColumnInfo cInfo = {.colId = pSColumnNode->colId,




1,584,076✔





3556



                         .type = pSColumnNode->node.resType.type,




1,583,592✔





3557



                         .bytes = pSColumnNode->node.resType.bytes};




1,583,448✔





3558



    void*       tmp = taosArrayPush(pCtx->cInfoList, &cInfo);




1,583,229✔





3559



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,585,272✔





3560



  } else {










3561



    SColumnNode* col = *(SColumnNode**)data;




1,179,144✔





3562



    pSColumnNode->slotId = col->slotId;




1,178,660✔





3563



  }










3564












3565



_end:




2,760,610✔





3566



  if (code != TSDB_CODE_SUCCESS) {




2,761,253✔





3567



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




712✔





3568



    return DEAL_RES_ERROR;




×







3569



  }










3570



  return DEAL_RES_CONTINUE;




2,760,541✔





3571



}










3572












3573



static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode,




1,582,176✔





3574



                                      SStorageAPI* pAPI, STagScanInfo* pInfo, void* pStreamRuntimeInfo) {










3575



  int32_t code = TSDB_CODE_SUCCESS;




1,582,176✔





3576



  int32_t lino = 0;




1,582,176✔





3577



  int32_t numOfTables = taosArrayGetSize(aUidTags);




1,582,176✔





3578



  SArray* pBlockList = NULL;




1,582,176✔





3579












3580



  SSDataBlock* pResBlock = createTagValBlockForFilter(pInfo->filterCtx.cInfoList, numOfTables, aUidTags, pVnode, pAPI);




1,582,176✔





3581



  QUERY_CHECK_NULL(pResBlock, code, lino, _end, terrno);




1,579,843✔





3582












3583



  pBlockList = taosArrayInit(1, POINTER_BYTES);




1,579,843✔





3584



  QUERY_CHECK_NULL(pBlockList, code, lino, _end, terrno);




1,580,806✔





3585












3586



  void* tmp = taosArrayPush(pBlockList, &pResBlock);




1,581,820✔





3587



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,581,820✔





3588












3589



  SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)};




1,581,820✔





3590












3591



  SScalarParam output = {0};




1,580,338✔





3592



  code = tagScanCreateResultData(&type, numOfTables, &output);




1,581,442✔





3593



  QUERY_CHECK_CODE(code, lino, _end);




1,581,314✔





3594












3595



  gTaskScalarExtra.pStreamInfo = (void*)pStreamRuntimeInfo;




1,581,314✔





3596



  gTaskScalarExtra.pStreamRange = NULL;




1,581,314✔





3597



  code = scalarCalculate(pTagCond, pBlockList, &output, &gTaskScalarExtra);




1,581,108✔





3598



  QUERY_CHECK_CODE(code, lino, _end);




1,578,663✔





3599












3600



  bool* result = (bool*)output.columnData->pData;




1,578,663✔





3601



  for (int32_t i = 0; i < numOfTables; ++i) {




3,951,857✔





3602



    if (result[i]) {




2,372,002✔





3603



      void* tmp = taosArrayPush(aFilterIdxs, &i);




2,215,920✔





3604



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




2,215,920✔





3605



    }










3606



  }










3607












3608



  colDataDestroy(output.columnData);




1,582,176✔





3609



  taosMemoryFreeClear(output.columnData);




1,577,841✔





3610












3611



_end:




1,575,902✔





3612



  blockDataDestroy(pResBlock);




1,577,333✔





3613



  taosArrayDestroy(pBlockList);




1,576,431✔





3614



  if (code != TSDB_CODE_SUCCESS) {




1,576,264✔





3615



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3616



  }










3617



  return code;




1,576,264✔





3618



}










3619












3620



static int32_t tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo,




29,394,444✔





3621



                                         SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex,










3622



                                         const SStorageAPI* pAPI, void* pVnode) {










3623



  int32_t code = TSDB_CODE_SUCCESS;




29,394,444✔





3624



  int32_t lino = 0;




29,394,444✔





3625



  if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) {




29,394,444✔





3626



    if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) {  // tbname




14,006,436✔





3627



      char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×







3628



      STR_TO_VARSTR(str, "ctbidx");




×







3629












3630



      code = colDataSetVal(pColInfo, rowIndex, str, false);




×







3631



      QUERY_CHECK_CODE(code, lino, _end);




×







3632



    } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) {




14,001,913✔





3633



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false);




6,997,565✔





3634



      QUERY_CHECK_CODE(code, lino, _end);




7,002,661✔





3635



    } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) {




7,004,155✔





3636



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false);




7,002,237✔





3637



      QUERY_CHECK_CODE(code, lino, _end);




7,003,177✔





3638



    }










3639



  } else {










3640



    STagVal tagVal = {0};




15,384,632✔





3641



    tagVal.cid = pExprInfo->base.pParam[0].pCol->colId;




15,386,963✔





3642



    if (pUidTagInfo->pTagVal == NULL) {




15,388,769✔





3643



      colDataSetNULL(pColInfo, rowIndex);




×







3644



    } else {










3645



      const char* p = pAPI->metaFn.extractTagVal(pUidTagInfo->pTagVal, pColInfo->info.type, &tagVal);




15,381,924✔





3646












3647



      if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {




15,388,808✔





3648



        colDataSetNULL(pColInfo, rowIndex);




5,864✔





3649



      } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {




15,383,072✔





3650



        code = colDataSetVal(pColInfo, rowIndex, p, false);




×







3651



        QUERY_CHECK_CODE(code, lino, _end);




×







3652



      } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {




19,283,764✔





3653



        if (IS_STR_DATA_BLOB(pColInfo->info.type)) {




3,911,871✔





3654



          QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_TAG, lino, _end);




×







3655



        }










3656



        char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);




3,911,783✔





3657



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




3,909,374✔





3658












3659



        varDataSetLen(tmp, tagVal.nData);




3,909,374✔





3660



        memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);




3,908,374✔





3661



        code = colDataSetVal(pColInfo, rowIndex, tmp, false);




3,906,073✔





3662



        taosMemoryFree(tmp);




3,905,433✔





3663



        QUERY_CHECK_CODE(code, lino, _end);




3,909,592✔





3664



      } else {










3665



        code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false);




11,457,951✔





3666



        QUERY_CHECK_CODE(code, lino, _end);




11,466,057✔





3667



      }










3668



    }










3669



  }










3670












3671



_end:




29,386,184✔





3672



  if (code != TSDB_CODE_SUCCESS) {




29,386,184✔





3673



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3674



  }










3675



  return code;




29,383,363✔





3676



}










3677












3678



static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags,




4,612,462✔





3679



                                      SArray* aFilterIdxs, bool ignoreFilterIdx, SStorageAPI* pAPI) {










3680



  int32_t       code = TSDB_CODE_SUCCESS;




4,612,462✔





3681



  int32_t       lino = 0;




4,612,462✔





3682



  STagScanInfo* pInfo = pOperator->info;




4,612,462✔





3683



  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];




4,614,196✔





3684



  if (!ignoreFilterIdx) {




4,610,398✔





3685



    size_t szTables = taosArrayGetSize(aFilterIdxs);




1,577,206✔





3686



    for (int i = 0; i < szTables; ++i) {




3,789,368✔





3687



      int32_t       idx = *(int32_t*)taosArrayGet(aFilterIdxs, i);




2,212,789✔





3688



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);




2,213,266✔





3689



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




2,209,827✔





3690



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




12,638,071✔





3691



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




10,425,237✔





3692



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




10,431,290✔





3693



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




10,431,290✔





3694



        QUERY_CHECK_CODE(code, lino, _end);




10,428,244✔





3695



      }










3696



    }










3697



  } else {










3698



    size_t szTables = taosArrayGetSize(aUidTags);




3,033,192✔





3699



    for (int i = 0; i < szTables; ++i) {




7,883,304✔





3700



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);




4,849,116✔





3701



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




4,849,116✔





3702



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




23,799,898✔





3703



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




18,950,901✔





3704



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




18,954,209✔





3705



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




18,954,209✔





3706



        QUERY_CHECK_CODE(code, lino, _end);




18,950,782✔





3707



      }










3708



    }










3709



  }










3710












3711



_end:




3,034,188✔





3712



  if (code != TSDB_CODE_SUCCESS) {




4,610,767✔





3713



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3714



  }










3715



  return code;




4,616,119✔





3716



}










3717












3718



static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




9,192,333✔





3719



  int32_t        code = TSDB_CODE_SUCCESS;




9,192,333✔





3720



  int32_t        lino = 0;




9,192,333✔





3721



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,192,333✔





3722



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




9,191,767✔





3723












3724



  STagScanInfo* pInfo = pOperator->info;




9,189,417✔





3725



  SSDataBlock*  pRes = pInfo->pRes;




9,189,901✔





3726












3727



  QRY_PARAM_CHECK(ppRes);




9,186,455✔





3728












3729



  if (pOperator->status == OP_EXEC_DONE) {




9,188,525✔





3730



    return TSDB_CODE_SUCCESS;




4,501,032✔





3731



  }










3732



  blockDataCleanup(pRes);




4,689,341✔





3733












3734



  if (pInfo->pCtbCursor == NULL) {




4,690,043✔





3735



    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);




4,690,224✔





3736



    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);




4,691,256✔





3737



  } else {










3738



    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);




×







3739



    QUERY_CHECK_CODE(code, lino, _end);




×







3740



  }










3741












3742



  SArray* aUidTags = pInfo->aUidTags;




4,690,772✔





3743



  SArray* aFilterIdxs = pInfo->aFilterIdxs;




4,691,968✔





3744



  int32_t count = 0;




4,688,016✔





3745



  bool    ctbCursorFinished = false;




4,688,016✔





3746



  while (1) {




101,488✔





3747



    taosArrayClearEx(aUidTags, tagScanFreeUidTag);




4,789,504✔





3748



    taosArrayClear(aFilterIdxs);




4,793,412✔





3749












3750



    int32_t numTables = 0;




4,793,594✔





3751



    while (numTables < pOperator->resultInfo.capacity) {




12,017,004✔





3752



      SMCtbCursor* pCur = pInfo->pCtbCursor;




12,010,529✔





3753



      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);




12,011,551✔





3754



      if (uid == 0) {




12,011,034✔





3755



        ctbCursorFinished = true;




4,793,950✔





3756



        break;




4,793,950✔





3757



      }










3758



      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};




7,217,084✔





3759



      info.pTagVal = taosMemoryMalloc(pCur->vLen);




7,216,597✔





3760



      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);




7,213,291✔





3761












3762



      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);




7,213,291✔





3763



      void* tmp = taosArrayPush(aUidTags, &info);




7,218,676✔





3764



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




7,218,676✔





3765



      ++numTables;




7,218,676✔





3766



    }










3767












3768



    if (numTables == 0) {




4,793,950✔





3769



      break;




176,848✔





3770



    }










3771



    bool ignoreFilterIdx = true;




4,617,102✔





3772



    if (pInfo->pTagCond != NULL) {




4,617,102✔





3773



      ignoreFilterIdx = false;




1,582,176✔





3774



      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo, pTaskInfo->pStreamRuntimeInfo);




1,582,176✔





3775



      QUERY_CHECK_CODE(code, lino, _end);




1,578,594✔





3776



    } else {










3777



      ignoreFilterIdx = true;




3,034,563✔





3778



    }










3779












3780



    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);




4,613,157✔





3781



    QUERY_CHECK_CODE(code, lino, _end);




4,616,247✔





3782












3783



    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);




4,616,247✔





3784












3785



    if (count != 0) {




4,615,397✔





3786



      break;




4,513,909✔





3787



    }










3788



  }










3789












3790



  if (count > 0) {




4,690,757✔





3791



    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);




4,513,287✔





3792



  }










3793



  if (count == 0 || ctbCursorFinished) {




4,690,554✔





3794



    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




4,690,554✔





3795



    pInfo->pCtbCursor = NULL;




4,687,450✔





3796



    setOperatorCompleted(pOperator);




4,686,966✔





3797



  }










3798












3799



  pRes->info.rows = count;




4,687,425✔





3800



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




4,688,283✔





3801



  if (bLimitReached) {




4,687,993✔





3802



    setOperatorCompleted(pOperator);




×







3803



  }










3804












3805



  pOperator->resultInfo.totalRows += pRes->info.rows;




4,687,993✔





3806



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




4,689,310✔





3807












3808



_end:




4,683,963✔





3809



  if (code != TSDB_CODE_SUCCESS) {




4,683,963✔





3810



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3811



    pTaskInfo->code = code;




×







3812



    T_LONG_JMP(pTaskInfo->env, code);




×







3813



  }










3814












3815



  return code;




4,683,963✔





3816



}










3817












3818



static int32_t createTagScanTableListInfoFromParam(SOperatorInfo* pOperator) {




3,361,839✔





3819



  STagScanInfo*          pInfo = pOperator->info;




3,361,839✔





3820



  SExecTaskInfo*         pTaskInfo = pOperator->pTaskInfo;




3,361,839✔





3821



  int32_t                code = 0;




3,361,839✔





3822



  STableListInfo*        pListInfo = pInfo->pTableListInfo;




3,361,839✔





3823



  STagScanOperatorParam* pParam = (STagScanOperatorParam*)pOperator->pOperatorGetParam->value;




3,361,839✔





3824



  tb_uid_t               pUid = pParam->vcUid;




3,361,839✔





3825












3826



  // qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",










3827



  //        pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList),










3828



  //        pOperator->status);










3829












3830



  STableKeyInfo info = {.groupId = 0};




3,361,839✔





3831












3832



  int32_t tableIdx = 0;




3,361,839✔





3833



  taosHashClear(pListInfo->map);




3,361,839✔





3834



  taosArrayClear(pListInfo->pTableList);




3,361,839✔





3835












3836



  if (taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {




3,361,839✔





3837



    if (TSDB_CODE_DUP_KEY == terrno) {




×







3838



    } else {










3839



      return terrno;




×







3840



    }










3841



  }










3842












3843



  info.uid = pUid;




3,361,839✔





3844



  void* p = taosArrayPush(pListInfo->pTableList, &info);




3,361,839✔





3845



  if (p == NULL) {




3,361,839✔





3846



    return terrno;




×







3847



  }










3848












3849



  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));




3,361,839✔





3850












3851



  return code;




3,361,839✔





3852



}










3853












3854



static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




7,408,264✔





3855



  int32_t       code = TSDB_CODE_SUCCESS;




7,408,264✔





3856



  int32_t       lino = 0;




7,408,264✔





3857



  STagScanInfo* pInfo = pOperator->info;




7,408,264✔





3858



  if (pOperator->pOperatorGetParam) {




7,408,264✔





3859



    pOperator->resultInfo.totalRows = 0;




3,361,839✔





3860



    pOperator->dynamicTask = true;




3,361,839✔





3861



    pInfo->curPos = 0;




3,361,839✔





3862



    code = createTagScanTableListInfoFromParam(pOperator);




3,361,839✔





3863



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




3,361,839✔





3864



    pOperator->pOperatorGetParam = NULL;




3,361,839✔





3865



    QUERY_CHECK_CODE(code, lino, _end);




3,361,839✔





3866












3867



    if (pOperator->status == OP_EXEC_DONE) {




3,361,839✔





3868



      pOperator->status = OP_OPENED;




1,778,529✔





3869



    }










3870



  }










3871












3872



  if (pOperator->status == OP_EXEC_DONE) {




7,405,486✔





3873



    (*ppRes) = NULL;




2,008,789✔





3874



    return code;




2,008,789✔





3875



  }










3876












3877



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




5,398,879✔





3878



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




5,395,517✔





3879












3880



  SExprInfo*   pExprInfo = &pOperator->exprSupp.pExprInfo[0];




5,396,684✔





3881



  SSDataBlock* pRes = pInfo->pRes;




5,399,475✔





3882



  blockDataCleanup(pRes);




5,399,107✔





3883












3884



  int32_t size = 0;




5,399,473✔





3885



  code = tableListGetSize(pInfo->pTableListInfo, &size);




5,399,473✔





3886



  QUERY_CHECK_CODE(code, lino, _end);




5,399,107✔





3887












3888



  if (size == 0) {




5,399,107✔





3889



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




18,980✔





3890



    (*ppRes) = NULL;




18,980✔





3891



    return code;




18,980✔





3892



  }










3893












3894



  SMetaReader mr = {0};




5,380,127✔





3895



  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




5,380,127✔





3896



  pRes->info.rows = 0;




5,378,453✔





3897












3898



  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {




15,701,993✔





3899



    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);




10,324,232✔





3900



    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD &&




10,325,922✔





3901



        code != TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED) {










3902



      // ignore other error










3903



      code = TSDB_CODE_SUCCESS;




10,326,412✔





3904



    }










3905



    QUERY_CHECK_CODE(code, lino, _end);




10,325,922✔





3906












3907



    if (++pInfo->curPos >= size) {




10,325,922✔





3908



      setOperatorCompleted(pOperator);




5,380,850✔





3909



    }










3910



  }










3911












3912



  pAPI->metaReaderFn.clearReader(&mr);




5,379,542✔





3913



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




5,380,850✔





3914



  if (bLimitReached) {




5,380,495✔





3915



    setOperatorCompleted(pOperator);




×







3916



  }










3917












3918



  // qDebug("QInfo:0x%" PRIx64 ", create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);










3919



  if (pOperator->status == OP_EXEC_DONE) {




5,380,495✔





3920



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




5,380,850✔





3921



  }










3922












3923



  pOperator->resultInfo.totalRows += pRes->info.rows;




5,380,495✔





3924












3925



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




5,380,495✔





3926



_end:




5,380,850✔





3927



  if (code != TSDB_CODE_SUCCESS) {




5,380,850✔





3928



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3929



    pTaskInfo->code = code;




×







3930



    T_LONG_JMP(pTaskInfo->env, code);




×







3931



  }










3932



  return code;




5,380,850✔





3933



}










3934












3935



static void destroyTagScanOperatorInfo(void* param) {




8,647,038✔





3936



  STagScanInfo* pInfo = (STagScanInfo*)param;




8,647,038✔





3937



  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {




8,647,038✔





3938



    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




×







3939



  }










3940



  taosHashCleanup(pInfo->filterCtx.colHash);




8,648,473✔





3941



  taosArrayDestroy(pInfo->filterCtx.cInfoList);




8,631,840✔





3942



  taosArrayDestroy(pInfo->aFilterIdxs);




8,627,426✔





3943



  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);




8,626,670✔





3944












3945



  blockDataDestroy(pInfo->pRes);




8,641,977✔





3946



  taosArrayDestroy(pInfo->matchInfo.pList);




8,642,658✔





3947



  tableListDestroy(pInfo->pTableListInfo);




8,636,140✔





3948












3949



  pInfo->pRes = NULL;




8,643,163✔





3950



  pInfo->pTableListInfo = NULL;




8,643,159✔





3951



  taosMemoryFreeClear(param);




8,644,021✔





3952



}




8,646,837✔





3953












3954



static int32_t resetTagScanOperatorState(SOperatorInfo* pOper) {




4,780✔





3955



  int32_t         code = TSDB_CODE_SUCCESS;




4,780✔





3956



  STagScanInfo*   pInfo = pOper->info;




4,780✔





3957












3958



  pOper->status = OP_NOT_OPENED;




4,780✔





3959



  STagScanPhysiNode* pTagScanNode = (STagScanPhysiNode*)pOper->pPhyNode;




4,780✔





3960



  if (pTagScanNode->onlyMetaCtbIdx) {




4,780✔





3961



      SExecTaskInfo* pTaskInfo = pOper->pTaskInfo;




2,080✔





3962



      SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




2,080✔





3963



      pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




2,080✔





3964



      pInfo->pCtbCursor = NULL;




2,080✔





3965



  } else {










3966



      pInfo->curPos = 0;




2,700✔





3967



  }










3968












3969



  return code;




4,780✔





3970



}










3971












3972



int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,




8,648,409✔





3973



                                  STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond,










3974



                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3975



  QRY_PARAM_CHECK(pOptrInfo);




8,648,409✔





3976












3977



  int32_t         code = TSDB_CODE_SUCCESS;




8,650,888✔





3978



  int32_t         lino = 0;




8,650,888✔





3979



  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;




8,650,888✔





3980



  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));




8,650,888✔





3981



  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




8,638,440✔





3982



  if (pInfo == NULL || pOperator == NULL) {




8,636,306✔





3983



    code = terrno;




×







3984



    goto _error;




×







3985



  }










3986



  pOperator->pPhyNode = pTagScanNode;




8,636,306✔





3987



  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;




8,640,450✔





3988












3989



  int32_t    numOfExprs = 0;




8,639,944✔





3990



  SExprInfo* pExprInfo = NULL;




8,640,327✔





3991












3992



  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);




8,641,614✔





3993



  QUERY_CHECK_CODE(code, lino, _error);




8,643,578✔





3994












3995



  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);




8,643,578✔





3996



  QUERY_CHECK_CODE(code, lino, _error);




8,642,797✔





3997












3998



  int32_t num = 0;




8,642,797✔





3999



  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




8,640,939✔





4000



  QUERY_CHECK_CODE(code, lino, _error);




8,641,677✔





4001












4002



  pInfo->pTagCond = pTagCond;




8,641,677✔





4003



  pInfo->pTagIndexCond = pTagIndexCond;




8,644,460✔





4004



  pInfo->suid = pPhyNode->suid;




8,638,525✔





4005



  pInfo->pStorageAPI = &pTaskInfo->storageAPI;




8,632,330✔





4006












4007



  pInfo->pTableListInfo = pTableListInfo;




8,613,531✔





4008



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




8,640,487✔





4009



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




8,646,951✔





4010












4011



  pInfo->readHandle = *pReadHandle;




8,631,482✔





4012



  pInfo->curPos = 0;




8,645,186✔





4013












4014



  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);




8,626,455✔





4015



  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,




8,635,887✔





4016



                  pTaskInfo);










4017



  initResultSizeInfo(&pOperator->resultInfo, 4096);




8,624,367✔





4018



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




8,642,175✔





4019



  QUERY_CHECK_CODE(code, lino, _error);




8,648,911✔





4020












4021



  if (pTagScanNode->onlyMetaCtbIdx) {




8,648,911✔





4022



    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));




4,697,745✔





4023



    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);




4,698,496✔





4024












4025



    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));




4,697,656✔





4026



    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);




4,698,496✔





4027












4028



    pInfo->filterCtx.colHash =




4,696,322✔





4029



        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);




4,697,656✔





4030



    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);




4,696,816✔





4031












4032



    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));




4,697,268✔





4033



    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);




4,696,178✔





4034












4035



    if (pInfo->pTagCond != NULL) {




4,695,959✔





4036



      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);




1,584,081✔





4037



    }










4038



  }










4039



  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;




8,649,294✔





4040



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,




8,651,945✔





4041



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










4042



  setOperatorResetStateFn(pOperator, resetTagScanOperatorState);     




8,646,633✔





4043



  










4044



  *pOptrInfo = pOperator;




8,650,527✔





4045



  return code;




8,639,332✔





4046












4047



_error:




×







4048



  if (pInfo) {




×







4049



    pInfo->pTableListInfo = NULL;




×







4050



  }










4051












4052



  if (pInfo != NULL) destroyTagScanOperatorInfo(pInfo);




×







4053



  if (pOperator != NULL) {




×







4054



    pOperator->info = NULL;




×







4055



    destroyOperator(pOperator);




×







4056



  }










4057



  return code;




×







4058



}










4059












4060



// table merge scan operator










4061












4062



static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {




241,847,580✔





4063



  int32_t                 left = *(int32_t*)pLeft;




241,847,580✔





4064



  int32_t                 right = *(int32_t*)pRight;




241,848,669✔





4065



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




241,848,306✔





4066












4067



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




241,848,306✔





4068



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




241,851,573✔





4069












4070



  if (leftIdx == -1) {




241,851,573✔





4071



    return 1;




207,333,813✔





4072



  } else if (rightIdx == -1) {




34,517,760✔





4073



    return -1;




341,760✔





4074



  }










4075












4076



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




34,176,000✔





4077



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




34,176,000✔





4078



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




34,176,000✔





4079



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




34,176,000✔





4080



    ret = -1 * ret;




×







4081



  }










4082



  return ret;




34,176,000✔





4083



}










4084












4085



static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) {




×







4086



  int32_t                 left = *(int32_t*)pLeft;




×







4087



  int32_t                 right = *(int32_t*)pRight;




×







4088



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




×







4089












4090



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




×







4091



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




×







4092












4093



  if (leftIdx == -1) {




×







4094



    return 1;




×







4095



  } else if (rightIdx == -1) {




×







4096



    return -1;




×







4097



  }










4098












4099



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




×







4100



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




×







4101



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




×







4102



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




×







4103



    ret = -1 * ret;




×







4104



  }










4105



  if (ret == 0 && pInfo->pPkOrderInfo) {




×







4106



    ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx,




×







4107



                               pInfo->pPkOrderInfo);




×







4108



  }










4109



  return ret;




×







4110



}










4111












4112



int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {




3,064,729✔





4113



  int32_t code = TSDB_CODE_SUCCESS;




3,064,729✔





4114



  int32_t lino = 0;




3,064,729✔





4115



  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));




3,064,729✔





4116



  dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));




3,064,729✔





4117



  QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);




3,060,045✔





4118



  for (int i = 0; i < src->numOfCols; i++) {




10,371,628✔





4119



    dst->colList[i] = src->colList[i];




7,334,053✔





4120



  }










4121












4122



_end:




3,067,975✔





4123



  if (code != TSDB_CODE_SUCCESS) {




3,067,975✔





4124



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4125



  }










4126



  return code;




3,065,783✔





4127



}










4128












4129



static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,




4,613,124✔





4130



                                                bool* pSubTableHasBlock) {










4131



  int32_t code = 0;




4,613,124✔





4132












4133



  STableMergeScanInfo*    pInfo = pOperator->info;




4,613,124✔





4134



  SReadHandle*            pHandle = &pInfo->base.readHandle;




4,612,768✔





4135



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




4,613,124✔





4136



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




4,612,035✔





4137



  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;




4,608,454✔





4138












4139



  blockDataCleanup(pInput->pReaderBlock);




4,607,372✔





4140



  if (!pInput->bInMemReader) {




4,610,625✔





4141



    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,




4,623,884✔





4142



                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




2,311,059✔





4143



    if (code != 0) {




2,309,251✔





4144



      return code;




×







4145



    }










4146



  }










4147












4148



  pInfo->base.dataReader = pInput->pReader;




4,608,468✔





4149












4150



  while (true) {




5,808✔





4151



    bool hasNext = false;




4,614,611✔





4152



    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);




4,614,255✔





4153



    if (code != 0) {




4,620,007✔





4154



      pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4155



      pInfo->base.dataReader = NULL;




×







4156



      return code;




×







4157



    }










4158












4159



    if (!hasNext || isTaskKilled(pTaskInfo)) {




4,620,007✔





4160



      if (isTaskKilled(pTaskInfo)) {




3,077,587✔





4161



        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4162



        pInfo->base.dataReader = NULL;




×







4163



        return code;




×







4164



      }










4165












4166



      *pSubTableHasBlock = false;




3,077,950✔





4167



      break;




3,077,950✔





4168



    }










4169












4170



    if (pInput->tblCond.order == TSDB_ORDER_ASC) {




1,542,420✔





4171



      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;




1,516,284✔





4172



    } else {










4173



      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;




26,136✔





4174



    }










4175












4176



    uint32_t status = 0;




1,542,420✔





4177



    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);




1,542,420✔





4178



    if (code != 0) {




1,542,420✔





4179



      pInfo->base.dataReader = NULL;




×







4180



      return code;




×







4181



    }










4182












4183



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




1,542,420✔





4184



      *pSubTableHasBlock = false;




×







4185



      break;




×







4186



    }










4187



    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {




1,542,420✔





4188



      continue;




5,808✔





4189



    }










4190












4191



    *pSubTableHasBlock = true;




1,536,612✔





4192



    break;




1,536,612✔





4193



  }










4194












4195



  if (*pSubTableHasBlock) {




4,615,288✔





4196



    pInput->pReaderBlock->info.id.groupId =




3,072,861✔





4197



        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);




3,073,224✔





4198



    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;




1,536,249✔





4199



  }










4200



  if (!pInput->bInMemReader || !*pSubTableHasBlock) {




4,613,850✔





4201



    pAPI->tsdReader.tsdReaderClose(pInput->pReader);




3,466,409✔





4202



    pInput->pReader = NULL;




3,464,650✔





4203



  }










4204












4205



  pInfo->base.dataReader = NULL;




4,613,501✔





4206



  return TSDB_CODE_SUCCESS;




4,613,152✔





4207



}










4208












4209



static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {




1,913,993✔





4210



  pInfo->bGroupProcessed = false;




1,913,993✔





4211












4212



  int32_t numOfTables = 0;




1,916,129✔





4213



  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




1,890,741✔





4214



  if (code != TSDB_CODE_SUCCESS) {




1,894,308✔





4215



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4216



    return code;




×







4217



  }










4218












4219



  int32_t i = pInfo->tableStartIndex + 1;




1,894,308✔





4220



  for (; i < numOfTables; ++i) {




3,046,796✔





4221



    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




1,208,304✔





4222



    if (!tableKeyInfo) {




1,202,496✔





4223



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4224



      return terrno;




×







4225



    }










4226



    if (tableKeyInfo->groupId != pInfo->groupId) {




1,202,496✔





4227



      break;




57,240✔





4228



    }










4229



  }










4230



  pInfo->tableEndIndex = i - 1;




1,895,732✔





4231



  return TSDB_CODE_SUCCESS;




1,918,621✔





4232



}










4233












4234



static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {




1,924,722✔





4235



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,999,831✔





4236



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,077,594✔





4237



    if (pInput->rowIdx == -1) {




3,074,732✔





4238



      continue;




1,539,928✔





4239



    }










4240












4241



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,535,886✔





4242



      pInput->rowIdx = 0;




1,536,249✔





4243



      pInput->pageIdx = -1;




1,536,612✔





4244



    }










4245












4246



    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,535,160✔





4247



    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




1,535,886✔





4248



    if (!col) {




1,535,893✔





4249



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4250



      return terrno;




×







4251



    }










4252



    pInput->aTs = (int64_t*)col->pData;




1,535,893✔





4253



  }










4254












4255



  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;




1,923,305✔





4256



  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);




1,924,722✔





4257



}










4258












4259



static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {




1,913,623✔





4260



  int32_t code = setGroupStartEndIndex(pInfo);




1,913,623✔





4261



  if (code != TSDB_CODE_SUCCESS) {




1,912,855✔





4262



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4263



    return code;




×







4264



  }










4265



  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));




1,912,855✔





4266



  if (pSubTblsInfo == NULL) {




1,897,491✔





4267



    return terrno;




×







4268



  }










4269



  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);




1,897,491✔





4270



  if (!pSubTblsInfo->pTsOrderInfo) {




1,910,049✔





4271



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4272



    return terrno;




×







4273



  }










4274



  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {




1,891,013✔





4275



    pSubTblsInfo->pPkOrderInfo = taosArrayGet(pInfo->pSortInfo, 1);




×







4276



    if (!pSubTblsInfo->pPkOrderInfo) {




×







4277



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4278



      return terrno;




×







4279



    }










4280



  } else {










4281



    pSubTblsInfo->pPkOrderInfo = NULL;




1,894,964✔





4282



  }










4283



  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




1,911,857✔





4284



  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));




1,910,056✔





4285



  if (pSubTblsInfo->aInputs == NULL) {




1,882,874✔





4286



    taosMemoryFree(pSubTblsInfo);




×







4287



    return terrno;




×







4288



  }










4289



  int32_t bufPageSize = pInfo->bufPageSize;




1,905,072✔





4290



  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;




1,907,222✔





4291



  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);




1,906,147✔





4292



  if (code != TSDB_CODE_SUCCESS) {




1,893,959✔





4293



    taosMemoryFree(pSubTblsInfo->aInputs);




×







4294



    taosMemoryFree(pSubTblsInfo);




×







4295



    return code;




×







4296



  }










4297



  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;




1,893,959✔





4298



  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;




1,911,857✔





4299












4300



  pInfo->pSubTablesMergeInfo = pSubTblsInfo;




1,916,883✔





4301



  return TSDB_CODE_SUCCESS;




1,889,345✔





4302



}










4303












4304



static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {




1,911,864✔





4305



  int32_t        code = TSDB_CODE_SUCCESS;




1,911,864✔





4306



  int32_t        lino = 0;




1,911,864✔





4307



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,911,864✔





4308



  SReadHandle*   pHandle = &pInfo->base.readHandle;




1,913,302✔





4309



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,899,704✔





4310












4311



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




1,893,945✔





4312












4313



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,990,547✔





4314



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,065,804✔





4315



    pInput->type = SUB_TABLE_MEM_BLOCK;




3,051,829✔





4316












4317



    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);




3,049,986✔





4318



    QUERY_CHECK_CODE(code, lino, _end);




3,064,722✔





4319












4320



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);




3,064,722✔





4321



    QUERY_CHECK_CODE(code, lino, _end);




3,072,938✔





4322












4323



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);




3,072,938✔





4324



    QUERY_CHECK_CODE(code, lino, _end);




3,079,032✔





4325












4326



    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);




3,079,032✔





4327



    pInput->pKeyInfo = keyInfo;




3,077,252✔





4328












4329



    if (isTaskKilled(pTaskInfo)) {




3,077,608✔





4330



      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);




×







4331



    }










4332












4333



    if (i + 1 < pSubTblsInfo->numInMemReaders) {




3,066,118✔





4334



      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,




2,302,128✔





4335



                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




1,151,790✔





4336



      QUERY_CHECK_CODE(code, lino, _end);




1,150,701✔





4337



      pInput->bInMemReader = true;




1,150,701✔





4338



    } else {










4339



      pInput->pReader = NULL;




1,923,298✔





4340



      pInput->bInMemReader = false;




1,925,085✔





4341



    }










4342



    bool hasNext = true;




3,075,053✔





4343



    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);




3,075,430✔





4344



    QUERY_CHECK_CODE(code, lino, _end);




3,077,601✔





4345



    if (!hasNext) {




3,077,601✔





4346



      pInput->rowIdx = -1;




1,540,989✔





4347



      ++pSubTblsInfo->numSubTablesCompleted;




1,540,640✔





4348



      continue;




1,541,352✔





4349



    } else {










4350



      pInput->rowIdx = 0;




1,536,612✔





4351



      pInput->pageIdx = -1;




1,536,612✔





4352



    }










4353



  }










4354












4355



_end:




1,925,797✔





4356



  if (code != TSDB_CODE_SUCCESS) {




1,926,153✔





4357



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4358



  }










4359



  return code;




1,925,078✔





4360



}










4361












4362



static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




1,536,612✔





4363



  int32_t              code = TSDB_CODE_SUCCESS;




1,536,612✔





4364



  int32_t              lino = 0;




1,536,612✔





4365



  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;




1,536,612✔





4366



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




1,536,612✔





4367



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




1,536,612✔





4368



  bool                 hasNext = true;




1,536,612✔





4369



  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);




1,536,612✔





4370



  QUERY_CHECK_CODE(code, lino, _end);




1,536,612✔





4371












4372



  if (!hasNext) {




1,536,612✔





4373



    pInput->rowIdx = -1;




1,536,612✔





4374



    ++pSubTblsInfo->numSubTablesCompleted;




1,536,612✔





4375



  } else {










4376



    pInput->rowIdx = 0;




×







4377



  }










4378












4379



_end:




1,536,612✔





4380



  if (code != TSDB_CODE_SUCCESS) {




1,536,612✔





4381



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4382



    pTaskInfo->code = code;




×







4383



    T_LONG_JMP(pTaskInfo->env, code);




×







4384



  }










4385



}




1,536,612✔





4386












4387



static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




279,784,566✔





4388



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




279,784,566✔





4389



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




279,787,812✔





4390












4391



  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




279,801,040✔





4392



  if (pInput->rowIdx < pInputBlock->info.rows - 1) {




279,809,382✔





4393



    ++pInput->rowIdx;




278,278,822✔





4394



  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {




1,536,612✔





4395



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,536,612✔





4396



      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);




1,536,612✔





4397



    }










4398



    if (pInput->rowIdx != -1) {




1,536,612✔





4399



      SColumnInfoData* col = taosArrayGet(pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




×







4400



      if (!col) {




×







4401



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4402



        return terrno;




×







4403



      }










4404



      pInput->pInputBlock = pInputBlock;




×







4405



      pInput->aTs = (int64_t*)col->pData;




×







4406



    }










4407



  }










4408












4409



  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));




279,819,036✔





4410



}










4411












4412



static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {




279,678,071✔





4413



  int32_t            code = TSDB_CODE_SUCCESS;




279,678,071✔





4414



  int32_t            lino = 0;




279,678,071✔





4415



  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




279,678,071✔





4416



  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




279,696,779✔





4417












4418



  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {




1,156,939,038✔





4419



    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);




876,428,275✔





4420



    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);




876,165,290✔





4421












4422



    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);




876,165,290✔





4423



    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);




875,783,425✔





4424



    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);




875,783,425✔





4425












4426



    if (isNull) {




876,561,976✔





4427



      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);




103,310,110✔





4428



      QUERY_CHECK_CODE(code, lino, _end);




103,310,543✔





4429



    } else {










4430



      if (pSrcColInfo->pData != NULL) {




773,251,866✔





4431



        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);




773,232,481✔





4432



        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);




774,457,352✔





4433



        QUERY_CHECK_CODE(code, lino, _end);




774,238,270✔





4434



      }










4435



    }










4436



  }










4437



  pBlock->info.dataLoad = 1;




279,797,110✔





4438



  pBlock->info.scanFlag = pInputBlock->info.scanFlag;




279,793,494✔





4439



  pBlock->info.rows += 1;




279,794,653✔





4440












4441



_end:




279,797,878✔





4442



  if (code != TSDB_CODE_SUCCESS) {




279,797,878✔





4443



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4444



  }










4445



  return code;




279,625,581✔





4446



}










4447












4448



static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,




3,119,218✔





4449



                                       SSDataBlock** pResBlock) {










4450



  int32_t                 code = TSDB_CODE_SUCCESS;




3,119,218✔





4451



  int32_t                 lino = 0;




3,119,218✔





4452



  STableMergeScanInfo*    pInfo = pOperator->info;




3,119,218✔





4453



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




3,120,300✔





4454



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




3,119,581✔





4455



  bool                    finished = false;




3,116,726✔





4456












4457



  QRY_PARAM_CHECK(pResBlock);




3,116,726✔





4458












4459



  blockDataCleanup(pBlock);




3,117,787✔





4460












4461



  while (true) {




×







4462



    while (true) {










4463



      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {




282,804,144✔





4464



        finished = true;




3,121,012✔





4465



        break;




3,121,012✔





4466



      }










4467












4468



      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);




279,684,591✔





4469



      QUERY_CHECK_CODE(code, lino, _end);




279,786,039✔





4470












4471



      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);




279,786,039✔





4472



      QUERY_CHECK_CODE(code, lino, _end);




279,675,160✔





4473












4474



      if (pBlock->info.rows >= capacity) {




279,675,160✔





4475



        break;




×







4476



      }










4477



    }










4478












4479



    if (isTaskKilled(pTaskInfo)) {




3,121,012✔





4480



      return pTaskInfo->code;




×







4481



    }










4482












4483



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);




3,120,656✔





4484



    if (finished || limitReached || pBlock->info.rows > 0) {




3,119,232✔





4485



      break;










4486



    }










4487



  }










4488












4489



  if (pBlock->info.rows > 0) {




3,119,232✔





4490



    *pResBlock = pBlock;




1,194,852✔





4491



  }










4492












4493



_end:




1,925,448✔





4494



  if (code != TSDB_CODE_SUCCESS) {




3,120,300✔





4495



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4496



    pTaskInfo->code = code;




×







4497



  }










4498



  return code;




3,120,300✔





4499



}










4500












4501



static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {




1,914,705✔





4502



  int32_t              code = TSDB_CODE_SUCCESS;




1,914,705✔





4503



  int32_t              lino = 0;




1,914,705✔





4504



  STableMergeScanInfo* pInfo = pOperator->info;




1,914,705✔





4505












4506



  code = initSubTablesMergeInfo(pInfo);




1,916,143✔





4507



  QUERY_CHECK_CODE(code, lino, _end);




1,886,497✔





4508












4509



  code = initSubTableInputs(pOperator, pInfo);




1,886,497✔





4510



  QUERY_CHECK_CODE(code, lino, _end);




1,924,729✔





4511












4512



  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);




1,924,729✔





4513



  QUERY_CHECK_CODE(code, lino, _end);




1,924,003✔





4514












4515



_end:




1,924,003✔





4516



  if (code != TSDB_CODE_SUCCESS) {




1,924,003✔





4517



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4518



  }










4519



  return code;




1,924,010✔





4520



}










4521












4522



static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {




30,803,157✔





4523



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




30,803,157✔





4524



  if (pSubTblsInfo != NULL) {




30,819,005✔





4525



    tMergeTreeDestroy(&pSubTblsInfo->pTree);




1,924,736✔





4526












4527



    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




5,001,988✔





4528



      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,078,676✔





4529



      taosMemoryFree(pInput->tblCond.colList);




3,077,608✔





4530



      blockDataDestroy(pInput->pReaderBlock);




3,077,964✔





4531



      blockDataDestroy(pInput->pPageBlock);




3,078,676✔





4532



      taosArrayDestroy(pInput->aBlockPages);




3,077,252✔





4533



      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);




3,077,252✔





4534



      pInput->pReader = NULL;




3,077,252✔





4535



    }










4536












4537



    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);




1,925,092✔





4538



    taosMemoryFree(pSubTblsInfo->aInputs);




1,924,380✔





4539












4540



    taosMemoryFree(pSubTblsInfo);




1,924,373✔





4541



    pInfo->pSubTablesMergeInfo = NULL;




1,924,736✔





4542












4543



    // taosMemoryTrim(0);










4544



  }










4545



}




30,819,717✔





4546












4547



int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




3,090,453✔





4548



  QRY_PARAM_CHECK(ppRes);




3,090,453✔





4549












4550



  int32_t lino = 0;




3,090,809✔





4551



  int32_t tableListSize = 0;




3,090,809✔





4552



  int64_t st = taosGetTimestampUs();




3,093,329✔





4553












4554



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,093,329✔





4555



  STableMergeScanInfo* pInfo = pOperator->info;




3,080,457✔





4556












4557



  if (pOperator->status == OP_EXEC_DONE) {




3,066,845✔





4558



    return TSDB_CODE_SUCCESS;




×







4559



  }










4560












4561



  int32_t code = pOperator->fpSet._openFn(pOperator);




3,090,802✔





4562



  QUERY_CHECK_CODE(code, lino, _end);




3,073,281✔





4563












4564



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




3,073,281✔





4565



  QUERY_CHECK_CODE(code, lino, _end);




3,085,811✔





4566












4567



  if (!pInfo->hasGroupId) {




3,085,811✔





4568



    pInfo->hasGroupId = true;




1,890,261✔





4569












4570



    if (tableListSize == 0) {




1,864,482✔





4571



      setOperatorCompleted(pOperator);




38,478✔





4572



      (*ppRes) = NULL;




39,204✔





4573



      return code;




38,841✔





4574



    }










4575












4576



    pInfo->tableStartIndex = 0;




1,826,004✔





4577



    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,852,837✔





4578



    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




1,827,093✔





4579



    pInfo->groupId = pTmpGpId->groupId;




1,827,093✔





4580



    code = startSubTablesTableMergeScan(pOperator);




1,847,818✔





4581



    QUERY_CHECK_CODE(code, lino, _end);




1,866,058✔





4582



  }










4583












4584



  SSDataBlock* pBlock = NULL;




3,063,772✔





4585



  while (pInfo->tableStartIndex < tableListSize) {




3,117,794✔





4586



    if (isTaskKilled(pTaskInfo)) {




3,118,869✔





4587



      break;




×







4588



    }










4589












4590



    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);




3,119,588✔





4591



    QUERY_CHECK_CODE(code, lino, _end);




3,119,588✔





4592












4593



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




3,119,588✔





4594



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




×







4595



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




×







4596












4597



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




×







4598



    }










4599












4600



    if (pBlock != NULL) {




3,119,232✔





4601



      pBlock->info.id.groupId = pInfo->groupId;




1,194,852✔





4602



      pOperator->resultInfo.totalRows += pBlock->info.rows;




1,194,852✔





4603



      pInfo->bGroupProcessed = true;




1,194,852✔





4604



      break;




1,194,852✔





4605



    } else {










4606



      // Data of this group are all dumped, let's try the next group










4607



      stopSubTablesTableMergeScan(pInfo);




1,924,380✔





4608



      if (pInfo->tableEndIndex >= tableListSize - 1) {




1,924,736✔





4609



        setOperatorCompleted(pOperator);




1,866,784✔





4610



        break;




1,867,852✔





4611



      }










4612












4613



      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




57,240✔





4614



      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




57,240✔





4615



      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




57,240✔





4616












4617



      pInfo->groupId = pTmpGpId->groupId;




57,240✔





4618



      code = startSubTablesTableMergeScan(pOperator);




57,240✔





4619



      QUERY_CHECK_CODE(code, lino, _end);




57,240✔





4620



      resetLimitInfoForNextGroup(&pInfo->limitInfo);




57,240✔





4621



    }










4622



  }










4623












4624



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




3,063,060✔





4625












4626



_end:




3,063,772✔





4627



  if (code != TSDB_CODE_SUCCESS) {




3,063,060✔





4628



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4629



    pTaskInfo->code = code;




×







4630



    T_LONG_JMP(pTaskInfo->env, code);




×







4631



  } else {










4632



    (*ppRes) = pBlock;




3,063,060✔





4633



  }










4634












4635



  return code;




3,062,348✔





4636



}










4637












4638



static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {




3,512,399✔





4639



  int32_t              code = TSDB_CODE_SUCCESS;




3,512,399✔





4640



  int32_t              lino = 0;




3,512,399✔





4641



  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;




3,512,399✔





4642



  STableMergeScanInfo* pInfo = pOperator->info;




3,512,399✔





4643



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,515,633✔





4644












4645



  if (pInfo->mSkipTables == NULL) {




3,515,633✔





4646



    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,




476,614✔





4647



                                      taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);










4648



    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);




476,614✔





4649



  }










4650



  int bSkip = 1;




3,515,633✔





4651



  if (pInfo->mSkipTables != NULL) {




3,515,633✔





4652



    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));




3,515,633✔





4653



    if (code == TSDB_CODE_DUP_KEY) {




3,515,633✔





4654



      code = TSDB_CODE_SUCCESS;




×







4655



    }










4656



    QUERY_CHECK_CODE(code, lino, _end);




3,515,633✔





4657



  }










4658












4659



_end:




3,515,633✔





4660



  if (code != TSDB_CODE_SUCCESS) {




3,515,633✔





4661



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4662



    pTaskInfo->code = code;




×







4663



    T_LONG_JMP(pTaskInfo->env, code);




×







4664



  }










4665



}




3,515,094✔





4666












4667



static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {




168,292,246✔





4668



  STableMergeScanInfo* pInfo = pOperator->info;




168,292,246✔





4669



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




168,323,730✔





4670



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




168,306,567✔





4671



  SSDataBlock*         pBlock = pInfo->pReaderBlock;




168,286,473✔





4672



  int32_t              code = 0;




168,291,654✔





4673



  bool                 hasNext = false;




168,291,654✔





4674



  STsdbReader*         reader = pInfo->base.dataReader;




168,327,457✔





4675












4676



  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);




168,316,512✔





4677



  if (code != 0) {




168,261,072✔





4678



    pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4679



    qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo));




×







4680



    pTaskInfo->code = code;




×







4681



    return code;




×







4682



  }










4683












4684



  if (!hasNext || isTaskKilled(pTaskInfo)) {




168,261,072✔





4685



    if (isTaskKilled(pTaskInfo)) {




30,082,433✔





4686



      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));




538✔





4687



      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




538✔





4688



    }










4689



    *pFinished = true;




30,085,229✔





4690



    return code;




30,080,638✔





4691



  }










4692












4693



  uint32_t status = 0;




138,204,332✔





4694



  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);




138,203,087✔





4695












4696



  if (code != TSDB_CODE_SUCCESS) {




138,180,432✔





4697



    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));




17,216✔





4698



    pTaskInfo->code = code;




17,216✔





4699



    return code;




17,216✔





4700



  }










4701












4702



  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




138,163,216✔





4703



    *pFinished = true;




×







4704



    return code;




×







4705



  }










4706












4707



  // current block is filter out according to filter condition, continue load the next block










4708



  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {




138,163,216✔





4709



    *pSkipped = true;




6,384,796✔





4710



    return code;




6,386,856✔





4711



  }










4712












4713



  return code;




131,766,577✔





4714



}










4715












4716



static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {




171,164,707✔





4717



  STableMergeScanSortSourceParam* source = param;




171,164,707✔





4718












4719



  SOperatorInfo*       pOperator = source->pOperator;




171,164,707✔





4720



  STableMergeScanInfo* pInfo = pOperator->info;




171,171,219✔





4721



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




171,170,172✔





4722



  SSDataBlock*         pBlock = NULL;




171,184,466✔





4723



  int64_t              st = taosGetTimestampUs();




171,160,992✔





4724



  int32_t              code = TSDB_CODE_SUCCESS;




171,160,992✔





4725












4726



  while (true) {










4727



    if (pInfo->rtnNextDurationBlocks) {




186,036,736✔





4728



      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",




17,735,297✔





4729



             GET_TASKID(pTaskInfo), pInfo->nextDurationBlocksIdx, pInfo->numNextDurationBlocks);










4730












4731



      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {




17,750,241✔





4732



        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];




8,495,312✔





4733



        ++pInfo->nextDurationBlocksIdx;




8,494,930✔





4734



      } else {










4735



        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




17,735,413✔





4736



          blockDataDestroy(pInfo->nextDurationBlocks[i]);




8,494,236✔





4737



          pInfo->nextDurationBlocks[i] = NULL;




8,490,034✔





4738



        }










4739












4740



        pInfo->rtnNextDurationBlocks = false;




9,241,941✔





4741



        pInfo->nextDurationBlocksIdx = 0;




9,240,413✔





4742



        pInfo->numNextDurationBlocks = 0;




9,238,121✔





4743



        continue;




9,240,413✔





4744



      }










4745



    } else {










4746



      bool bFinished = false;




168,299,841✔





4747



      bool bSkipped = false;




168,291,120✔





4748












4749



      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);




168,325,129✔





4750



      if (code != 0) {




168,252,173✔





4751



        return code;




17,216✔





4752



      }










4753












4754



      pBlock = pInfo->pReaderBlock;




168,234,957✔





4755



      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",




168,280,156✔





4756



             GET_TASKID(pTaskInfo), bFinished, bSkipped, pInfo->bNextDurationBlockEvent, pInfo->bNewFilesetEvent);










4757



      if (bFinished) {




168,329,688✔





4758



        pInfo->bNewFilesetEvent = false;




30,106,325✔





4759



        break;




30,106,325✔





4760



      }










4761












4762



      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {




138,223,363✔





4763



        if (!bSkipped) {




9,247,853✔





4764



          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);




8,495,312✔





4765



          if (code) {




8,486,144✔





4766



            *ppBlock = NULL;




×







4767



            return code;




×







4768



          }










4769












4770



          ++pInfo->numNextDurationBlocks;




8,486,144✔





4771



          if (pInfo->numNextDurationBlocks > 2) {




8,488,054✔





4772



            qError("%s table merge scan prefetch %d next duration blocks. end early.", GET_TASKID(pTaskInfo),




×







4773



                   pInfo->numNextDurationBlocks);










4774



            pInfo->bNewFilesetEvent = false;




×







4775



            break;




×







4776



          }










4777



        }










4778












4779



        if (pInfo->bNewFilesetEvent) {




9,237,921✔





4780



          pInfo->rtnNextDurationBlocks = true;




9,238,051✔





4781



          *ppBlock = NULL;




9,237,669✔





4782



          return code;




9,227,355✔





4783



        }










4784













UNCOV

4785



        if (pInfo->bNextDurationBlockEvent) {




×







4786



          pInfo->bNextDurationBlockEvent = false;




×







4787



          continue;




×







4788



        }










4789



      }










4790



      if (bSkipped) continue;




128,978,739✔





4791



    }










4792












4793



    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);




131,838,427✔





4794












4795



    pOperator->resultInfo.totalRows += pBlock->info.rows;




131,843,581✔





4796



    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;




131,836,732✔





4797



    *ppBlock = pBlock;




131,832,127✔





4798












4799



    return code;




131,826,747✔





4800



  }










4801












4802



  *ppBlock = NULL;




30,105,347✔





4803



  return code;




30,105,841✔





4804



}










4805












4806



int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {




26,616,477✔





4807



  int32_t code = TSDB_CODE_SUCCESS;




26,616,477✔





4808



  int32_t lino = 0;




26,616,477✔





4809



  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));




26,616,477✔





4810



  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);




26,596,882✔





4811



  SBlockOrderInfo biTs = {0};




26,596,882✔





4812



  SBlockOrderInfo biPk = {0};




26,599,128✔





4813












4814



  int32_t tsTargetSlotId = 0;




26,615,134✔





4815



  int32_t pkTargetSlotId = -1;




26,615,134✔





4816



  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {




99,194,081✔





4817



    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);




72,633,374✔





4818



    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);




72,643,649✔





4819



    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




72,643,649✔





4820



      tsTargetSlotId = colInfo->dstSlotId;




26,627,808✔





4821



      biTs.order = order;




26,613,425✔





4822



      biTs.slotId = tsTargetSlotId;




26,613,425✔





4823



      biTs.nullFirst = (order == TSDB_ORDER_ASC);




26,613,425✔





4824



      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);




26,613,425✔





4825



    }










4826



    // TODO: order by just ts










4827



    if (colInfo->isPk) {




72,572,365✔





4828



      pkTargetSlotId = colInfo->dstSlotId;




1,981,671✔





4829



      biPk.order = order;




1,981,671✔





4830



      biPk.slotId = pkTargetSlotId;




1,981,671✔





4831



      biPk.nullFirst = (order == TSDB_ORDER_ASC);




1,981,671✔





4832



      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);




1,981,671✔





4833



    }










4834



  }










4835












4836



  void* tmp = taosArrayPush(pSortInfo, &biTs);




26,633,806✔





4837



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




26,633,806✔





4838



  if (pkTargetSlotId != -1) {




26,633,806✔





4839



    tmp = taosArrayPush(pSortInfo, &biPk);




1,982,308✔





4840



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,982,308✔





4841



  }










4842












4843



  (*ppSortArray) = pSortInfo;




26,634,443✔





4844












4845



_end:




26,612,997✔





4846



  if (code != TSDB_CODE_SUCCESS) {




26,611,457✔





4847



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4848



  }










4849



  return code;




26,611,457✔





4850



}










4851












4852



void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {




31,638,254✔





4853



  STableMergeScanInfo* pTmsInfo = param;




31,638,254✔





4854



  if (type == TSD_READER_NOTIFY_DURATION_START) {




31,638,254✔





4855



    pTmsInfo->bNewFilesetEvent = true;




31,648,635✔





4856



  } else if (type == TSD_READER_NOTIFY_NEXT_DURATION_BLOCK) {




×







4857



    pTmsInfo->bNextDurationBlockEvent = true;




×







4858



  }










4859



  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);




31,635,954✔





4860












4861



  return;




31,665,927✔





4862



}










4863












4864



int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




39,531,555✔





4865



  STableMergeScanInfo* pInfo = pOperator->info;




39,531,555✔





4866



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




39,563,791✔





4867












4868



  int32_t code = TSDB_CODE_SUCCESS;




39,549,801✔





4869



  int32_t lino = 0;




39,549,801✔





4870



  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




39,549,801✔





4871












4872



  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));




39,549,089✔





4873



  pInfo->bNewFilesetEvent = false;




39,614,730✔





4874



  pInfo->bNextDurationBlockEvent = false;




39,590,698✔





4875












4876



  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;




39,576,952✔





4877



  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;




39,578,695✔





4878












4879



  pInfo->pSortHandle = NULL;




39,593,290✔





4880



  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,




79,158,876✔





4881



                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);




39,583,142✔





4882



  if (code) {




39,522,066✔





4883



    return code;




×







4884



  }










4885












4886



  if (pInfo->bSortRowId && numOfTable != 1) {




39,522,066✔





4887



    int32_t memSize = 512 * 1024 * 1024;




2,936,683✔





4888



    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);




2,936,683✔





4889



    QUERY_CHECK_CODE(code, lino, _end);




2,938,359✔





4890



  }










4891












4892



  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);




39,538,170✔





4893



  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);




39,542,738✔





4894



  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);




39,552,285✔





4895












4896



  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);




39,539,677✔





4897



  QUERY_CHECK_CODE(code, lino, _end);




39,535,259✔





4898












4899



  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));




39,535,259✔





4900



  QUERY_CHECK_NULL(param, code, lino, _end, terrno);




39,506,118✔





4901



  param->pOperator = pOperator;




39,506,118✔





4902












4903



  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));




39,508,423✔





4904



  if (ps == NULL) {




39,515,955✔





4905



    taosMemoryFree(param);




×







4906



    QUERY_CHECK_NULL(ps, code, lino, _end, terrno);




×







4907



  }










4908












4909



  ps->param = param;




39,515,955✔





4910



  ps->onlyRef = false;




39,522,082✔





4911



  code = tsortAddSource(pInfo->pSortHandle, ps);




39,539,268✔





4912



  QUERY_CHECK_CODE(code, lino, _end);




39,557,724✔





4913












4914



  if (numOfTable == 1) {




39,557,724✔





4915



    tsortSetSingleTableMerge(pInfo->pSortHandle);




25,897,111✔





4916



  } else {










4917



    code = tsortOpen(pInfo->pSortHandle);




13,660,613✔





4918



    QUERY_CHECK_CODE(code, lino, _end);




13,667,394✔





4919



  }










4920












4921



_end:




13,658,786✔





4922



  if (code != TSDB_CODE_SUCCESS) {




39,554,617✔





4923



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




8,608✔





4924



  }










4925



  return code;




39,551,643✔





4926



}










4927












4928



void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




39,578,298✔





4929



  STableMergeScanInfo* pInfo = pOperator->info;




39,578,298✔





4930



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




39,578,792✔





4931



  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));




39,576,938✔





4932












4933



  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);




39,579,444✔





4934



  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;




39,575,538✔





4935



  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;




39,577,578✔





4936



  pInfo->sortExecInfo.loops += sortExecInfo.loops;




39,574,915✔





4937



  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;




39,569,730✔





4938



  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;




39,572,187✔





4939












4940



  tsortDestroySortHandle(pInfo->pSortHandle);




39,566,011✔





4941



  pInfo->pSortHandle = NULL;




39,566,918✔





4942



}




39,568,446✔





4943












4944



void startGroupTableMergeScan(SOperatorInfo* pOperator) {




30,321,190✔





4945



  int32_t              code = TSDB_CODE_SUCCESS;




30,321,190✔





4946



  int32_t              lino = 0;




30,321,190✔





4947



  STableMergeScanInfo* pInfo = pOperator->info;




30,321,190✔





4948



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




30,332,379✔





4949



  SReadHandle*         pHandle = &pInfo->base.readHandle;




30,322,952✔





4950



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




30,337,844✔





4951



  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




30,313,391✔





4952












4953



  {










4954



    int32_t numOfTables = 0;




30,325,640✔





4955



    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




30,330,619✔





4956



    QUERY_CHECK_CODE(code, lino, _end);




30,308,570✔





4957












4958



    int32_t i = pInfo->tableStartIndex + 1;




30,308,570✔





4959



    for (; i < numOfTables; ++i) {




136,401,429✔





4960



      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




112,462,260✔





4961



      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);




112,463,962✔





4962



      if (tableKeyInfo->groupId != pInfo->groupId) {




112,463,962✔





4963



        break;




6,352,961✔





4964



      }










4965



    }










4966



    pInfo->tableEndIndex = i - 1;




30,292,130✔





4967



  }










4968



  pInfo->bGroupProcessed = false;




30,342,738✔





4969



  int32_t tableStartIdx = pInfo->tableStartIndex;




30,348,704✔





4970



  int32_t tableEndIdx = pInfo->tableEndIndex;




30,339,922✔





4971












4972



  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;




30,337,735✔





4973



  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);




30,337,735✔





4974



  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,




60,662,641✔





4975



                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);




30,331,464✔





4976



  QUERY_CHECK_CODE(code, lino, _end);




30,299,961✔





4977



  if (pInfo->filesetDelimited) {




30,299,961✔





4978



    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);




30,316,899✔





4979



  }










4980



  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);




30,293,927✔





4981












4982



  code = startDurationForGroupTableMergeScan(pOperator);




30,269,790✔





4983



  QUERY_CHECK_CODE(code, lino, _end);




30,316,051✔





4984












4985



_end:




30,307,443✔





4986



  if (code != TSDB_CODE_SUCCESS) {




30,316,633✔





4987



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




8,608✔





4988



    pTaskInfo->code = code;




8,608✔





4989



    T_LONG_JMP(pTaskInfo->env, code);




8,608✔





4990



  }










4991



}




30,308,025✔





4992












4993



void stopGroupTableMergeScan(SOperatorInfo* pOperator) {




30,333,753✔





4994



  STableMergeScanInfo* pInfo = pOperator->info;




30,333,753✔





4995



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




30,335,306✔





4996



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




30,333,753✔





4997












4998



  stopDurationForGroupTableMergeScan(pOperator);




30,334,812✔





4999












5000



  if (pInfo->base.dataReader != NULL) {




30,325,085✔





5001



    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);




30,328,877✔





5002



    pInfo->base.dataReader = NULL;




30,260,444✔





5003



  }










5004



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




30,269,092✔





5005



    if (pInfo->nextDurationBlocks[i]) {




1,076✔





5006



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




1,076✔





5007



      pInfo->nextDurationBlocks[i] = NULL;




1,076✔





5008



    }










5009



    pInfo->numNextDurationBlocks = 0;




1,076✔





5010



    pInfo->nextDurationBlocksIdx = 0;




1,076✔





5011



  }










5012



  resetLimitInfoForNextGroup(&pInfo->limitInfo);




30,290,917✔





5013



  taosHashCleanup(pInfo->mSkipTables);




30,287,151✔





5014



  pInfo->mSkipTables = NULL;




30,262,322✔





5015



  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




30,273,746✔





5016



}




30,318,629✔





5017












5018



// all data produced by this function only belongs to one group










5019



// slimit/soffset does not need to be concerned here, since this function only deal with data within one group.










5020



SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,




80,739,058✔





5021



                                              SOperatorInfo* pOperator) {










5022



  STableMergeScanInfo* pInfo = pOperator->info;




80,739,058✔





5023



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




80,759,864✔





5024



  STupleHandle*        pTupleHandle = NULL;




80,744,886✔





5025












5026



  blockDataCleanup(pResBlock);




80,741,701✔





5027












5028



  while (1) {




×







5029



    while (1) {




2,147,483,647✔





5030



      pTupleHandle = NULL;




2,147,483,647✔





5031



      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);




2,147,483,647✔





5032



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5033



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




2,929,424✔





5034



        T_LONG_JMP(pOperator->pTaskInfo->env, code);




2,929,424✔





5035



      }










5036



      if (pTupleHandle == NULL) {




2,147,483,647✔





5037



        break;




64,957,370✔





5038



      }










5039












5040



      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);




2,147,483,647✔





5041



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5042



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







5043



        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5044



      }










5045












5046



      if (pResBlock->info.rows >= capacity) {




2,147,483,647✔





5047



        break;




15,804,718✔





5048



      }










5049



    }










5050












5051



    if (tsortIsClosed(pHandle)) {




80,762,088✔





5052



      terrno = TSDB_CODE_TSC_QUERY_CANCELLED;




×







5053



      T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5054



    }










5055












5056



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);




80,778,242✔





5057



    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,




80,776,924✔





5058



           pInfo->limitInfo.numOfOutputRows);










5059



    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {




80,791,616✔





5060



      break;










5061



    }










5062



  }










5063



  return (pResBlock->info.rows > 0) ? pResBlock : NULL;




80,791,616✔





5064



}










5065












5066



int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




68,208,356✔





5067



  if (pOperator->status == OP_EXEC_DONE) {




68,208,356✔





5068



    (*ppRes) = NULL;




42,933✔





5069



    return TSDB_CODE_SUCCESS;




42,933✔





5070



  }










5071












5072



  int32_t              code = TSDB_CODE_SUCCESS;




68,150,843✔





5073



  int32_t              lino = 0;




68,150,843✔





5074



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




68,150,843✔





5075



  STableMergeScanInfo* pInfo = pOperator->info;




68,152,119✔





5076












5077



  code = pOperator->fpSet._openFn(pOperator);




68,165,049✔





5078



  QUERY_CHECK_CODE(code, lino, _end);




68,150,514✔





5079












5080



  int64_t st = taosGetTimestampUs();




68,160,735✔





5081












5082



  int32_t tableListSize = 0;




68,160,735✔





5083



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




68,156,817✔





5084



  QUERY_CHECK_CODE(code, lino, _end);




68,172,690✔





5085












5086



  if (!pInfo->hasGroupId) {




68,172,690✔





5087



    pInfo->hasGroupId = true;




26,965,567✔





5088












5089



    if (tableListSize == 0) {




26,950,929✔





5090



      setOperatorCompleted(pOperator);




2,991,996✔





5091



      (*ppRes) = NULL;




2,993,740✔





5092



      return code;




2,993,740✔





5093



    }










5094



    pInfo->tableStartIndex = 0;




23,958,933✔





5095



    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




23,935,954✔





5096



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




23,938,468✔





5097



    pInfo->groupId = tmp->groupId;




23,938,468✔





5098



    startGroupTableMergeScan(pOperator);




23,970,663✔





5099



  }










5100












5101



  SSDataBlock* pBlock = NULL;




65,133,043✔





5102



  while (pInfo->tableStartIndex < tableListSize) {




80,722,527✔





5103



    if (isTaskKilled(pTaskInfo)) {




80,761,489✔





5104



      goto _end;




538✔





5105



    }










5106












5107



    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,




80,749,979✔





5108



                                              pOperator);










5109



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




80,791,094✔





5110



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,846,494✔





5111



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




1,846,494✔





5112



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




1,846,494✔





5113



    }










5114



    if (pBlock != NULL) {




80,789,796✔





5115



      pBlock->info.id.groupId = pInfo->groupId;




41,210,439✔





5116



      pOperator->resultInfo.totalRows += pBlock->info.rows;




41,211,516✔





5117



      pInfo->bGroupProcessed = true;




41,209,878✔





5118



      break;




41,208,996✔





5119



    } else {










5120



      if (pInfo->bNewFilesetEvent) {




39,579,357✔





5121



        stopDurationForGroupTableMergeScan(pOperator);




9,244,927✔





5122



        code = startDurationForGroupTableMergeScan(pOperator);




9,239,040✔





5123



        QUERY_CHECK_CODE(code, lino, _end);




9,236,523✔





5124



      } else {










5125



        // Data of this group are all dumped, let's try the next group










5126



        stopGroupTableMergeScan(pOperator);




30,334,430✔





5127



        if (pInfo->tableEndIndex >= tableListSize - 1) {




30,330,962✔





5128



          setOperatorCompleted(pOperator);




23,977,331✔





5129



          break;




23,974,471✔





5130



        }










5131












5132



        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




6,352,961✔





5133



        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




6,352,961✔





5134



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




6,352,444✔





5135



        pInfo->groupId = tmp->groupId;




6,352,444✔





5136



        startGroupTableMergeScan(pOperator);




6,352,961✔





5137



        resetLimitInfoForNextGroup(&pInfo->limitInfo);




6,352,405✔





5138



      }










5139



    }










5140



  }










5141












5142



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




65,180,342✔





5143












5144



_end:




65,184,672✔





5145



  if (code != TSDB_CODE_SUCCESS) {




65,185,592✔





5146



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5147



    pTaskInfo->code = code;




×







5148



    T_LONG_JMP(pTaskInfo->env, code);




×







5149



  } else {










5150



    (*ppRes) = pBlock;




65,185,592✔





5151



  }










5152












5153



  return code;




65,186,114✔





5154



}










5155












5156



static SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {




×







5157



  SSDataBlock* pRes = NULL;




×







5158



  int32_t      code = doTableMergeScanNext(pOperator, &pRes);




×







5159



  return pRes;




×







5160



}










5161












5162



void destroyTableMergeScanOperatorInfo(void* param) {




26,650,842✔





5163



  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;




26,650,842✔





5164












5165



  // start one reader variable










5166



  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {




26,650,842✔





5167



    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);




26,659,253✔





5168



    pTableScanInfo->base.dataReader = NULL;




26,650,927✔





5169



  }










5170












5171



  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {




26,657,352✔





5172



    if (pTableScanInfo->nextDurationBlocks[i] != NULL) {




×







5173



      blockDataDestroy(pTableScanInfo->nextDurationBlocks[i]);




×







5174



      pTableScanInfo->nextDurationBlocks[i] = NULL;




×







5175



    }










5176



  }










5177












5178



  tsortDestroySortHandle(pTableScanInfo->pSortHandle);




26,651,672✔





5179



  pTableScanInfo->pSortHandle = NULL;




26,643,287✔





5180



  taosHashCleanup(pTableScanInfo->mSkipTables);




26,645,586✔





5181



  pTableScanInfo->mSkipTables = NULL;




26,645,603✔





5182



  blockDataDestroy(pTableScanInfo->pSortInputBlock);




26,658,101✔





5183



  pTableScanInfo->pSortInputBlock = NULL;




26,649,598✔





5184



  // end one reader variable










5185












5186



  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);




26,649,976✔





5187












5188



  blockDataDestroy(pTableScanInfo->pResBlock);




26,647,254✔





5189



  pTableScanInfo->pResBlock = NULL;




26,651,038✔





5190












5191



  // remove it from the task->result list










5192



  blockDataDestroy(pTableScanInfo->pReaderBlock);




26,648,686✔





5193



  pTableScanInfo->pReaderBlock = NULL;




26,653,303✔





5194



  taosArrayDestroy(pTableScanInfo->pSortInfo);




26,654,727✔





5195












5196



  stopSubTablesTableMergeScan(pTableScanInfo);




26,646,618✔





5197












5198



  taosMemoryFreeClear(param);




26,638,363✔





5199



}




26,637,953✔





5200












5201



int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {




1,243,946✔





5202



  if (pOptr == NULL) {




1,243,946✔





5203



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));




×







5204



    return TSDB_CODE_INVALID_PARA;




×







5205



  }










5206



  // TODO: merge these two info into one struct










5207



  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));




1,243,946✔





5208



  if (!execInfo) {




1,244,704✔





5209



    return terrno;




×







5210



  }










5211



  STableMergeScanInfo* pInfo = pOptr->info;




1,244,704✔





5212



  execInfo->blockRecorder = pInfo->base.readRecorder;




1,244,698✔





5213



  execInfo->sortExecInfo = pInfo->sortExecInfo;




1,247,396✔





5214












5215



  *pOptrExplain = execInfo;




1,246,632✔





5216



  *len = sizeof(STableMergeScanExecInfo);




1,248,178✔





5217












5218



  return TSDB_CODE_SUCCESS;




1,248,948✔





5219



}










5220












5221



static int32_t resetTableMergeScanOperatorState(SOperatorInfo* pOper) {




2,237,573✔





5222



  int32_t         code = TSDB_CODE_SUCCESS;




2,237,573✔





5223



  STableMergeScanInfo*   pInfo = pOper->info;




2,237,573✔





5224



  pOper->status = OP_NOT_OPENED;




2,237,573✔





5225












5226



  pInfo->tableEndIndex = 0;




2,237,573✔





5227



  pInfo->tableStartIndex = 0;




2,237,573✔





5228



  pInfo->hasGroupId = false;




2,237,573✔





5229



  if (pInfo->base.readerAPI.tsdReaderClose) {




2,237,573✔





5230



    pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);




2,237,573✔





5231



  }










5232



  pInfo->base.dataReader = NULL;




2,237,313✔





5233



  pInfo->base.scanFlag = MAIN_SCAN;




2,237,313✔





5234












5235



  pInfo->base.limitInfo = (SLimitInfo){0};




2,237,573✔





5236



  pInfo->base.limitInfo.limit.limit = -1;




2,237,313✔





5237



  pInfo->base.limitInfo.slimit.limit = -1;




2,237,313✔





5238












5239



  tableListDestroy(pInfo->base.pTableListInfo);




2,237,573✔





5240



  pInfo->base.pTableListInfo = tableListCreate();




2,237,573✔





5241



  if (!pInfo->base.pTableListInfo) {




2,237,573✔





5242



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







5243



    return terrno;




×







5244



  }










5245



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




2,237,573✔





5246












5247



  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;




2,237,573✔





5248



  code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,




4,474,650✔





5249



                                  &pInfo->base.readHandle, pInfo->base.pTableListInfo, 










5250



                                  pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);




4,474,898✔





5251



  if (code) {




2,237,573✔





5252



    qError("%s failed to createScanTableListInfo, code:%s", __func__, tstrerror(code));




×







5253



    return code;




×







5254



  }










5255












5256



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




2,237,573✔





5257



  cleanupQueryTableDataCond(&pInfo->base.cond);




2,237,573✔





5258



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, false);




2,237,573✔





5259



  if (code) {




2,237,573✔





5260



    qError("%s failed to initQueryTableDataCond, code:%s", __func__, tstrerror(code));




×







5261



    return code;




×







5262



  }










5263












5264



  tsortDestroySortHandle(pInfo->pSortHandle);




2,237,573✔





5265



  pInfo->pSortHandle = NULL;




2,237,573✔





5266












5267



  taosHashCleanup(pInfo->mSkipTables);




2,237,573✔





5268



  pInfo->mSkipTables = NULL;




2,237,573✔





5269



  pOper->resultInfo.totalRows = 0;




2,237,573✔





5270



  










5271



  pInfo->bGroupProcessed = false;




2,237,573✔





5272



  pInfo->bNewFilesetEvent = false;




2,237,573✔





5273



  pInfo->bNextDurationBlockEvent = false;




2,237,573✔





5274



  pInfo->rtnNextDurationBlocks = false;




2,237,573✔





5275



  pInfo->nextDurationBlocksIdx = 0;




2,237,573✔





5276



  pInfo->bSortRowId = false;




2,237,573✔





5277












5278



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




2,237,573✔





5279



    if (pInfo->nextDurationBlocks[i] != NULL) {




×







5280



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




×







5281



      pInfo->nextDurationBlocks[i] = NULL;




×







5282



    }










5283



  }










5284



  pInfo->numNextDurationBlocks = 0;




2,237,573✔





5285












5286



  stopSubTablesTableMergeScan(pInfo);




2,237,573✔





5287



  return code;




2,237,573✔





5288



}










5289












5290



int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




26,592,212✔





5291



                                         STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










5292



                                         SOperatorInfo** pOptrInfo) {










5293



  QRY_PARAM_CHECK(pOptrInfo);




26,592,212✔





5294












5295



  int32_t              code = TSDB_CODE_SUCCESS;




26,618,719✔





5296



  int32_t              lino = 0;




26,618,719✔





5297



  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));




26,618,719✔





5298



  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




26,545,165✔





5299



  if (pInfo == NULL || pOperator == NULL) {




26,545,184✔





5300



    code = terrno;




18✔





5301



    goto _error;




×







5302



  }










5303












5304



  pOperator->pPhyNode = pTableScanNode;




26,551,276✔





5305



  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;




26,556,253✔





5306












5307



  int32_t numOfCols = 0;




26,574,058✔





5308



  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,




26,588,920✔





5309



                             &pInfo->base.matchInfo);










5310



  QUERY_CHECK_CODE(code, lino, _error);




26,577,991✔





5311












5312



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, false);




26,577,991✔





5313



  QUERY_CHECK_CODE(code, lino, _error);




26,574,245✔





5314












5315



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




26,574,245✔





5316



    SExprSupp* pSup = &pInfo->base.pseudoSup;




10,867,726✔





5317



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);




10,868,531✔





5318



    QUERY_CHECK_CODE(code, lino, _error);




10,849,981✔





5319












5320



    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,




10,849,981✔





5321



                                      &pTaskInfo->storageAPI.functionStore);










5322



    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);




10,867,660✔





5323



  }










5324












5325



  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};




26,583,551✔





5326












5327



  if (tsMetaEntryCache && readHandle->streamRtInfo == NULL) {




26,531,427✔





5328



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(tsMetaEntryCacheSize, -1, .5);




×







5329



    QUERY_CHECK_NULL(pInfo->base.metaCache.pTableMetaEntryCache, code, lino, _error, terrno);




×







5330



  }










5331












5332



  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;




26,531,427✔





5333



  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




26,602,016✔





5334



  pInfo->base.scanFlag = MAIN_SCAN;




26,562,967✔





5335



  pInfo->base.readHandle = *readHandle;




26,570,185✔





5336












5337



  pInfo->readIdx = -1;




26,547,464✔





5338












5339



  pInfo->base.limitInfo.limit.limit = -1;




26,505,911✔





5340



  pInfo->base.limitInfo.slimit.limit = -1;




26,608,539✔





5341



  pInfo->base.pTableListInfo = pTableListInfo;




26,531,111✔





5342












5343



  pInfo->sample.sampleRatio = pTableScanNode->ratio;




26,564,590✔





5344



  pInfo->sample.seed = taosGetTimestampSec();




26,602,591✔





5345












5346



  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,




26,562,360✔





5347



                            pTaskInfo->pStreamRuntimeInfo);




26,593,815✔





5348



  QUERY_CHECK_CODE(code, lino, _error);




26,523,103✔





5349












5350



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




26,523,103✔





5351












5352



  pInfo->mergeLimit = -1;




26,532,215✔





5353



  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;




26,540,716✔





5354



  if (hasLimit) {




26,569,523✔





5355



    pInfo->mergeLimit = pInfo->limitInfo.limit.offset != -1




4,648,676✔





5356



                            ? pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset




818,234✔





5357



                            : pInfo->limitInfo.limit.limit;




3,139,809✔





5358



    pInfo->mSkipTables = NULL;




2,324,872✔





5359



  }










5360












5361



  initResultSizeInfo(&pOperator->resultInfo, 1024);




26,572,923✔





5362



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




26,561,468✔





5363



  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);




26,587,430✔





5364



  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);




26,597,481✔





5365



  QUERY_CHECK_CODE(code, lino, _error);




26,633,842✔





5366



  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {




26,633,842✔





5367



    pInfo->bSortRowId = true;




5,260,961✔





5368



  } else {










5369



    pInfo->bSortRowId = false;




21,378,581✔





5370



  }










5371












5372



  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);




26,627,424✔





5373



  QUERY_CHECK_CODE(code, lino, _error);




26,600,000✔





5374












5375



  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo);




26,600,000✔





5376



  QUERY_CHECK_CODE(code, lino, _error);




26,590,800✔





5377












5378



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);




26,590,800✔





5379



  QUERY_CHECK_CODE(code, lino, _error);




26,621,818✔





5380












5381



  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;




26,621,818✔





5382












5383



  int32_t  rowSize = pInfo->pResBlock->info.rowSize;




26,624,848✔





5384



  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);




26,604,913✔





5385












5386



  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);




26,602,765✔





5387












5388



  // start one reader variable










5389



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);




26,620,430✔





5390



  QUERY_CHECK_CODE(code, lino, _error);




26,634,346✔





5391












5392



  if (!tsExperimental) {




26,634,346✔





5393



    pInfo->filesetDelimited = false;




×







5394



  } else {










5395



    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




26,634,346✔





5396



  }










5397



  // end one reader variable










5398



  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,




26,637,766✔





5399



                  pInfo, pTaskInfo);










5400



  pOperator->exprSupp.numOfExprs = numOfCols;




26,583,231✔





5401












5402



  pOperator->fpSet = createOperatorFpSet(




26,598,583✔





5403



      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,




26,612,314✔





5404



      destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn,










5405



      NULL);










5406



  setOperatorResetStateFn(pOperator, resetTableMergeScanOperatorState);     




26,568,015✔





5407



  pOperator->cost.openCost = 0;




26,576,380✔





5408












5409



  *pOptrInfo = pOperator;




26,580,578✔





5410



  return code;




26,569,635✔





5411












5412



_error:




×







5413



  if (code != TSDB_CODE_SUCCESS) {




×







5414



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5415



  }










5416



  pTaskInfo->code = code;




×







5417



  if (pInfo != NULL) {




×







5418



    pInfo->base.pTableListInfo = NULL;




×







5419



    destroyTableMergeScanOperatorInfo(pInfo);




×







5420



  }










5421



  if (pOperator != NULL) {




×







5422



    pOperator->info = NULL;




×







5423



    destroyOperator(pOperator);




×







5424



  }










5425



  return code;




×







5426



}










5427












5428



// ====================================================================================================================










5429



// TableCountScanOperator










5430



static void        destoryTableCountScanOperator(void* param);










5431



static int32_t     buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5432



                                                  SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI);










5433



static int32_t     buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5434



                                                  SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI);










5435



static int32_t     buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5436



                                             STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName);










5437



static int32_t     buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5438



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName);










5439



static int32_t     buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5440



                                          STableCountScanSupp* pSupp, SSDataBlock* pRes);










5441



static void        buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5442



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5443



                                               size_t perfdbTableNum);










5444



static void        buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,










5445



                                              size_t infodbTableNum, size_t perfdbTableNum);










5446



static const char* GROUP_TAG_DB_NAME = "db_name";










5447



static const char* GROUP_TAG_STABLE_NAME = "stable_name";










5448












5449



int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {




27,001✔





5450



  if (scanCols != NULL) {




27,001✔





5451



    SNode* pNode = NULL;




14,154✔





5452



    FOREACH(pNode, scanCols) {




32,866✔





5453



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




18,885✔





5454



        return TSDB_CODE_QRY_SYS_ERROR;




×







5455



      }










5456



      STargetNode* targetNode = (STargetNode*)pNode;




18,885✔





5457



      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {




18,885✔





5458



        return TSDB_CODE_QRY_SYS_ERROR;




×







5459



      }










5460



      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);




18,885✔





5461



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




18,885✔





5462



        supp->dbNameSlotId = targetNode->slotId;




9,289✔





5463



      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




9,596✔





5464



        supp->stbNameSlotId = targetNode->slotId;




9,596✔





5465



      }










5466



    }










5467



  }










5468



  return TSDB_CODE_SUCCESS;




26,828✔





5469



}










5470












5471



int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {




26,828✔





5472



  if (pseudoCols != NULL) {




26,828✔





5473



    SNode* pNode = NULL;




26,838✔





5474



    FOREACH(pNode, pseudoCols) {




53,819✔





5475



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




26,828✔





5476



        return TSDB_CODE_QRY_SYS_ERROR;




×







5477



      }










5478



      STargetNode* targetNode = (STargetNode*)pNode;




26,828✔





5479



      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {




26,828✔





5480



        return TSDB_CODE_QRY_SYS_ERROR;




×







5481



      }










5482



      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);




27,011✔





5483



      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {




27,001✔





5484



        supp->tbCountSlotId = targetNode->slotId;




26,991✔





5485



      }










5486



    }










5487



  }










5488



  return TSDB_CODE_SUCCESS;




26,991✔





5489



}










5490












5491



int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {




27,001✔





5492



  if (groupTags != NULL) {




27,001✔





5493



    SNode* pNode = NULL;




14,154✔





5494



    FOREACH(pNode, groupTags) {




33,039✔





5495



      if (nodeType(pNode) != QUERY_NODE_COLUMN) {




18,885✔





5496



        return TSDB_CODE_QRY_SYS_ERROR;




×







5497



      }










5498



      SColumnNode* colNode = (SColumnNode*)pNode;




18,885✔





5499



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




18,885✔





5500



        supp->groupByDbName = true;




9,289✔





5501



      }










5502



      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




18,885✔





5503



        supp->groupByStbName = true;




9,596✔





5504



      }










5505



    }










5506



  } else {










5507



    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);




12,847✔





5508



    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);




12,857✔





5509



  }










5510



  return TSDB_CODE_SUCCESS;




27,001✔





5511



}










5512












5513



int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,




27,001✔





5514



                              STableCountScanSupp* supp, SExecTaskInfo* taskInfo) {










5515



  int32_t code = 0;




27,001✔





5516



  code = tblCountScanGetInputs(groupTags, tableName, supp);




27,001✔





5517



  if (code != TSDB_CODE_SUCCESS) {




27,001✔





5518



    qError("%s get table count scan supp. get inputs error", GET_TASKID(taskInfo));




×







5519



    return code;




×







5520



  }










5521












5522



  supp->dbNameSlotId = -1;




27,001✔





5523



  supp->stbNameSlotId = -1;




27,001✔





5524



  supp->tbCountSlotId = -1;




27,001✔





5525












5526



  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);




26,991✔





5527



  if (code != TSDB_CODE_SUCCESS) {




26,808✔





5528



    qError("%s get table count scan supp. get group tags slot id error", GET_TASKID(taskInfo));




×







5529



    return code;




×







5530



  }










5531












5532



  code = tblCountScanGetCountSlotId(pseudoCols, supp);




26,808✔





5533



  if (code != TSDB_CODE_SUCCESS) {




26,981✔





5534



    qError("%s get table count scan supp. get count error", GET_TASKID(taskInfo));




×







5535



    return code;




×







5536



  }










5537



  return code;




26,991✔





5538



}










5539












5540



int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,




26,838✔





5541



                                         SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










5542



  QRY_PARAM_CHECK(pOptrInfo);




26,838✔





5543












5544



  int32_t                      code = TSDB_CODE_SUCCESS;




27,011✔





5545



  int32_t                      lino = 0;




27,011✔





5546



  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;




27,011✔





5547



  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));




26,838✔





5548



  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




27,001✔





5549



  if (!pInfo || !pOperator) {




27,011✔





5550



    code = terrno;




×







5551



    goto _error;




×







5552



  }










5553












5554



  pInfo->readHandle = *readHandle;




27,011✔





5555












5556



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




27,011✔





5557



  initResultSizeInfo(&pOperator->resultInfo, 1);




27,011✔





5558



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




27,011✔





5559



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




27,001✔





5560












5561



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




27,001✔





5562



  QUERY_CHECK_CODE(code, lino, _error);




27,011✔





5563












5564



  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,




27,011✔





5565



                               pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp,










5566



                               pTaskInfo);










5567



  QUERY_CHECK_CODE(code, lino, _error);




26,991✔





5568












5569



  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,




26,991✔





5570



                  pInfo, pTaskInfo);










5571



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,




26,808✔





5572



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










5573



  *pOptrInfo = pOperator;




26,981✔





5574



  return code;




26,981✔





5575












5576



_error:




×







5577



  if (pInfo != NULL) {




×







5578



    destoryTableCountScanOperator(pInfo);




×







5579



  }










5580



  if (pOperator != NULL) {




×







5581



    pOperator->info = NULL;




×







5582



    destroyOperator(pOperator);




×







5583



  }










5584



  pTaskInfo->code = code;




×







5585



  return code;




×







5586



}










5587












5588



int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,




36,634✔





5589



                                    SSDataBlock* pRes) {










5590



  int32_t code = TSDB_CODE_SUCCESS;




36,634✔





5591



  int32_t lino = 0;




36,634✔





5592



  if (pSupp->dbNameSlotId != -1) {




36,634✔





5593



    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




13,990✔





5594



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);




13,990✔





5595



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




13,990✔





5596












5597



    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,990✔





5598



    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);




13,990✔





5599












5600



    varDataSetLen(varDbName, strlen(dbName));




13,990✔





5601



    code = colDataSetVal(colInfoData, 0, varDbName, false);




13,850✔





5602



    QUERY_CHECK_CODE(code, lino, _end);




13,990✔





5603



  }










5604












5605



  if (pSupp->stbNameSlotId != -1) {




36,665✔





5606



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);




18,322✔





5607



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




18,322✔





5608



    if (strlen(stbName) != 0) {




18,322✔





5609



      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,104✔





5610



      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);




13,104✔





5611



      varDataSetLen(varStbName, strlen(stbName));




13,104✔





5612



      code = colDataSetVal(colInfoData, 0, varStbName, false);




13,104✔





5613



      QUERY_CHECK_CODE(code, lino, _end);




13,104✔





5614



    } else {










5615



      colDataSetNULL(colInfoData, 0);










5616



    }










5617



  }










5618












5619



  if (pSupp->tbCountSlotId != -1) {




36,461✔





5620



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);




36,502✔





5621



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




36,634✔





5622



    code = colDataSetVal(colInfoData, 0, (char*)&count, false);




36,634✔





5623



    QUERY_CHECK_CODE(code, lino, _end);




36,634✔





5624



  }










5625



  pRes->info.rows = 1;




36,593✔





5626












5627



_end:




36,665✔





5628



  if (code != TSDB_CODE_SUCCESS) {




36,665✔





5629



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5630



  }










5631



  return code;




36,624✔





5632



}










5633












5634



static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {




10,559✔





5635



  STableCountScanSupp* pSupp = &pInfo->supp;




10,559✔





5636



  SSDataBlock*         pRes = pInfo->pRes;




10,559✔





5637












5638



  size_t infodbTableNum;




10,559✔





5639



  getInfosDbMeta(NULL, &infodbTableNum);




10,559✔





5640



  infodbTableNum -= 1;




10,559✔





5641



  size_t perfdbTableNum;




10,559✔





5642



  getPerfDbMeta(NULL, &perfdbTableNum);




10,559✔





5643












5644



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




10,559✔





5645



    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);




9,036✔





5646



    return (pRes->info.rows > 0) ? pRes : NULL;




9,036✔





5647



  } else {










5648



    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);




1,523✔





5649



    return (pRes->info.rows > 0) ? pRes : NULL;




1,523✔





5650



  }










5651



}










5652












5653



static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,




1,523✔





5654



                                       size_t infodbTableNum, size_t perfdbTableNum) {










5655



  int32_t        code = TSDB_CODE_SUCCESS;




1,523✔





5656



  int32_t        lino = 0;




1,523✔





5657



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,523✔





5658



  if (strlen(pSupp->stbNameFilter) != 0) {




1,523✔





5659



    // sys dbs do not contain any stable, so the count is always 0










5660



    code = fillTableCountScanDataBlock(pSupp, "", "", 0, pRes);




519✔





5661



    QUERY_CHECK_CODE(code, lino, _end);




519✔





5662



  } else if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) {




1,004✔





5663



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




173✔





5664



    QUERY_CHECK_CODE(code, lino, _end);




173✔





5665



  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {




831✔





5666



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




×







5667



    QUERY_CHECK_CODE(code, lino, _end);




×







5668



  } else if (strlen(pSupp->dbNameFilter) == 0) {




831✔





5669



    code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes);




658✔





5670



    QUERY_CHECK_CODE(code, lino, _end);




658✔





5671



  } else {










5672



    // other dbs do not exist in sys dbs, so the count is always 0










5673



    code = fillTableCountScanDataBlock(pSupp, pSupp->dbNameFilter, pSupp->stbNameFilter, 0, pRes);




173✔





5674



    QUERY_CHECK_CODE(code, lino, _end);




173✔





5675



  }










5676












5677



_end:




173✔





5678



  if (code != TSDB_CODE_SUCCESS) {




1,523✔





5679



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5680



    pTaskInfo->code = code;




×







5681



    T_LONG_JMP(pTaskInfo->env, code);




×







5682



  }










5683



  setOperatorCompleted(pOperator);




1,523✔





5684



}




1,523✔





5685












5686



static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




9,036✔





5687



                                        STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5688



                                        size_t perfdbTableNum) {










5689



  int32_t        code = TSDB_CODE_SUCCESS;




9,036✔





5690



  int32_t        lino = 0;




9,036✔





5691



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,036✔





5692



  if (pInfo->currGrpIdx == 0) {




9,036✔





5693



    uint64_t groupId = 0;




3,012✔





5694



    if (pSupp->groupByDbName) {




3,012✔





5695



      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));




2,049✔





5696



    } else {










5697



      groupId = calcGroupId("", 0);




963✔





5698



    }










5699












5700



    pRes->info.id.groupId = groupId;




3,012✔





5701



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




3,012✔





5702



    QUERY_CHECK_CODE(code, lino, _end);




3,012✔





5703



  } else if (pInfo->currGrpIdx == 1) {




6,024✔





5704



    uint64_t groupId = 0;




3,012✔





5705



    if (pSupp->groupByDbName) {




3,012✔





5706



      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));




2,049✔





5707



    } else {










5708



      groupId = calcGroupId("", 0);




963✔





5709



    }










5710












5711



    pRes->info.id.groupId = groupId;




3,012✔





5712



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




3,012✔





5713



    QUERY_CHECK_CODE(code, lino, _end);




3,012✔





5714



  } else {










5715



    setOperatorCompleted(pOperator);




3,012✔





5716



  }










5717



  pInfo->currGrpIdx++;




9,036✔





5718












5719



_end:




9,036✔





5720



  if (code != TSDB_CODE_SUCCESS) {




9,036✔





5721



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5722



    pTaskInfo->code = code;




×







5723



    T_LONG_JMP(pTaskInfo->env, code);




×







5724



  }










5725



}




9,036✔





5726












5727



static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




63,472✔





5728



  int32_t                      code = TSDB_CODE_SUCCESS;




63,472✔





5729



  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;




63,472✔





5730



  STableCountScanOperatorInfo* pInfo = pOperator->info;




63,513✔





5731



  STableCountScanSupp*         pSupp = &pInfo->supp;




63,513✔





5732



  SSDataBlock*                 pRes = pInfo->pRes;




63,513✔





5733












5734



  blockDataCleanup(pRes);




63,503✔





5735



  QRY_PARAM_CHECK(ppRes);




63,513✔





5736












5737



  if (pOperator->status == OP_EXEC_DONE) {




63,513✔





5738



    return code;




16,467✔





5739



  }










5740












5741



  if (pInfo->readHandle.mnd != NULL) {




47,209✔





5742



    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);




10,559✔





5743



    return code;




10,559✔





5744



  }










5745












5746



  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);




36,640✔





5747



  if (code != TSDB_CODE_SUCCESS) {




36,599✔





5748



    qError("%s failed since %s", __func__, tstrerror(code));




×







5749



    pTaskInfo->code = code;




×







5750



    T_LONG_JMP(pTaskInfo->env, code);




×







5751



  }










5752



  if (pRes->info.rows > 0) {




36,599✔





5753



    *ppRes = pRes;




29,128✔





5754



  }










5755












5756



  return code;




36,650✔





5757



}










5758












5759



static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




36,500✔





5760



                                      STableCountScanSupp* pSupp, SSDataBlock* pRes) {










5761



  int32_t        code = TSDB_CODE_SUCCESS;




36,500✔





5762



  int32_t        lino = 0;




36,500✔





5763



  const char*    db = NULL;




36,500✔





5764



  int32_t        vgId = 0;




36,500✔





5765



  char           dbName[TSDB_DB_NAME_LEN] = {0};




36,500✔





5766



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




36,640✔





5767



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




36,640✔





5768












5769



  // get dbname










5770



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);




36,640✔





5771



  SName sn = {0};




36,640✔





5772












5773



  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);




36,650✔





5774



  QUERY_CHECK_CODE(code, lino, _end);




36,640✔





5775












5776



  code = tNameGetDbName(&sn, dbName);




36,640✔





5777



  QUERY_CHECK_CODE(code, lino, _end);




36,500✔





5778












5779



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




36,500✔





5780



    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);




25,336✔





5781



  } else {










5782



    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);




11,314✔





5783



  }










5784












5785



_end:




36,436✔





5786



  if (code != TSDB_CODE_SUCCESS) {




36,467✔





5787



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5788



    pTaskInfo->code = code;




×







5789



  }










5790












5791



  return code;




36,467✔





5792



}










5793












5794



static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




25,176✔





5795



                                           STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) {










5796



  int32_t        code = TSDB_CODE_SUCCESS;




25,176✔





5797



  int32_t        lino = 0;




25,176✔





5798



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




25,176✔





5799



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




25,316✔





5800












5801



  if (pSupp->groupByStbName) {




25,316✔





5802



    if (pInfo->stbUidList == NULL) {




21,696✔





5803



      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));




7,522✔





5804



      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);




7,522✔





5805



      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);




7,522✔





5806



      QUERY_CHECK_CODE(code, lino, _end);




7,522✔





5807



    }










5808












5809



    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {




21,696✔





5810



      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);




13,104✔





5811



      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);




13,104✔





5812



      QUERY_CHECK_CODE(code, lino, _end);




13,104✔





5813












5814



      pInfo->currGrpIdx++;




13,104✔





5815



    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {




8,592✔





5816



      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);




7,522✔





5817



      QUERY_CHECK_CODE(code, lino, _end);




7,522✔





5818












5819



      pInfo->currGrpIdx++;




7,522✔





5820



    } else {










5821



      setOperatorCompleted(pOperator);




1,070✔





5822



    }










5823



  } else {










5824



    uint64_t groupId = calcGroupId(dbName, strlen(dbName));




3,620✔





5825



    pRes->info.id.groupId = groupId;




3,620✔





5826












5827



    int64_t dbTableCount = 0;




3,620✔





5828



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);




3,620✔





5829



    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);




3,620✔





5830



    QUERY_CHECK_CODE(code, lino, _end);




3,620✔





5831



    setOperatorCompleted(pOperator);




3,620✔





5832



  }










5833












5834



_end:




25,316✔





5835



  if (code != TSDB_CODE_SUCCESS) {




25,316✔





5836



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5837



    pTaskInfo->code = code;




×







5838



  }










5839



  return code;




25,316✔





5840



}










5841












5842



static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




11,324✔





5843



                                         STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) {










5844



  int32_t        code = TSDB_CODE_SUCCESS;




11,324✔





5845



  int32_t        lino = 0;




11,324✔





5846



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




11,324✔





5847



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




11,324✔





5848












5849



  if (strlen(pSupp->dbNameFilter) != 0 && strcmp(dbName, pSupp->dbNameFilter) != 0) {




11,324✔





5850



    // db name not match, return count 0










5851



    code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




×







5852



    QUERY_CHECK_CODE(code, lino, _end);




×







5853



  } else if (strlen(pSupp->stbNameFilter) != 0) {




11,324✔





5854



    uint64_t uid = 0;




5,564✔





5855



    code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid);




5,564✔





5856



    if (code == TSDB_CODE_TDB_TABLE_NOT_EXIST) {




5,523✔





5857



      // table not exist, return count 0










5858



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




1,384✔





5859



      QUERY_CHECK_CODE(code, lino, _end);




1,415✔





5860



    } else {










5861



      QUERY_CHECK_CODE(code, lino, _end);




4,139✔





5862












5863



      int64_t numOfChildTables = 0;




4,139✔





5864



      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL, NULL);




4,170✔





5865



      QUERY_CHECK_CODE(code, lino, _end);




4,180✔





5866












5867



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes);




4,180✔





5868



      QUERY_CHECK_CODE(code, lino, _end);




4,139✔





5869



    }










5870



  } else {










5871



    int64_t tbNumVnode = 0;




5,760✔





5872



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);




5,760✔





5873



    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);




5,760✔





5874



    QUERY_CHECK_CODE(code, lino, _end);




5,760✔





5875



  }










5876












5877



_end:




11,314✔





5878



  if (code != TSDB_CODE_SUCCESS) {




11,314✔





5879



    pTaskInfo->code = code;




×







5880



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5881



  }










5882












5883



  setOperatorCompleted(pOperator);




11,314✔





5884



  return code;




11,293✔





5885



}










5886












5887



static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




7,522✔





5888



                                              SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) {










5889



  int32_t code = TSDB_CODE_SUCCESS;




7,522✔





5890



  int32_t lino = 0;




7,522✔





5891



  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




7,522✔





5892



  if (pSupp->groupByDbName) {




7,522✔





5893



    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");




3,620✔





5894



  }










5895












5896



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




7,522✔





5897



  pRes->info.id.groupId = groupId;




7,522✔





5898












5899



  int64_t numOfTables = 0;




7,522✔





5900



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);




7,522✔





5901












5902



  if (numOfTables != 0) {




7,522✔





5903



    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);




1,070✔





5904



  }










5905












5906



_end:




6,452✔





5907



  if (code != TSDB_CODE_SUCCESS) {




7,522✔





5908



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5909



  }










5910



  return code;




7,522✔





5911



}










5912












5913



static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




13,104✔





5914



                                              SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) {










5915



  int32_t code = TSDB_CODE_SUCCESS;




13,104✔





5916



  int32_t lino = 0;




13,104✔





5917



  char    stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,104✔





5918



  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);




13,104✔





5919



  QUERY_CHECK_CODE(code, lino, _end);




13,104✔





5920












5921



  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




13,104✔





5922



  if (pSupp->groupByDbName) {




13,104✔





5923



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));




5,992✔





5924



  } else {










5925



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));




7,112✔





5926



  }










5927












5928



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




13,104✔





5929



  pRes->info.id.groupId = groupId;




12,964✔





5930












5931



  int64_t ctbNum = 0;




13,104✔





5932



  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL, NULL);




12,964✔





5933



  QUERY_CHECK_CODE(code, lino, _end);




13,104✔





5934



  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);




13,104✔





5935



  QUERY_CHECK_CODE(code, lino, _end);




13,104✔





5936












5937



_end:




13,104✔





5938



  if (code != TSDB_CODE_SUCCESS) {




13,104✔





5939



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5940



  }










5941



  return code;




13,104✔





5942



}










5943












5944



static void destoryTableCountScanOperator(void* param) {




27,011✔





5945



  STableCountScanOperatorInfo* pTableCountScanInfo = param;




27,011✔





5946



  blockDataDestroy(pTableCountScanInfo->pRes);




27,011✔





5947












5948



  taosArrayDestroy(pTableCountScanInfo->stbUidList);




27,011✔





5949



  taosMemoryFreeClear(param);




27,011✔





5950



}




27,011✔



















    

  • 

    •