taosdata / TDengine / #4982

coverage: 68.587% (+0.1%) from 68.488%
#4982

push

travis-ci

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

merge: from main to 3.0 branch

279 of 443 new or added lines in 34 files covered. (62.98%)

2352 existing lines in 132 files now uncovered.

212163 of 309332 relevant lines covered (68.59%)

135254549.82 hits per line

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

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




691,543,608✔





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;




691,543,608✔





89



#endif










90



}










91












92



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




68,429✔





93



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




68,429✔





94



    SWITCH_ORDER(pCtx[i].order);




×







95



  }










96



}




68,429✔





97












98



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




697,078,705✔





99



  int32_t     code = TSDB_CODE_SUCCESS;




697,078,705✔





100



  STimeWindow w = {0};




697,078,705✔





101












102



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










103



  if (pInterval->interval == 0) {




697,455,828✔





104



    *overlap = false;




657,114,810✔





105



    return code;




657,058,470✔





106



  }










107












108



  if (order == TSDB_ORDER_ASC) {




40,252,754✔





109



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




38,103,900✔





110



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




38,110,134✔





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




38,075,795✔





116



      *overlap = true;




33,082,872✔





117



      return code;




33,074,989✔





118



    }










119












120



    while (1) {










121



      getNextTimeWindow(pInterval, &w, order);




5,007,337✔





122



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




5,022,686✔





123



        break;




4,746,926✔





124



      }










125












126



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




274,796✔





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




274,264✔





131



        *overlap = true;




274,264✔





132



        return code;




274,796✔





133



      }










134



    }










135



  } else {










136



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




2,148,854✔





137



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




2,153,180✔





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




2,151,542✔





143



      *overlap = true;




1,685,053✔





144



      return code;




1,684,809✔





145



    }










146












147



    while (1) {










148



      getNextTimeWindow(pInterval, &w, order);




466,098✔





149



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




466,098✔





150



        break;




463,470✔





151



      }










152












153



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




2,628✔





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





158



        *overlap = true;




2,628✔





159



        return code;




2,628✔





160



      }










161



    }










162



  }










163












164



  *overlap = false;




5,210,396✔





165



  return code;




5,205,273✔





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




182,077,107✔





170



  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {




182,077,107✔





171



    return NULL;




×







172



  }










173












174



  int64_t buf[2] = {0};




182,119,113✔





175



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




182,113,188✔





176












177



  STableScanInfo* pTableScanInfo = pOperator->info;




181,961,157✔





178












179



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




181,991,055✔





180



                                                               buf, GET_RES_WINDOW_KEY_LEN(sizeof(groupId)));










181












182



  if (p1 == NULL) {




182,174,919✔





183



    return NULL;




52,310,399✔





184



  }










185












186



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




129,864,520✔





187



  if (NULL == *pPage) {




129,802,185✔





188



    return NULL;




×







189



  }










190












191



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




129,816,125✔





192



}










193












194



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




14,992,275✔





195



  if (NULL == pTableScanInfo->pIgnoreTables) {




14,992,275✔





196



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




2,357,900✔





197



    pTableScanInfo->pIgnoreTables =




2,357,531✔





198



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




2,356,710✔





199



    if (NULL == pTableScanInfo->pIgnoreTables) {




2,357,531✔





200



      return terrno;




×







201



    }










202



  }










203












204



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




14,994,000✔





205



                                sizeof(pTableScanInfo->scanTimes));










206



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




14,991,666✔





207



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




×







208



    return tempRes;




×







209



  }










210



  return TSDB_CODE_SUCCESS;




14,991,666✔





211



}










212












213



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




778,970,283✔





214



  STableScanInfo* pTableScanInfo = pOperator->info;




778,970,283✔





215



  int32_t         code = TSDB_CODE_SUCCESS;




779,725,481✔





216












217



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




779,725,481✔





218



    return TSDB_CODE_SUCCESS;




597,330,507✔





219



  }










220












221



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




182,059,764✔





222












223



  SFilePage*  pPage = NULL;




182,104,106✔





224



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




182,096,572✔





225












226



  if (pRow == NULL) {




182,112,821✔





227



    return TSDB_CODE_SUCCESS;




52,293,949✔





228



  }










229












230



  bool notLoadBlock = true;




129,818,872✔





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;




114,834,041✔





239



      break;




114,834,041✔





240



    }










241



  }










242












243



  // release buffer pages










244



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




128,595,132✔





245












246



  if (notLoadBlock) {




129,800,395✔





247



    *status = FUNC_DATA_REQUIRED_NOT_LOAD;




14,995,873✔





248



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




14,993,178✔





249



  }










250












251



  return code;




129,675,958✔





252



}










253












254



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




9,465,427✔





255



                                  int32_t numOfRows, bool* keep) {










256



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




9,465,427✔





257



    *keep = true;




×







258



    return TSDB_CODE_SUCCESS;




×







259



  }










260












261



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




9,467,909✔





262



}










263












264



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




208,134,273✔





265



                              bool* pLoad) {










266



  SStorageAPI* pAPI = &pTaskInfo->storageAPI;




208,134,273✔





267



  bool         allColumnsHaveAgg = true;




208,294,371✔





268



  bool         hasNullSMA = false;




208,301,636✔





269



  if (pLoad != NULL) {




208,246,700✔





270



    *pLoad = false;




208,195,848✔





271



  }










272












273



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




208,270,592✔





274



                                                               &hasNullSMA);










275



  if (code != TSDB_CODE_SUCCESS) {




208,060,700✔





276



    return code;




×







277



  }










278












279



  if (!allColumnsHaveAgg || hasNullSMA) {




208,060,700✔





280



    *pLoad = false;




175,800,805✔





281



  } else {










282



    *pLoad = true;




32,259,895✔





283



  }










284












285



  return code;




207,928,942✔





286



}










287












288



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




758,334,009✔





289



                                  int32_t rows) {










290



  int32_t    code = 0;




758,334,009✔





291



  SExprSupp* pSup = &pTableScanInfo->pseudoSup;




758,334,009✔





292



  if (pSup->numOfExprs > 0) {




759,516,846✔





293



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




299,324,790✔





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




298,866,830✔






UNCOV

297



      code = 0;




×







298



    }










299



  }










300












301



  return code;




759,127,954✔





302



}










303












304



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




1,242,199,734✔





305



  SLimit*     pLimit = &pLimitInfo->limit;




1,242,199,734✔





306



  const char* id = GET_TASKID(pTaskInfo);




1,242,340,853✔





307












308



  if (pLimitInfo->remainOffset > 0) {




1,242,487,156✔





309



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




5,105,339✔





310



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




2,629,065✔





311



      blockDataEmpty(pBlock);




2,629,065✔





312



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




2,629,065✔





313



      return false;




2,629,065✔





314



    } else {










315



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




2,476,274✔





316



      if (code != TSDB_CODE_SUCCESS) {




2,476,274✔






UNCOV

317



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




×







318



        pTaskInfo->code = code;




×







319



        T_LONG_JMP(pTaskInfo->env, code);




×







320



      }










321



      pLimitInfo->remainOffset = 0;




2,476,274✔





322



    }










323



  }










324












325



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




1,240,123,935✔





326



    // limit the output rows










327



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




26,043,133✔





328



    blockDataKeepFirstNRows(pBlock, keep);




26,043,968✔





329












330



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




26,040,451✔





331



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




26,042,028✔





332



    return true;




26,045,703✔





333



  }










334












335



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




1,213,393,281✔





336



  return false;




1,214,226,941✔





337



}










338












339



static bool skipSetTagColumnData(SOperatorInfo* pOperator) {




808,132,192✔





340



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




1,483,539,329✔





341



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




674,865,433✔





342



}










343












344



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




828,293,547✔





345



                             uint32_t* status) {










346



  int32_t        code = TSDB_CODE_SUCCESS;




828,293,547✔





347



  int32_t        lino = 0;




828,293,547✔





348



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




828,293,547✔





349



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




828,670,153✔





350



  bool           loadSMA = false;




828,473,798✔





351












352



  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;




828,473,798✔





353












354



  pCost->totalBlocks += 1;




828,377,584✔





355



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




828,564,730✔





356



  *status = pTableScanInfo->dataBlockLoadFlag;




828,277,806✔





357












358



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




828,402,776✔





359



    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




130,692,863✔





360



  } else {










361



    bool overlap = false;




697,416,085✔





362



    int  ret =










363



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




697,487,999✔





364



    if (ret != TSDB_CODE_SUCCESS) {




696,475,585✔






UNCOV

365



      return ret;




×







366



    }










367



    if (overlap) {




696,475,585✔





368



      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




35,030,525✔





369



    }










370



  }










371












372



  SDataBlockInfo* pBlockInfo = &pBlock->info;




828,125,377✔





373



  taosMemoryFreeClear(pBlock->pBlockAgg);




828,146,560✔





374












375



  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {




828,042,042✔






UNCOV

376



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




×







377



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











UNCOV

378



    pCost->filterOutBlocks += 1;




×







379



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




×







380



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




×







381



    return TSDB_CODE_SUCCESS;




×







382



  } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




827,158,086✔





383



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




22,206,165✔





384



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










385



           pBlockInfo->id.uid);










386



    if (!skipSetTagColumnData(pOperator)) {




22,260,867✔





387



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




22,312,086✔





388



    }










389



    pCost->skipBlocks += 1;




22,305,196✔





390



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




22,308,845✔





391



    return code;




22,306,281✔





392



  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {




805,037,512✔





393



    pCost->loadBlockStatis += 1;




77,591,099✔





394



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




77,532,814✔





395



    bool success = true;




77,532,814✔





396



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




77,544,916✔





397



    if (code) {




77,382,321✔






UNCOV

398



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




×







399



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




×







400



      QUERY_CHECK_CODE(code, lino, _end);




×







401



    }










402












403



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




77,352,689✔





404



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




22,759,486✔





405



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










406



      if (!skipSetTagColumnData(pOperator)) {




22,759,566✔





407



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




5,572,400✔





408



      }










409



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




22,805,914✔





410



      return code;




22,779,376✔





411



    } else {










412



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




54,593,203✔





413



      *status = FUNC_DATA_REQUIRED_DATA_LOAD;




54,763,884✔





414



    }










415



  }










416












417



  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {




781,872,744✔






UNCOV

418



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




×







419



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




×







420



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







421



  }










422












423



  // try to filter data block according to sma info










424



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




781,799,152✔





425



    bool success = true;




130,613,128✔





426



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




130,679,992✔





427



    if (code) {




130,503,152✔






UNCOV

428



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




×







429



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




×







430



      QUERY_CHECK_CODE(code, lino, _end);




19,463✔





431



    }










432












433



    if (success) {




130,522,559✔





434



      size_t size = taosArrayGetSize(pBlock->pDataBlock);




9,466,303✔





435



      bool   keep = false;




9,466,449✔





436



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




9,466,595✔





437



      if (code) {




9,465,684✔






UNCOV

438



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




×







439



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




×







440



        QUERY_CHECK_CODE(code, lino, _end);




×







441



      }










442












443



      if (!keep) {




9,465,684✔





444



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




3,415,598✔





445



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










446



        pCost->filterOutBlocks += 1;




3,416,151✔





447



        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;




3,416,151✔





448



        taosMemoryFreeClear(pBlock->pBlockAgg);




3,416,151✔





449












450



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




3,416,151✔





451



        return TSDB_CODE_SUCCESS;




3,416,151✔





452



      }










453



    }










454



  }










455












456



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










457



  taosMemoryFreeClear(pBlock->pBlockAgg);




779,159,619✔





458












459



  // try to filter data block according to current results










460



  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);




778,526,341✔





461



  if (code) {




779,343,407✔






UNCOV

462



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




×







463



    QUERY_CHECK_CODE(code, lino, _end);




×







464



  }










465












466



  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




779,343,420✔





467



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




14,996,384✔





468



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










469



    pCost->skipBlocks += 1;




15,005,114✔





470



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




14,998,082✔





471












472



    STableScanInfo* p1 = pOperator->info;




14,997,405✔





473



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




14,997,405✔





474



      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;




5,152,947✔





475



    } else {










476



      *status = FUNC_DATA_REQUIRED_FILTEROUT;




9,845,062✔





477



    }










478



    return TSDB_CODE_SUCCESS;




14,998,604✔





479



  }










480












481



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




763,712,998✔





482



  pCost->loadBlocks += 1;




763,971,649✔





483












484



  SSDataBlock* p = NULL;




763,501,556✔





485



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




763,636,798✔





486



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




764,109,589✔






UNCOV

487



    return code;




×







488



  }










489












490



  if (!skipSetTagColumnData(pOperator)) {




764,109,589✔





491



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




683,681,631✔





492



    QUERY_CHECK_CODE(code, lino, _end);




683,124,973✔





493



  }










494












495



  // restore the previous value










496



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




763,630,403✔





497












498



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




764,567,532✔





499



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




127,274,290✔





500



    QUERY_CHECK_CODE(code, lino, _end);




127,227,054✔





501












502



    int64_t st = taosGetTimestampUs();




126,345,861✔





503



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




126,286,681✔





504



    pTableScanInfo->readRecorder.filterTime += el;




126,286,681✔





505












506



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




126,300,476✔





507



      pCost->filterOutBlocks += 1;




34,705,746✔





508



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




34,696,597✔





509



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










510



    } else {










511



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




91,450,553✔





512



    }










513



  }










514












515



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




763,452,472✔





516



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




763,767,815✔





517



    setOperatorCompleted(pOperator);




2,980,929✔





518



  }










519












520



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




763,766,945✔





521












522



_end:




764,836,201✔





523



  if (code != TSDB_CODE_SUCCESS) {




764,743,826✔





524



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




968,067✔





525



  }










526



  return code;




763,794,590✔





527



}










528












529



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




68,429✔





530



  SET_REVERSE_SCAN_FLAG(pTableScanInfo);




68,429✔





531












532



  switchCtxOrder(pCtx, numOfOutput);




68,429✔





533



  pTableScanInfo->cond.order = TSDB_ORDER_DESC;




68,429✔





534



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










535



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










536



}




68,429✔





537












538



typedef struct STableCachedVal {










539



  const char* pName;










540



  STag*       pTags;










541



} STableCachedVal;










542













UNCOV

543



static void freeTableCachedVal(void* param) {




×







544



  if (param == NULL) {




×







545



    return;




×







546



  }










547













UNCOV

548



  STableCachedVal* pVal = param;




×







549



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




×







550



  taosMemoryFree(pVal->pTags);




×







551



  taosMemoryFree(pVal);




×







552



}










553













UNCOV

554



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




×







555



  int32_t          code = TSDB_CODE_SUCCESS;




×







556



  int32_t          lino = 0;




×







557



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




×







558



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




×







559













UNCOV

560



  pVal->pTags = NULL;




×







561



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




×







562



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




×







563












564



  // only child table has tag value











UNCOV

565



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




×







566



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




×







567



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




×







568



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




×







569



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




×







570



  }










571













UNCOV

572



  (*ppResVal) = pVal;




×







573













UNCOV

574



_end:




×







575



  if (code != TSDB_CODE_SUCCESS) {




×







576



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




×







577



    freeTableCachedVal(pVal);




×







578



  }











UNCOV

579



  return code;




×







580



}










581












582



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











UNCOV

583



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




×







584



  (void)key;










585



  (void)keyLen;










586



  (void)ud;











UNCOV

587



  freeTableCachedVal(value);




×







588



}




×







589













UNCOV

590



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




×







591



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




×







592



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




×







593













UNCOV

594



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




×







595



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




×







596



  }











UNCOV

597



}




×







598












599



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




299,330,850✔





600



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










601



  int32_t          code = TSDB_CODE_SUCCESS;




299,330,850✔





602



  int32_t          lino = 0;




299,330,850✔





603



  bool             freeReader = false;




299,330,850✔





604



  LRUHandle*       h = NULL;




299,330,850✔





605



  STableCachedVal  val = {0};




299,330,850✔





606



  SMetaReader      mr = {0};




299,330,850✔





607



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




299,236,810✔





608



  int32_t          insertRet = TAOS_LRU_STATUS_OK;




299,499,976✔





609



  STableCachedVal* pVal = NULL;




299,499,976✔





610












611



  // currently only the tbname pseudo column










612



  if (numOfExpr <= 0) {




299,754,567✔





613



    return TSDB_CODE_SUCCESS;




172,062✔





614



  }










615












616



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










617












618



  // backup the rows










619



  int32_t backupRows = pBlock->info.rows;




299,582,505✔





620



  pBlock->info.rows = rows;




299,621,222✔





621












622



  // todo refactor: extract method










623



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










624












625



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










626



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




299,498,049✔





627



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




299,403,110✔





628



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




299,693,558✔





629



    if (code != TSDB_CODE_SUCCESS) {




299,149,204✔





630



      // when encounter the TSDB_CODE_PAR_TABLE_NOT_EXIST error, we proceed.











UNCOV

631



      if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







632



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




×







633



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










634












635



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











UNCOV

636



        doSetNullValue(pBlock, pExpr, numOfExpr);




×







637



      } else {











UNCOV

638



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




×







639



      }











UNCOV

640



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




×







641



      return code;




×







642



    }










643












644



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




299,149,204✔





645












646



    val.pName = mr.me.name;




299,524,970✔





647



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




299,524,970✔





648












649



    freeReader = true;




299,524,970✔





650



  } else {











UNCOV

651



    pCache->metaFetch += 1;




×







652













UNCOV

653



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




×







654



    if (h == NULL) {




×







655



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




×







656



      freeReader = true;




×







657



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




×







658



      if (code != TSDB_CODE_SUCCESS) {




×







659



        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







660



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




×







661



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










662



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











UNCOV

663



          doSetNullValue(pBlock, pExpr, numOfExpr);




×







664



        } else {











UNCOV

665



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




×







666



                 idStr);










667



        }











UNCOV

668



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




×







669



        return code;




×







670



      }










671













UNCOV

672



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




×







673













UNCOV

674



      code = createTableCacheVal(&mr, &pVal);




×







675



      QUERY_CHECK_CODE(code, lino, _end);




×







676













UNCOV

677



      val = *pVal;




×







678



    } else {











UNCOV

679



      pCache->cacheHit += 1;




×







680



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




×







681



      val = *pValTmp;




×







682













UNCOV

683



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




×







684



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




×







685



    }










686













UNCOV

687



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




×







688



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










689



  }










690












691



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




964,014,821✔





692



    const SExprInfo* pExpr1 = &pExpr[j];




664,418,025✔





693



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




664,412,759✔





694












695



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




664,981,677✔





696



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




664,996,772✔





697



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




664,996,772✔





698












699



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




665,038,123✔





700












701



    // this is to handle the tbname










702



    if (fmIsScanPseudoColumnFunc(functionId)) {




665,171,564✔





703



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




102,270,334✔





704



      if (fType == FUNCTION_TYPE_TBNAME) {




102,290,627✔





705



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




102,290,627✔





706



        QUERY_CHECK_CODE(code, lino, _end);




102,230,960✔






UNCOV

707



      } else if (fType == FUNCTION_TYPE_VGID) {




×







708



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




×







709



        QUERY_CHECK_CODE(code, lino, _end);




×







710



      } else if (fType == FUNCTION_TYPE_VGVER) {




×







711



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




×







712



        QUERY_CHECK_CODE(code, lino, _end);




×







713



      }










714



    } else {  // these are tags










715



      STagVal tagVal = {0};




562,167,120✔





716



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




562,273,365✔





717



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




562,699,858✔





718












719



      char* data = NULL;




562,740,117✔





720



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




562,740,117✔





721



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




557,574,518✔





722



      } else {










723



        data = (char*)p;




5,152,913✔





724



      }










725












726



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




562,340,446✔





727



      if (isNullVal) {




562,353,624✔





728



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




4,663,538✔





729



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




557,690,086✔





730



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




557,521,746✔





731



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




557,711,800✔





732



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




211,909,256✔





733



          if (tmp != NULL) {




212,033,007✔





734



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




212,033,007✔





735



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




212,004,490✔





736



                   pBlock->info.id.uid);










737



            taosMemoryFree(tmp);




212,123,520✔





738



          }










739



          taosMemoryFree(data);




212,123,367✔





740



        }










741



        QUERY_CHECK_CODE(code, lino, _end);




557,415,139✔





742



      } else {  // todo opt for json tag










743



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




3,098,681✔





744



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




2,609,476✔





745



          QUERY_CHECK_CODE(code, lino, _end);




2,610,252✔





746



        }










747



      }










748



    }










749



  }










750












751



  // restore the rows










752



  pBlock->info.rows = backupRows;




299,596,796✔





753












754



_end:




299,603,250✔





755












756



  if (NULL != pVal) {




299,633,110✔






UNCOV

757



    insertRet =




×







758



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




×







759



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











UNCOV

760



    if (insertRet != TAOS_LRU_STATUS_OK) {




×







761



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




×







762



    }










763



  }










764












765



  if (freeReader) {




299,633,110✔





766



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




299,314,910✔





767



  }










768



  if (code != TSDB_CODE_SUCCESS) {




299,674,878✔






UNCOV

769



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




×







770



  }










771



  return code;




299,501,408✔





772



}










773












774



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




102,242,775✔





775



                         const char* name) {










776



  int32_t                     code = TSDB_CODE_SUCCESS;




102,242,775✔





777



  int32_t                     lino = 0;




102,242,775✔





778



  struct SScalarFuncExecFuncs fpSet = {0};




102,242,775✔





779



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




102,257,729✔





780



  QUERY_CHECK_CODE(code, lino, _end);




102,275,104✔





781












782



  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;




102,275,104✔





783



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




102,275,104✔





784



  STR_TO_VARSTR(buf, name)




102,271,182✔





785












786



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




102,226,926✔





787












788



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




102,220,212✔





789



  QUERY_CHECK_CODE(code, lino, _end);




102,254,862✔





790












791



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




102,254,862✔





792



  QUERY_CHECK_CODE(code, lino, _end);




102,226,981✔





793












794



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




102,226,981✔





795



  SScalarParam param = {.columnData = pColInfoData};




102,262,515✔





796












797



  if (fpSet.process != NULL) {




102,167,479✔





798



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




102,167,479✔





799



    QUERY_CHECK_CODE(code, lino, _end);




102,263,162✔





800



  } else {











UNCOV

801



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




×







802



  }










803












804



  colDataDestroy(&infoData);




102,263,162✔





805












806



_end:




102,256,427✔





807



  if (code != TSDB_CODE_SUCCESS) {




102,275,618✔






UNCOV

808



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




×







809



  }










810



  return code;




102,275,618✔





811



}










812













UNCOV

813



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




×







814



  int32_t                     code = TSDB_CODE_SUCCESS;




×







815



  int32_t                     lino = 0;




×







816



  struct SScalarFuncExecFuncs fpSet = {0};




×







817



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







818



  QUERY_CHECK_CODE(code, lino, _end);




×







819













UNCOV

820



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




×







821













UNCOV

822



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




×







823



  QUERY_CHECK_CODE(code, lino, _end);




×







824













UNCOV

825



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




×







826



  QUERY_CHECK_CODE(code, lino, _end);




×







827













UNCOV

828



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




×







829



  SScalarParam param = {.columnData = pColInfoData};




×







830













UNCOV

831



  if (fpSet.process != NULL) {




×







832



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




×







833



    QUERY_CHECK_CODE(code, lino, _end);




×







834



  } else {











UNCOV

835



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




×







836



  }










837













UNCOV

838



_end:




×







839



  colDataDestroy(&infoData);




×







840



  if (code != TSDB_CODE_SUCCESS) {




×







841



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




×







842



  }











UNCOV

843



  return code;




×







844



}










845













UNCOV

846



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




×







847



  int32_t                     code = TSDB_CODE_SUCCESS;




×







848



  int32_t                     lino = 0;




×







849



  struct SScalarFuncExecFuncs fpSet = {0};




×







850



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







851



  QUERY_CHECK_CODE(code, lino, _end);




×







852













UNCOV

853



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




×







854













UNCOV

855



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




×







856



  QUERY_CHECK_CODE(code, lino, _end);




×







857













UNCOV

858



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




×







859



  QUERY_CHECK_CODE(code, lino, _end);




×







860













UNCOV

861



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




×







862



  SScalarParam param = {.columnData = pColInfoData};




×







863













UNCOV

864



  if (fpSet.process != NULL) {




×







865



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




×







866



    QUERY_CHECK_CODE(code, lino, _end);




×







867



  } else {











UNCOV

868



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




×







869



  }










870













UNCOV

871



_end:




×







872



  colDataDestroy(&infoData);




×







873



  if (code != TSDB_CODE_SUCCESS) {




×







874



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




×







875



  }











UNCOV

876



  return code;




×







877



}










878












879



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




258,653,454✔





880



  int32_t code = TSDB_CODE_SUCCESS;




258,653,454✔





881



  int32_t lino = 0;




258,653,454✔





882



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




258,653,454✔





883



  QUERY_CHECK_CODE(code, lino, _end);




258,550,359✔





884












885



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




258,550,359✔





886



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




258,408,887✔





887



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




258,376,903✔





888



  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);




258,370,292✔





889












890



  if (!pInfo->needCountEmptyTable) {




258,592,144✔





891



    pInfo->countState = TABLE_COUNT_STATE_END;




240,527,006✔





892



  } else {










893



    pInfo->countState = TABLE_COUNT_STATE_SCAN;




17,893,351✔





894



  }










895












896



_end:




258,449,851✔





897



  if (code != TSDB_CODE_SUCCESS) {




258,449,851✔






UNCOV

898



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




×







899



  }










900



  return code;




258,155,943✔





901



}










902












903



void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {




688,878,059✔





904



  if (pInfo->countState == TABLE_COUNT_STATE_END) {




688,878,059✔





905



    return;




606,351,962✔





906



  }










907



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




83,146,336✔





908



    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;




219,104✔





909



  } else {










910



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




82,918,335✔





911



    if (code != TSDB_CODE_SUCCESS) {




82,930,171✔





912



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




16,882,148✔





913



    }










914



  }










915



}










916












917



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




47,876,675✔





918



                                         const STableKeyInfo* tbInfo) {










919



  blockDataEmpty(pBlock);




47,876,675✔





920



  pBlock->info.rows = 1;




47,889,153✔





921



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




47,890,197✔





922



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




47,889,725✔





923



  pBlock->info.blankFill = true;




47,886,071✔





924












925



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










926



  int32_t col_num = blockDataGetNumOfCols(pBlock);




47,886,071✔





927



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




197,264,061✔





928



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




149,384,304✔





929



    colDataSetNULL(pColInfoData, 0);










930



  }










931












932



  // set tag/tbname










933



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




47,879,757✔





934












935



  return pBlock;




47,882,417✔





936



}










937












938



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




46,010,444✔





939



  STableScanInfo* pTableScanInfo = pOperator->info;




46,010,444✔





940



  SSDataBlock*    pBlock =










941



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




46,015,664✔





942












943



  pOperator->resultInfo.totalRows++;




46,001,720✔





944



  return pBlock;




46,011,119✔





945



}










946












947



/**










948



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










949



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










950



*/










951



static int32_t prepareTableScan(SOperatorInfo* pOperator) {




919,852,577✔





952



  int32_t code = TSDB_CODE_SUCCESS;




919,852,577✔





953



  int32_t lino = 0;




919,852,577✔





954












955



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




919,852,577✔





956



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




920,215,642✔





957



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




920,977,209✔





958



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




37,756,841✔





959



         NOTIFY_TYPE_SCAN_PARAM &&




3,072,577✔





960



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




3,072,577✔





961



    STableScanOperatorParam* pNotify =




3,072,577✔





962



      (STableScanOperatorParam*)pGetParam->value;










963












964



    STableScanInfo* pTableScanInfo = pOperator->info;




3,072,577✔





965



    SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




3,072,577✔





966



    SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




3,072,577✔





967



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




3,072,577✔





968



                                             pNotify->notifyTs);










969



    QUERY_CHECK_CODE(code, lino, _end);




3,072,577✔





970












971



    if (!pGetParam->reUse) {




3,072,577✔





972



      freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




99,094✔





973



    } else {










974



      /**










975



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










976



        the parent operator after getting next block.










977



      */










978



      pGetParam->reUse = false;




2,973,483✔





979



    }










980



    /**










981



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










982



    */










983



    pOperator->pOperatorGetParam = NULL;




3,072,577✔





984



  }










985












986



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




920,984,343✔





987



_end:




273,392,531✔





988



  if (code != TSDB_CODE_SUCCESS) {




920,946,752✔






UNCOV

989



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




×







990



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










991



  }










992



  return code;




920,938,272✔





993



}










994












995



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




882,271,535✔





996



  int32_t         code = TSDB_CODE_SUCCESS;




882,271,535✔





997



  int32_t         lino = 0;




882,271,535✔





998



  STableScanInfo* pTableScanInfo = pOperator->info;




882,271,535✔





999



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




882,426,839✔





1000



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




882,207,321✔





1001



  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;




882,213,610✔





1002



  bool            hasNext = false;




882,047,109✔





1003



  int64_t         st = taosGetTimestampUs();




881,666,720✔





1004












1005



  QRY_PARAM_CHECK(ppRes);




881,666,720✔





1006



  pBlock->info.dataLoad = false;




882,126,598✔





1007












1008



  while (true) {




42,576,534✔





1009



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




924,315,850✔





1010



    if (code != TSDB_CODE_SUCCESS) {




923,588,237✔






UNCOV

1011



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




×







1012



      QUERY_CHECK_CODE(code, lino, _end);




37,170✔





1013



    }










1014












1015



    if (!hasNext) {




923,621,387✔





1016



      break;




232,468,733✔





1017



    }










1018












1019



    if (isTaskKilled(pTaskInfo)) {




691,152,654✔





1020



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




22,881✔





1021



      code = pTaskInfo->code;




22,881✔





1022



      QUERY_CHECK_CODE(code, lino, _end);




22,881✔





1023



    }










1024












1025



    if (pOperator->status == OP_EXEC_DONE) {




692,379,553✔





1026



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




59,584✔





1027



      break;




59,584✔





1028



    }










1029












1030



    // process this data block based on the probabilities










1031



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




692,149,772✔





1032



    if (!processThisBlock) {




692,057,657✔






UNCOV

1033



      continue;




×







1034



    }










1035












1036



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




692,057,657✔





1037



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




692,362,939✔





1038



    }










1039












1040



    uint32_t status = 0;




692,456,736✔





1041



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




692,418,600✔





1042



    QUERY_CHECK_CODE(code, lino, _end);




691,674,601✔





1043












1044



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




690,724,057✔





1045



      break;




5,151,821✔





1046



    }










1047












1048



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










1049



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




685,572,236✔





1050



      continue;




42,573,402✔





1051



    }










1052












1053



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




643,150,774✔





1054



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




643,439,190✔





1055












1056



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




643,583,050✔





1057



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




643,713,454✔





1058












1059



    (*ppRes) = pBlock;




643,700,367✔





1060



    return code;




643,143,515✔





1061



  }










1062












1063



_end:




238,705,796✔





1064



  if (code != TSDB_CODE_SUCCESS) {




238,749,280✔





1065



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




1,057,567✔





1066



    pTaskInfo->code = code;




1,057,567✔





1067



    T_LONG_JMP(pTaskInfo->env, code);




973,956✔





1068



  }










1069



  return code;




237,691,713✔





1070



}










1071












1072



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




931,230,815✔





1073



  int32_t         code = TSDB_CODE_SUCCESS;




931,230,815✔





1074



  int32_t         lino = 0;




931,230,815✔





1075



  STableScanInfo* pTableScanInfo = pOperator->info;




931,230,815✔





1076



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




931,361,488✔





1077



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




931,001,928✔





1078












1079



  QRY_PARAM_CHECK(pBlock);




931,129,828✔





1080












1081



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










1082



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




931,041,661✔





1083



    return code;




3,023,048✔





1084



  }










1085












1086



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










1087



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




1,149,827,477✔





1088



    SSDataBlock* p = NULL;




826,799,003✔





1089



    code = doTableScanImplNext(pOperator, &p);




826,464,642✔





1090



    QUERY_CHECK_CODE(code, lino, _end);




825,207,141✔





1091












1092



    if (p != NULL) {




825,207,141✔





1093



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




602,953,398✔





1094



      *pBlock = p;




603,149,503✔





1095



      return code;




603,271,794✔





1096



    }










1097












1098



    pTableScanInfo->scanTimes += 1;




222,253,743✔





1099



    taosHashClear(pTableScanInfo->pIgnoreTables);




222,274,567✔





1100












1101



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




222,230,187✔





1102



      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




84,136✔





1103



      pTableScanInfo->base.scanFlag = MAIN_SCAN;




84,136✔





1104



      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




84,136✔





1105



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




84,136✔





1106












1107



      // do prepare for the next round table scan operation










1108



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




84,136✔





1109



      QUERY_CHECK_CODE(code, lino, _end);




68,812✔





1110



    }










1111



  }










1112












1113



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




323,642,003✔





1114



  if (pTableScanInfo->scanTimes < total) {




323,618,213✔





1115



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




55,479,236✔





1116



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




68,429✔





1117



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




68,429✔





1118



      QUERY_CHECK_CODE(code, lino, _end);




68,429✔





1119



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




68,429✔





1120



    }










1121












1122



    while (pTableScanInfo->scanTimes < total) {




70,865,253✔





1123



      SSDataBlock* p = NULL;




55,461,757✔





1124



      code = doTableScanImplNext(pOperator, &p);




55,451,912✔





1125



      QUERY_CHECK_CODE(code, lino, _end);




55,219,718✔





1126












1127



      if (p != NULL) {




55,219,718✔





1128



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




39,798,056✔





1129



        *pBlock = p;




39,957,413✔





1130



        return code;




39,942,594✔





1131



      }










1132












1133



      pTableScanInfo->scanTimes += 1;




15,421,662✔





1134



      taosHashClear(pTableScanInfo->pIgnoreTables);




15,433,244✔





1135












1136



      if (pTableScanInfo->scanTimes < total) {




15,428,764✔






UNCOV

1137



        setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




×







1138



        pTableScanInfo->base.scanFlag = MAIN_SCAN;




×







1139













UNCOV

1140



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




×







1141



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




×







1142



        QUERY_CHECK_CODE(code, lino, _end);




×







1143



      }










1144



    }










1145



  }










1146












1147



  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {




283,479,464✔





1148



    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;




63,202,507✔





1149



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




63,199,973✔





1150



      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {




108,860✔





1151



        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;




1,006✔





1152



        STableKeyInfo* pStart =










1153



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




1,006✔





1154












1155



        if (NULL == pStart) {




1,006✔






UNCOV

1156



          return code;




×







1157



        }










1158












1159



        *pBlock = getBlockForEmptyTable(pOperator, pStart);




1,006✔





1160



        return code;




1,006✔





1161



      }










1162



    } else {  // group by tag + no sort










1163



      int32_t numOfTables = 0;




63,088,100✔





1164



      code = tableListGetSize(pTableListInfo, &numOfTables);




63,080,453✔





1165



      QUERY_CHECK_CODE(code, lino, _end);




63,093,495✔





1166












1167



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




63,093,495✔





1168



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










1169



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




62,161,005✔





1170



        if (pIte != NULL) {




62,157,138✔





1171



          size_t        keySize = 0;




46,008,344✔





1172



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




46,009,388✔





1173



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




46,005,315✔





1174



          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);




46,002,080✔





1175



          markGroupProcessed(pTableScanInfo, *pGroupId);




46,013,564✔





1176



          *pBlock = getBlockForEmptyTable(pOperator, &info);




46,004,740✔





1177












1178



          return code;




46,007,603✔





1179



        }










1180



      }










1181



    }










1182



    pTableScanInfo->countState = TABLE_COUNT_STATE_END;




17,193,798✔





1183



  }










1184












1185



_end:




220,372,081✔





1186



  if (code != TSDB_CODE_SUCCESS) {




237,551,412✔






UNCOV

1187



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




×







1188



    pTaskInfo->code = code;




×







1189



  }










1190












1191



  return code;




237,551,412✔





1192



}










1193












1194



static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {




977,708✔





1195



  STableScanInfo*          pInfo = pOperator->info;




977,708✔





1196



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




977,708✔





1197



  int32_t                  code = 0;




977,708✔





1198



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




977,708✔





1199



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




977,708✔





1200



  int32_t                  num = taosArrayGetSize(pParam->pUidList);




977,708✔





1201



  if (num <= 0) {




977,708✔






UNCOV

1202



    qError("empty table scan uid list");




×







1203



    return TSDB_CODE_INVALID_PARA;




×







1204



  }










1205












1206



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




977,708✔





1207



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










1208



         pOperator->status);










1209












1210



  if (pParam->tableSeq) {




977,708✔





1211



    pListInfo->oneTableForEachGroup = true;




727,797✔





1212



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




727,797✔






UNCOV

1213



      taosHashClear(pListInfo->map);




×







1214



      taosArrayClear(pListInfo->pTableList);




×







1215



      pOperator->status = OP_EXEC_DONE;




×







1216



    }










1217



  } else {










1218



    pListInfo->oneTableForEachGroup = false;




249,911✔





1219



    pListInfo->numOfOuputGroups = 1;




249,911✔





1220



  }










1221



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




977,708✔





1222



    // do nothing










1223



  } else {










1224



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




723,261✔





1225



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




723,261✔





1226



  }










1227












1228



  STableKeyInfo info = {.groupId = 0};




977,708✔





1229



  int32_t       tableIdx = 0;




977,708✔





1230



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




9,121,758✔





1231



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




8,144,050✔





1232



    if (!pUid) {




8,139,914✔






UNCOV

1233



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




×







1234



      return terrno;




×







1235



    }










1236












1237



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




8,139,914✔





1238



      if (TSDB_CODE_DUP_KEY == terrno) {




6,818,923✔





1239



        continue;




6,815,821✔





1240



      }











UNCOV

1241



      return terrno;




×







1242



    }










1243












1244



    info.uid = *pUid;




1,331,331✔





1245



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




1,331,331✔





1246



    if (p == NULL) {




1,330,943✔






UNCOV

1247



      return terrno;




×







1248



    }










1249












1250



    tableIdx++;




1,330,943✔





1251



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




1,330,943✔





1252



  }










1253












1254



  return code;




977,708✔





1255



}










1256












1257



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




239,115,110✔





1258



                            STableKeyInfo** pList) {










1259



  const char* idStr = GET_TASKID(pTaskInfo);




239,115,110✔





1260



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




239,204,980✔





1261



  if (code) {




238,471,673✔






UNCOV

1262



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




×







1263



    return code;




×







1264



  }










1265












1266



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




238,471,673✔






UNCOV

1267



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




×







1268



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







1269



  }










1270












1271



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




477,192,284✔





1272



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




238,958,395✔





1273



  if (code) {




238,671,303✔





1274



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




2,270✔





1275



  }










1276












1277



  return code;




238,295,066✔





1278



}










1279












1280



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




365,925,838✔





1281



  SColIdPair* node1 = (SColIdPair*)elem1;




365,925,838✔





1282



  SColIdPair* node2 = (SColIdPair*)elem2;




365,925,838✔





1283












1284



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




365,925,838✔





1285



    return 0;




110,434✔





1286



  }










1287












1288



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




366,093,923✔





1289



}










1290












1291



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




480,028,763✔





1292



  SColIdSlotIdPair* node1 = (SColIdSlotIdPair*)elem1;




480,028,763✔





1293



  SColIdSlotIdPair* node2 = (SColIdSlotIdPair*)elem2;




480,028,763✔





1294












1295



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




480,028,763✔





1296



    return 0;




168,730✔





1297



  }










1298












1299



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




480,147,747✔





1300



}










1301













UNCOV

1302



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




×







1303



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




×







1304



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




×







1305













UNCOV

1306



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




×







1307



    return 0;




×







1308



  }










1309













UNCOV

1310



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




×







1311



}










1312












1313



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




105,402,783✔





1314



  if (pList == NULL) {




105,402,783✔






UNCOV

1315



    return NULL;




×







1316



  }










1317












1318



  int32_t left = 0;




105,402,783✔





1319



  int32_t right = taosArrayGetSize(pList) - 1;




105,402,783✔





1320



  while (left <= right) {




325,684,407✔





1321



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




325,684,407✔





1322



    SColMatchItem* pItem = taosArrayGet(pList, mid);




325,684,407✔





1323



    if (pItem->colId == colId) {




325,684,407✔





1324



      // return the first matched item in sorted order










1325



      while (mid > 0) {




105,402,783✔





1326



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




78,781,415✔





1327



        if (pPrev->colId != colId) {




78,781,415✔





1328



          break;




78,781,415✔





1329



        }











UNCOV

1330



        mid--;




×







1331



      }










1332



      return taosArrayGet(pList, mid);




105,402,783✔





1333



    }










1334












1335



    if (pItem->colId < colId) {




220,281,624✔





1336



      left = mid + 1;




103,759,671✔





1337



    } else {










1338



      right = mid - 1;




116,521,953✔





1339



    }










1340



  }










1341













UNCOV

1342



  return NULL;




×







1343



}










1344












1345



static bool isNewScanParam(STableScanOperatorParam* pParam) {




45,595,469✔





1346



  return pParam->isNewParam;




45,595,469✔





1347



}










1348












1349



static int32_t createVTableScanInfoFromBatchParam(SOperatorInfo* pOperator) {




90,529,844✔





1350



  int32_t                  code = 0;




90,529,844✔





1351



  int32_t                  lino = 0;




90,529,844✔





1352



  STableScanInfo*          pInfo = pOperator->info;




90,529,844✔





1353



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




90,551,349✔





1354



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




90,540,234✔





1355



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




90,547,385✔





1356



  SMetaReader              orgTable = {0};




90,542,601✔





1357



  SMetaReader              superTable = {0};




90,583,042✔





1358



  SSchemaWrapper*          schema = NULL;




90,572,097✔





1359



  SArray*                  pColArray = NULL;




90,572,097✔





1360



  SArray*                  pBlockColArray = NULL;




90,572,097✔





1361



  int32_t                  num = 0;




90,572,097✔





1362



  STableKeyInfo*           pList = NULL;




90,566,153✔





1363



  SOrgTbInfo*              pOrgTbInfo;










1364



  bool                     isNewTable;










1365












1366



  cleanupQueryTableDataCond(&pInfo->base.cond);




90,563,559✔





1367












1368



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




90,545,767✔





1369



  if (pGetParam &&




90,541,973✔





1370



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




7,079,976✔





1371



    STableScanOperatorParam* pParam =




7,083,289✔





1372



      (STableScanOperatorParam*)pGetParam->value;










1373



    pInfo->pBatchColMap = pParam->pBatchTbInfo;




7,078,203✔





1374



    pParam->pBatchTbInfo = NULL;




7,061,510✔





1375



    pInfo->cachedTimeWindow = pParam->window;




7,049,532✔





1376



    pInfo->currentBatchIdx = 0;




7,072,237✔





1377



    pInfo->lastBatchIdx = -1;




7,062,033✔





1378



    pInfo->cachedTagList = pParam->pTagList;




7,049,434✔





1379



    pParam->pTagList = NULL;




7,069,318✔





1380



    pInfo->cachedGroupId = pParam->groupid;




7,054,426✔





1381












1382



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




7,063,877✔





1383



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










1384



    taosHashClear(pInfo->pIgnoreTables);




7,063,877✔





1385












1386



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




7,081,290✔





1387



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




6,586,210✔





1388



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




82,565,816✔





1389



        SqlFunctionCtx ctx = pSup->pCtx[i];




76,070,179✔





1390



        ctx.skipDynDataCheck = false;




75,981,721✔





1391



      }










1392



    }










1393



  }










1394












1395



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




90,454,606✔





1396



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




90,575,975✔





1397












1398



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




90,575,975✔





1399



    isNewTable = false;




78,986,637✔





1400



  } else {










1401



    isNewTable = true;




11,578,793✔





1402



    pInfo->lastBatchIdx = pInfo->currentBatchIdx;




11,578,793✔





1403



  }










1404












1405



  if (isNewTable) {




90,543,971✔





1406



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




11,574,362✔





1407



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




11,592,561✔





1408



    pAPI->metaReaderFn.readerReleaseLock(&orgTable);




11,553,201✔





1409



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




11,561,945✔





1410



    QUERY_CHECK_CODE(code, lino, _return);




11,538,153✔





1411



    switch (orgTable.me.type) {




11,538,153✔





1412



      case TSDB_CHILD_TABLE:




587,863✔





1413



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




587,863✔





1414



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




589,048✔





1415



        pAPI->metaReaderFn.readerReleaseLock(&superTable);




588,467✔





1416



        QUERY_CHECK_CODE(code, lino, _return);




589,048✔





1417



        schema = &superTable.me.stbEntry.schemaRow;




589,048✔





1418



        break;




589,048✔





1419



      case TSDB_NORMAL_TABLE:




10,911,187✔





1420



        schema = &orgTable.me.ntbEntry.schemaRow;




10,911,187✔





1421



        break;




10,911,187✔





1422



      default:




39,103✔





1423



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




39,103✔






UNCOV

1424



        return TSDB_CODE_INVALID_PARA;




×







1425



        break;










1426



    }










1427












1428



    pListInfo->oneTableForEachGroup = true;




11,500,235✔





1429



    taosHashClear(pListInfo->map);




11,506,868✔





1430



    taosArrayClear(pListInfo->pTableList);




11,599,452✔





1431












1432



    uint64_t      pUid = orgTable.me.uid;




11,592,796✔





1433



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




11,592,796✔





1434



    int32_t       tableIdx = 0;




11,594,444✔





1435



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




11,594,966✔





1436



    QUERY_CHECK_CODE(code, lino, _return);




11,597,873✔





1437



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




23,184,090✔





1438



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




11,586,217✔





1439












1440



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




11,586,217✔





1441



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




11,576,998✔





1442



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




11,576,998✔





1443



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




11,569,649✔





1444












1445



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










1446



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




11,569,649✔





1447



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




11,576,204✔





1448












1449



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




43,333,621✔





1450



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




31,754,376✔





1451



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




248,659,919✔





1452



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




248,172,182✔





1453



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




31,773,906✔





1454



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




31,767,375✔





1455



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




31,767,375✔





1456



                 pPair.vtbColId, GET_TASKID(pTaskInfo));










1457



          break;




31,724,760✔





1458



        }










1459



      }










1460



    }










1461












1462



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




54,946,498✔





1463



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




43,334,141✔





1464



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




253,931,292✔





1465



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




253,224,096✔





1466



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




253,342,138✔





1467



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




43,351,317✔





1468



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




43,383,038✔





1469



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




43,383,038✔





1470



                 colIdSlotIdPair.vtbSlotId, GET_TASKID(pTaskInfo));










1471



          break;




43,336,973✔





1472



        }










1473



      }










1474



    }










1475












1476



    taosArraySort(pColArray, compareColIdPair);




11,583,061✔





1477



    taosArraySort(pBlockColArray, compareColIdSlotIdPair);




11,583,245✔





1478



    if (pInfo->pBlockColMap) {




11,587,109✔





1479



      taosArrayDestroy(pInfo->pBlockColMap);




8,079,045✔





1480



      pInfo->pBlockColMap = NULL;




8,057,893✔





1481



    }










1482



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




11,559,937✔





1483



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




11,575,640✔





1484












1485












1486



    taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




11,518,248✔





1487



    taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




11,560,950✔





1488












1489



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




11,588,854✔





1490



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




9,982,812✔





1491



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




122,977,155✔





1492



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




113,060,953✔





1493



        bool           needScan = false;




113,041,863✔





1494



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




227,686,862✔





1495



          SFunctParam pParam = ctx->param[j];




114,579,006✔





1496



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




548,472,618✔





1497



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




459,224,802✔





1498



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




461,419,499✔





1499



              needScan |= true;




28,583,718✔





1500



              break;




28,583,718✔





1501



            }










1502



          }










1503



        }










1504



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




113,081,997✔





1505



        if (!needScan) {




113,195,186✔





1506



          ctx->skipDynDataCheck = true;




84,637,227✔





1507



        } else {










1508



          ctx->skipDynDataCheck = false;




28,557,959✔





1509



        }










1510



      }










1511



    }










1512












1513












1514



  } else {










1515



    pColArray = pInfo->lastColArray;




78,969,609✔





1516



    pBlockColArray = pInfo->lastBlockColArray;




78,973,701✔





1517



  }










1518












1519



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




90,558,405✔





1520



  QUERY_CHECK_CODE(code, lino, _return);




90,588,161✔





1521












1522



  if (pInfo->pResBlock) {




90,588,161✔





1523



    blockDataDestroy(pInfo->pResBlock);




83,488,127✔





1524



    pInfo->pResBlock = NULL;




83,475,594✔





1525



  }










1526












1527



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




90,567,578✔





1528



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










1529



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










1530



         isNewTable, pInfo->base.orgCond.order,










1531



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










1532



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










1533



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










1534












1535



  if (isNewTable) {




90,516,768✔





1536



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




11,556,261✔





1537



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




10,105,659✔





1538



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




10,073,317✔





1539



    } else {










1540



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




1,454,042✔





1541



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




1,456,967✔





1542



    }










1543



  } else {










1544



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




78,960,507✔





1545



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




2,283,273✔





1546



    else {










1547



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




76,692,168✔





1548



    }










1549



  }










1550












1551



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




90,530,186✔





1552



  pInfo->currentGroupId = 0;




90,531,752✔





1553



  pInfo->ignoreTag = true;




90,522,581✔





1554












1555



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




90,509,069✔





1556



  QUERY_CHECK_CODE(code, lino, _return);




90,560,904✔





1557












1558



  if (isNewTable) {




90,560,904✔





1559



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




11,573,435✔





1560



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




8,079,401✔





1561



    }










1562



    pInfo->base.dataReader = NULL;




11,531,956✔





1563












1564



    taosRLockLatch(&pTaskInfo->lock);




11,537,055✔





1565



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




11,597,868✔





1566



    taosRUnLockLatch(&pTaskInfo->lock);




11,492,059✔





1567



    QUERY_CHECK_CODE(code, lino, _return);




11,560,052✔





1568












1569



    pInfo->newReader = true;




11,560,052✔





1570



    if (pInfo->lastColArray) {




11,561,127✔





1571



      taosArrayDestroy(pInfo->lastColArray);




4,494,901✔





1572



      pInfo->lastColArray = NULL;




4,494,356✔





1573



    }










1574



    if (pInfo->lastBlockColArray) {




11,547,231✔





1575



      taosArrayDestroy(pInfo->lastBlockColArray);




4,492,666✔





1576



      pInfo->lastBlockColArray = NULL;




4,492,276✔





1577



    }










1578



    pInfo->lastColArray = pColArray;




11,473,980✔





1579



    pInfo->lastBlockColArray = pBlockColArray;




11,456,447✔





1580



  } else {










1581



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




78,987,469✔





1582



    QUERY_CHECK_CODE(code, lino, _return);




78,969,400✔





1583












1584



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




78,969,400✔





1585



    pInfo->newReader = false;




78,989,684✔





1586



    pInfo->scanTimes = 0;




78,989,684✔





1587



  }










1588












1589



  pOperator->status = OP_OPENED;




90,437,139✔





1590












1591



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




90,471,837✔






UNCOV

1592



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




×







1593



  }










1594












1595



  pInfo->currentGroupId = -1;




90,503,758✔





1596



_return:




90,484,896✔





1597



  if (code) {




90,444,312✔






UNCOV

1598



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




×







1599



  }










1600



  pAPI->metaReaderFn.clearReader(&superTable);




90,444,312✔





1601



  pAPI->metaReaderFn.clearReader(&orgTable);




90,459,641✔





1602



  return code;




90,527,386✔





1603



}










1604












1605



static int32_t createVTableScanInfoFromParam(SOperatorInfo* pOperator) {




26,621,368✔





1606



  int32_t                  code = 0;




26,621,368✔





1607



  int32_t                  lino = 0;




26,621,368✔





1608



  STableScanInfo*          pInfo = pOperator->info;




26,621,368✔





1609



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




26,621,368✔





1610



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




26,621,368✔





1611



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




26,621,368✔





1612



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




26,621,368✔





1613



  SMetaReader              orgTable = {0};




26,621,368✔





1614



  SMetaReader              superTable = {0};




26,621,368✔





1615



  SSchemaWrapper*          schema = NULL;




26,621,368✔





1616



  SArray*                  pColArray = NULL;




26,621,368✔





1617



  SArray*                  pBlockColArray = NULL;




26,621,368✔





1618



  int32_t                  num = 0;




26,621,368✔





1619



  STableKeyInfo*           pList = NULL;




26,621,368✔





1620



  SOrgTbInfo*              pOrgTbInfo;










1621



  SArray*                  pMatchList = NULL;




26,621,368✔





1622












1623



  cleanupQueryTableDataCond(&pInfo->base.cond);




26,621,368✔





1624












1625



  pOrgTbInfo = pParam->pOrgTbInfo;




26,621,368✔





1626












1627



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




26,621,368✔





1628












1629



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




26,621,368✔





1630



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




26,621,368✔





1631



  pAPI->metaReaderFn.readerReleaseLock(&orgTable);




26,621,368✔





1632



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




26,621,368✔





1633



  QUERY_CHECK_CODE(code, lino, _return);




26,621,368✔





1634



  switch (orgTable.me.type) {




26,621,368✔





1635



    case TSDB_CHILD_TABLE:




7,095,736✔





1636



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




7,095,736✔





1637



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




7,095,736✔





1638



      pAPI->metaReaderFn.readerReleaseLock(&superTable);




7,095,736✔





1639



      QUERY_CHECK_CODE(code, lino, _return);




7,095,736✔





1640



      schema = &superTable.me.stbEntry.schemaRow;




7,095,736✔





1641



      break;




7,095,736✔





1642



    case TSDB_NORMAL_TABLE:




19,525,632✔





1643



      schema = &orgTable.me.ntbEntry.schemaRow;




19,525,632✔





1644



      break;




19,525,632✔






UNCOV

1645



    default:




×







1646



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




×







1647



      return TSDB_CODE_INVALID_PARA;




×







1648



      break;










1649



  }










1650












1651



  pListInfo->oneTableForEachGroup = true;




26,621,368✔





1652



  taosHashClear(pListInfo->map);




26,621,368✔





1653



  taosArrayClear(pListInfo->pTableList);




26,621,368✔





1654












1655



  uint64_t      pUid = orgTable.me.uid;




26,621,368✔





1656



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




26,621,368✔





1657



  int32_t       tableIdx = 0;




26,621,368✔





1658



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




26,621,368✔





1659



  QUERY_CHECK_CODE(code, lino, _return);




26,621,368✔





1660



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




53,242,736✔





1661



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




26,621,368✔





1662












1663



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




26,621,368✔





1664



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




26,621,368✔





1665



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




26,621,368✔





1666



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




26,621,368✔





1667



  if (pInfo->pBlockColMap) {




26,621,368✔





1668



    taosArrayDestroy(pInfo->pBlockColMap);




23,896,516✔





1669



    pInfo->pBlockColMap = NULL;




23,896,516✔





1670



  }










1671



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




26,621,368✔





1672



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




26,621,368✔





1673












1674



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










1675



  SColIdPair tsPair = {.vtbColId = PRIMARYKEY_TIMESTAMP_COL_ID,




26,621,368✔





1676



                       .orgColId = PRIMARYKEY_TIMESTAMP_COL_ID,










1677



                       .type.type = TSDB_DATA_TYPE_TIMESTAMP,










1678



                       .type.bytes = 8};










1679



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




26,621,368✔





1680












1681



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




105,402,783✔





1682



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




78,781,415✔





1683



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




665,272,071✔





1684



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




665,272,071✔





1685



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




78,781,415✔





1686



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




78,781,415✔





1687



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




78,781,415✔





1688



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




78,781,415✔





1689



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




78,781,415✔





1690



        break;




78,781,415✔





1691



      }










1692



    }










1693



  }










1694












1695



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




26,621,368✔





1696



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




26,621,368✔






UNCOV

1697



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




×







1698



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




×







1699



      taosArraySort(pMatchList, compareColMatchItemByColId);




×







1700



    } else {










1701



      pMatchList = pInfo->base.matchInfo.pList;




26,621,368✔





1702



    }










1703



  }










1704












1705



  // skip ts pair










1706



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




132,023,509✔





1707



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




105,402,783✔





1708



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




105,402,783✔





1709



    if (pItem) {




105,402,783✔





1710



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




105,402,783✔





1711



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




642✔





1712



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










1713



        code = TSDB_CODE_VTABLE_COLUMN_TYPE_MISMATCH;




642✔





1714



        goto _return;




642✔





1715



      }










1716



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




105,402,141✔





1717



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




105,402,141✔





1718



      if (i > 0) {




105,402,141✔





1719



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




157,561,546✔





1720



      }










1721



    }










1722



  }










1723












1724



  taosArraySort(pColArray, compareColIdPair);




26,620,726✔





1725



  taosArraySort(pBlockColArray, compareColIdSlotIdPair);




26,620,726✔





1726



  taosArraySort(pInfo->pBlockColMap, compareColIdSlotIdPair);




26,620,726✔





1727












1728



  taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




26,620,726✔





1729



  taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




26,620,726✔





1730












1731



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




26,620,726✔





1732



  QUERY_CHECK_CODE(code, lino, _return);




26,620,726✔





1733












1734



  if (pInfo->pResBlock) {




26,620,726✔





1735



    blockDataDestroy(pInfo->pResBlock);




18,977,113✔





1736



    pInfo->pResBlock = NULL;




18,977,113✔





1737



  }










1738












1739



  if (isNewScanParam(pParam)) {




26,620,726✔





1740



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




7,650,869✔





1741



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




7,650,869✔





1742



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




7,650,869✔





1743



    } else {











UNCOV

1744



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




×







1745



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




×







1746



    }










1747



  } else {










1748



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




18,969,857✔





1749



  }










1750



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




26,620,726✔





1751



  pInfo->currentGroupId = 0;




26,620,726✔





1752



  pInfo->ignoreTag = true;




26,620,726✔





1753












1754



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




26,620,726✔





1755



  QUERY_CHECK_CODE(code, lino, _return);




26,620,726✔





1756












1757



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




26,620,726✔





1758



  if (reader) {




26,620,726✔





1759



    if (isNewScanParam(pParam)) {




18,974,743✔





1760



      pAPI->tsdReader.tsdReaderClose(*reader);




4,886✔





1761



      pInfo->base.dataReader = NULL;




4,886✔





1762












1763



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




4,886✔





1764



      QUERY_CHECK_CODE(code, lino, _return);




4,886✔





1765












1766



      taosRLockLatch(&pTaskInfo->lock);




4,886✔





1767



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




4,886✔





1768



      taosRUnLockLatch(&pTaskInfo->lock);




4,886✔





1769



      QUERY_CHECK_CODE(code, lino, _return);




4,886✔





1770












1771



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




4,886✔





1772



      QUERY_CHECK_CODE(code, lino, _return);




4,886✔





1773



      pInfo->newReader = true;




4,886✔





1774



    } else {










1775



      pInfo->base.dataReader = *reader;




18,969,857✔





1776



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




18,969,857✔





1777



      QUERY_CHECK_CODE(code, lino, _return);




18,969,857✔





1778












1779



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




18,969,857✔





1780



      pInfo->newReader = false;




18,969,857✔





1781



      pInfo->scanTimes = 0;




18,969,857✔





1782



    }










1783



  } else {










1784



    pInfo->base.dataReader = NULL;




7,645,983✔





1785












1786



    taosRLockLatch(&pTaskInfo->lock);




7,645,983✔





1787



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




7,645,983✔





1788



    taosRUnLockLatch(&pTaskInfo->lock);




7,645,983✔





1789



    QUERY_CHECK_CODE(code, lino, _return);




7,645,983✔





1790












1791



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




7,645,983✔





1792



    QUERY_CHECK_CODE(code, lino, _return);




7,645,983✔





1793



    pInfo->newReader = true;




7,645,983✔





1794



  }










1795



  pOperator->status = OP_OPENED;




26,620,726✔





1796












1797



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




26,620,726✔






UNCOV

1798



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




×







1799



  }










1800












1801



  pInfo->currentGroupId = -1;




26,620,726✔





1802



_return:




26,621,368✔





1803



  if (code) {




26,621,368✔





1804



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




642✔





1805



  }










1806



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




26,621,368✔






UNCOV

1807



    taosArrayDestroy(pMatchList);




×







1808



  }










1809



  taosArrayDestroy(pColArray);




26,621,368✔





1810



  taosArrayDestroy(pBlockColArray);




26,621,368✔





1811



  pAPI->metaReaderFn.clearReader(&superTable);




26,621,368✔





1812



  pAPI->metaReaderFn.clearReader(&orgTable);




26,621,368✔





1813



  return code;




26,621,368✔





1814



}










1815












1816



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




234,652,344✔





1817



  int32_t         code = TSDB_CODE_SUCCESS;




234,652,344✔





1818



  int32_t         lino = 0;




234,652,344✔





1819



  STableScanInfo* pInfo = pOperator->info;




234,652,344✔





1820



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




234,687,222✔





1821



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




234,654,593✔





1822



  int32_t         numOfTables = 0;




234,719,763✔





1823












1824



  QRY_PARAM_CHECK(pResult);




234,596,879✔





1825












1826



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




234,601,774✔





1827



  QUERY_CHECK_CODE(code, lino, _end);




234,687,898✔





1828












1829



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




234,687,898✔





1830



    setOperatorCompleted(pOperator);




215,103,245✔





1831



    if (pOperator->dynamicTask) {




215,105,140✔





1832



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




974,263✔





1833



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




975,806✔





1834



    }










1835



    return code;




215,095,885✔





1836



  }










1837












1838



  // reset value for the next group data output










1839



  pOperator->status = OP_OPENED;




19,408,160✔





1840



  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);




19,526,342✔





1841












1842



  int32_t        num = 0;




19,534,015✔





1843



  STableKeyInfo* pList = NULL;




19,535,256✔





1844



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




19,534,019✔





1845



  QUERY_CHECK_CODE(code, lino, _end);




19,563,954✔





1846












1847



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




19,563,954✔





1848



  QUERY_CHECK_CODE(code, lino, _end);




19,549,986✔





1849












1850



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




19,549,986✔





1851



  QUERY_CHECK_CODE(code, lino, _end);




19,551,291✔





1852



  pInfo->scanTimes = 0;




19,551,291✔





1853












1854



  code = doGroupedTableScan(pOperator, pResult);




19,544,694✔





1855



  QUERY_CHECK_CODE(code, lino, _end);




19,602,292✔





1856












1857



  if (*pResult != NULL) {




19,602,292✔





1858



    if (pOperator->dynamicTask) {




16,088,448✔





1859



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




15,837,173✔





1860



    }










1861



    return code;




16,086,713✔





1862



  }










1863












1864



_end:




3,516,012✔





1865



  if (code != TSDB_CODE_SUCCESS) {




3,513,214✔






UNCOV

1866



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




×







1867



    pTaskInfo->code = code;




×







1868



  }










1869



  return code;




3,513,415✔





1870



}










1871












1872



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




802,001,862✔





1873



  int32_t         code = TSDB_CODE_SUCCESS;




802,001,862✔





1874



  int32_t         lino = 0;




802,001,862✔





1875



  STableScanInfo* pInfo = pOperator->info;




802,001,862✔





1876



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




802,065,998✔





1877



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




801,949,624✔





1878



  int32_t         num = 0;




801,978,136✔





1879



  STableKeyInfo*  pList = NULL;




801,963,504✔





1880



  SSDataBlock*    pResult = NULL;




801,863,611✔





1881



  const char*     idStr = GET_TASKID(pTaskInfo);




801,927,838✔





1882












1883



  QRY_PARAM_CHECK(pResBlock);




801,921,451✔





1884












1885



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




801,899,419✔





1886



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




219,705,302✔






UNCOV

1887



      setOperatorCompleted(pOperator);




×







1888



      return code;




×







1889



    }










1890












1891



    taosRLockLatch(&pTaskInfo->lock);




219,862,795✔





1892



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




220,018,467✔





1893



    taosRUnLockLatch(&pTaskInfo->lock);




219,507,429✔





1894



    QUERY_CHECK_CODE(code, lino, _end);




219,751,470✔





1895












1896



    if (pInfo->filesetDelimited) {




219,749,200✔





1897



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




249,870✔





1898



    }










1899












1900



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




219,750,537✔






UNCOV

1901



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




×







1902



    }










1903



  }










1904












1905



  code = doGroupedTableScan(pOperator, &pResult);




801,578,332✔





1906



  QUERY_CHECK_CODE(code, lino, _end);




799,634,761✔





1907












1908



  if (pResult != NULL) {




799,634,761✔





1909



    if (pOperator->dynamicTask) {




585,302,195✔





1910



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




2,079,610✔





1911



    }










1912












1913



    *pResBlock = pResult;




585,282,838✔





1914



    return code;




584,122,492✔





1915



  }










1916












1917



  while (true) {










1918



    code = startNextGroupScan(pOperator, &pResult);




214,413,457✔





1919



    QUERY_CHECK_CODE(code, lino, _end);




215,482,974✔





1920












1921



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




215,482,974✔





1922



      *pResBlock = pResult;




215,373,621✔





1923



      return code;




215,349,411✔





1924



    }










1925



  }










1926












1927



_end:




2,270✔





1928



  if (code != TSDB_CODE_SUCCESS) {




2,270✔





1929



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




2,270✔





1930



    pTaskInfo->code = code;




2,270✔





1931



  }










1932












1933



  return code;




2,270✔





1934



}










1935












1936



static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {




26,620,726✔





1937



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




26,620,726✔





1938



}










1939












1940



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




977,708✔





1941



  int32_t                  code = TSDB_CODE_SUCCESS;




977,708✔





1942



  int32_t                  lino = 0;




977,708✔





1943



  STableScanInfo*          pInfo = pOperator->info;




977,708✔





1944



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




977,708✔





1945



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




977,708✔





1946



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




977,708✔





1947












1948



  code = createTableListInfoFromParam(pOperator);




977,708✔





1949



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




977,708✔





1950



  pOperator->pOperatorGetParam = NULL;




977,330✔





1951



  QUERY_CHECK_CODE(code, lino, _end);




977,330✔





1952












1953



  if (pOperator->status == OP_EXEC_DONE) {




977,330✔





1954



    pInfo->currentGroupId = -1;




23,751✔





1955



    pOperator->status = OP_OPENED;




23,751✔





1956



    SSDataBlock* result = NULL;




23,751✔





1957












1958



    while (true) {










1959



      code = startNextGroupScan(pOperator, &result);




23,751✔





1960



      QUERY_CHECK_CODE(code, lino, _end);




23,751✔





1961












1962



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




23,751✔





1963



        (*ppRes) = result;




23,751✔





1964



        return code;




23,751✔





1965



      }










1966



    }










1967



  }










1968



_end:




953,579✔





1969



  if (code) {




953,579✔






UNCOV

1970



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




×







1971



  }










1972



  return code;




953,579✔





1973



}










1974












1975



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




18,979,337✔





1976



  int32_t      code = TSDB_CODE_SUCCESS;




18,979,337✔





1977



  int32_t      lino = 0;




18,979,337✔





1978



  bool         found = false;




18,979,337✔





1979












1980



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




18,979,337✔





1981



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




18,979,337✔





1982












1983



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




93,676,376✔





1984



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




74,697,039✔





1985



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




74,697,039✔





1986



    found = false;




74,697,039✔





1987



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




212,701,484✔





1988



      SColIdSlotIdPair* pColPair = taosArrayGet(pColMap, j);




193,725,172✔





1989



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




193,725,172✔





1990



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




193,725,172✔





1991



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




55,720,727✔





1992



        found = true;




55,720,727✔





1993



        break;




55,720,727✔





1994



      }










1995



    }










1996



    if (!found) {




74,697,039✔





1997



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




18,976,312✔





1998



        pSrcCol->info.slotId = -1;




18,976,312✔





1999



      } else {











UNCOV

2000



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




×







2001



               (int32_t)taosArrayGetSize(pColMap));











UNCOV

2002



        code = TSDB_CODE_QRY_VSTB_SLOTID_NOT_FOUND;




×







2003



      }










2004



    }










2005



  }










2006












2007



  return code;




18,979,337✔






UNCOV

2008



_return:




×







2009



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




×







2010



  return code;




×







2011



}










2012












2013



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




26,621,368✔





2014



  int32_t                  code = TSDB_CODE_SUCCESS;




26,621,368✔





2015



  int32_t                  lino = 0;




26,621,368✔





2016



  STableScanInfo*          pInfo = pOperator->info;




26,621,368✔





2017



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




26,621,368✔





2018



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




26,621,368✔





2019



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




26,621,368✔





2020












2021



  QRY_PARAM_CHECK(ppRes);




26,621,368✔





2022



  qTrace("%s call", __FUNCTION__);




26,621,368✔





2023












2024



  code = createVTableScanInfoFromParam(pOperator);




26,621,368✔





2025



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




26,621,368✔





2026



  pOperator->pOperatorGetParam = NULL;




26,621,368✔





2027












2028



  QUERY_CHECK_CODE(code, lino, _end);




26,621,368✔





2029












2030



  SSDataBlock* result = NULL;




26,620,726✔





2031



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




26,620,726✔





2032



    (*ppRes) = result;




18,868✔





2033



    return code;




18,868✔





2034



  }










2035












2036



  if (pInfo->newReader) {




26,601,858✔





2037



    code = startNextGroupScan(pOperator, &result);




7,650,869✔





2038



    QUERY_CHECK_CODE(code, lino, _end);




7,650,869✔





2039



  } else {










2040



    code = doGroupedTableScan(pOperator, &result);




18,950,989✔





2041



    QUERY_CHECK_CODE(code, lino, _end);




18,950,989✔





2042



  }










2043












2044



  if (result) {




26,601,858✔





2045



    SSDataBlock* res = NULL;




18,979,337✔





2046



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




18,979,337✔





2047



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




18,979,337✔





2048



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




18,979,337✔





2049












2050



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




18,979,337✔





2051



    QUERY_CHECK_CODE(code, lino, _end);




18,979,337✔





2052



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










2053



    //QUERY_CHECK_CODE(code, lino, _end);










2054












2055



    //pInfo->pResBlock = res;










2056



    //blockDataDestroy(result);










2057



    (*ppRes) = result;




18,979,337✔





2058



  } else {










2059



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




7,622,521✔





2060



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




7,622,521✔





2061












2062



    blockDataDestroy(pInfo->pResBlock);




7,622,521✔





2063



    pInfo->pResBlock = NULL;




7,622,521✔





2064












2065



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




7,622,521✔





2066



    if (reader) {




7,622,521✔





2067



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




7,622,521✔





2068



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




7,622,521✔





2069



        pInfo->base.dataReader = NULL;




7,622,521✔





2070



      }










2071



      if (pAPI->tsdReader.tsdReaderClose) {




7,622,521✔





2072



        pAPI->tsdReader.tsdReaderClose(*reader);




7,622,521✔





2073



      }










2074



    }










2075












2076



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




7,622,521✔





2077



    QUERY_CHECK_CODE(code, lino, _end);




7,622,521✔





2078



  }










2079



_end:




26,602,500✔





2080



  if (code) {




26,602,500✔





2081



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




642✔





2082



  }










2083



  return code;




26,602,500✔





2084



}










2085












2086



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




17,606,218✔





2087



  int32_t                  code = TSDB_CODE_SUCCESS;




17,606,218✔





2088



  int32_t                  lino = 0;




17,606,218✔





2089



  STableScanInfo*          pInfo = pOperator->info;




17,606,218✔





2090



  int32_t                  index = 0;




17,606,218✔





2091



  char*                    tagVal = NULL;




17,606,218✔





2092












2093



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




125,488,759✔





2094



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




107,886,751✔





2095



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




107,887,877✔





2096












2097



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




107,888,463✔





2098



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




107,888,463✔





2099












2100



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




2,147,483,647✔





2101



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




2,147,483,647✔





2102



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




2,147,483,647✔





2103



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




2,147,483,647✔





2104












2105



        varDataSetLen(tagVal, pTagVal->nData);




2,147,483,647✔





2106



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




2,147,483,647✔





2107



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




2,147,483,647✔





2108



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2109



        taosMemoryFreeClear(tagVal);




2,147,483,647✔





2110



      } else {










2111



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




2,147,483,647✔





2112



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2113



      }










2114



    }










2115



    index++;




107,882,541✔





2116



  }










2117



  return code;




17,606,218✔






UNCOV

2118



_end:




×







2119



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




×







2120



  taosMemoryFreeClear(tagVal);




×







2121



  return code;




×







2122



}










2123












2124



static void clearVstbBatchDynamicTableScanInfo(STableScanInfo* pInfo) {




7,100,271✔





2125



  if (pInfo->pBatchColMap) {




7,100,271✔





2126



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




18,695,474✔





2127



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




11,594,150✔





2128



      taosArrayDestroy(pOrgTbInfo->colMap);




11,594,077✔





2129



    }










2130



    taosArrayDestroy(pInfo->pBatchColMap);




7,099,735✔





2131



    pInfo->pBatchColMap = NULL;




7,098,242✔





2132



  }










2133



  if (pInfo->cachedTagList) {




7,100,403✔





2134



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




21,557,140✔





2135



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




18,345,464✔





2136



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




18,347,030✔





2137



        taosMemoryFreeClear(pTagVal->pData);




8,055,147✔





2138



      }










2139



    }










2140



    taosArrayDestroy(pInfo->cachedTagList);




3,213,691✔





2141



    pInfo->cachedTagList = NULL;




3,214,286✔





2142



  }










2143



  if (pInfo->lastColArray) {




7,102,940✔





2144



    taosArrayDestroy(pInfo->lastColArray);




7,102,940✔





2145



    pInfo->lastColArray = NULL;




7,100,720✔





2146



  }










2147



  if (pInfo->lastBlockColArray) {




7,101,896✔





2148



    taosArrayDestroy(pInfo->lastBlockColArray);




7,101,374✔





2149



    pInfo->lastBlockColArray = NULL;




7,098,486✔





2150



  }










2151












2152



  blockDataDestroy(pInfo->pResBlock);




7,099,081✔





2153



  pInfo->pResBlock = NULL;




7,101,837✔





2154



}




7,101,374✔





2155












2156



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




86,052,903✔





2157



  int32_t                  code = TSDB_CODE_SUCCESS;




86,052,903✔





2158



  int32_t                  lino = 0;




86,052,903✔





2159



  STableScanInfo*          pInfo = pOperator->info;




86,052,903✔





2160



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




86,060,446✔





2161



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




86,059,441✔





2162



  SSDataBlock*             result = NULL;




86,061,274✔





2163












2164



  QRY_PARAM_CHECK(ppRes);




86,048,191✔





2165



  qTrace("%s call", __FUNCTION__);




86,061,233✔





2166












2167



  while (!result) {




169,496,491✔





2168



    code = createVTableScanInfoFromBatchParam(pOperator);




90,543,412✔





2169



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




90,501,826✔





2170



    pOperator->pOperatorGetParam = NULL;




90,466,465✔





2171



    QUERY_CHECK_CODE(code, lino, _end);




90,482,498✔





2172












2173



    if (pInfo->newReader) {




90,482,498✔





2174



      code = startNextGroupScan(pOperator, &result);




11,495,585✔





2175



      QUERY_CHECK_CODE(code, lino, _end);




11,591,348✔





2176



    } else {










2177



      code = doGroupedTableScan(pOperator, &result);




78,987,601✔





2178



      QUERY_CHECK_CODE(code, lino, _end);




78,954,136✔





2179



    }










2180



    if (!result) {




90,545,484✔





2181



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




11,589,056✔





2182



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










2183



      pInfo->currentBatchIdx++;




11,589,056✔





2184



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




11,581,905✔





2185



        // all batch scan finished










2186



        break;




7,100,852✔





2187



      }










2188



    }










2189



  }










2190












2191



  if (result) {




86,053,931✔





2192



    SSDataBlock* res = NULL;




78,954,645✔





2193



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




78,957,629✔





2194



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




78,973,281✔





2195



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




78,976,796✔





2196












2197



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




78,977,987✔





2198



    QUERY_CHECK_CODE(code, lino, _end);




78,993,222✔





2199












2200



    if (pInfo->cachedTagList) {




78,993,222✔





2201



      code = setTagValFromTagList(pOperator, res);




17,606,218✔





2202



      QUERY_CHECK_CODE(code, lino, _end);




17,606,218✔





2203



    }










2204












2205



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




78,994,412✔





2206



    pInfo->pResBlock = res;




78,993,354✔





2207



    blockDataDestroy(result);




78,993,368✔





2208



    (*ppRes) = res;




78,987,231✔





2209












2210



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




78,987,223✔





2211



  } else {










2212



    clearVstbBatchDynamicTableScanInfo(pInfo);




7,099,286✔





2213



    setOperatorCompleted(pOperator);




7,101,896✔





2214



  }










2215












2216



_end:




86,086,400✔





2217



  return code;




86,085,805✔





2218



}










2219












2220



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




113,659,581✔





2221



  int32_t                  code = TSDB_CODE_SUCCESS;




113,659,581✔





2222



  int32_t                  lino = 0;




113,659,581✔





2223



  STableScanInfo*          pInfo = pOperator->info;




113,659,581✔





2224



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




113,679,642✔





2225



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




113,677,838✔





2226












2227



  QRY_PARAM_CHECK(ppRes);




113,675,345✔





2228



  qTrace("%s call", __FUNCTION__);




113,665,307✔





2229












2230



  pOperator->dynamicTask = true;




113,665,307✔





2231












2232



  switch (type) {




113,646,106✔





2233



    case DYN_TYPE_VSTB_WIN_SCAN:




977,708✔





2234



    case DYN_TYPE_STB_JOIN: {










2235



      code = doStbJoinDynamicTableScanNext(pOperator, ppRes);




977,708✔





2236



      QUERY_CHECK_CODE(code, lino, _end);




977,330✔





2237



      break;




977,330✔





2238



    }










2239



    case DYN_TYPE_VSTB_SINGLE_SCAN: {




26,621,368✔





2240



      code = doVstbSingleDynamicTableScanNext(pOperator, ppRes);




26,621,368✔





2241



      QUERY_CHECK_CODE(code, lino, _end);




26,621,368✔





2242



      break;




26,620,726✔





2243



    }










2244



    case DYN_TYPE_VSTB_BATCH_SCAN:




86,047,030✔





2245



      code = doVstbBatchDynamicTableScanNext(pOperator, ppRes);




86,047,030✔





2246



      QUERY_CHECK_CODE(code, lino, _end);




86,088,180✔





2247



      break;




86,088,180✔






UNCOV

2248



    default:




×







2249



      code = TSDB_CODE_INVALID_PARA;




×







2250



      QUERY_CHECK_CODE(code, lino, _end);




×







2251



      break;




×







2252



  }










2253












2254



_end:




113,686,878✔





2255



  return code;




113,686,878✔





2256



}










2257












2258



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




920,103,661✔





2259



  int32_t         code = TSDB_CODE_SUCCESS;




920,103,661✔





2260



  int32_t         lino = 0;




920,103,661✔





2261



  STableScanInfo* pInfo = pOperator->info;




920,103,661✔





2262



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




920,757,706✔





2263



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




920,523,516✔





2264



  QRY_PARAM_CHECK(ppRes);




920,631,833✔





2265



  qTrace("%s call", __FUNCTION__);




919,975,290✔





2266












2267



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




919,976,833✔





2268



  QUERY_CHECK_CODE(code, lino, _end);




920,961,556✔





2269












2270



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




920,961,556✔





2271



  if (pGetParam || pInfo->pBatchColMap) {




920,954,174✔





2272



    ETableScanDynType type = pGetParam ?




113,666,470✔





2273



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




113,660,588✔





2274



      DYN_TYPE_VSTB_BATCH_SCAN;










2275












2276



    code = doDynamicTableScanNext(pOperator, type, ppRes);




113,666,470✔





2277



    QUERY_CHECK_CODE(code, lino, _end);




113,685,688✔





2278












2279



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




113,685,046✔





2280



      return code;




112,737,857✔





2281



    }










2282



  }










2283












2284



  // scan table one by one sequentially










2285



  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {




808,236,567✔





2286



    int32_t       numOfTables = 0;




6,256,419✔





2287



    STableKeyInfo tInfo = {0};




6,256,419✔





2288



    pInfo->countState = TABLE_COUNT_STATE_END;




6,256,419✔





2289












2290



    while (1) {




5,845,224✔





2291



      SSDataBlock* result = NULL;




12,101,643✔





2292



      code = doGroupedTableScan(pOperator, &result);




12,089,557✔





2293



      QUERY_CHECK_CODE(code, lino, _end);




12,082,343✔





2294












2295



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




12,082,343✔





2296



        (*ppRes) = result;




6,195,346✔





2297



        return code;




6,212,550✔





2298



      }










2299












2300



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










2301



      pInfo->currentTable++;




5,886,285✔





2302












2303



      taosRLockLatch(&pTaskInfo->lock);




5,884,738✔





2304



      numOfTables = 0;




5,892,644✔





2305



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




5,892,644✔





2306



      if (code != TSDB_CODE_SUCCESS) {




5,885,022✔






UNCOV

2307



        taosRUnLockLatch(&pTaskInfo->lock);




×







2308



        TSDB_CHECK_CODE(code, lino, _end);




×







2309



      }










2310












2311



      if (pInfo->currentTable >= numOfTables) {




5,885,022✔





2312



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




41,389✔





2313



        taosRUnLockLatch(&pTaskInfo->lock);




41,714✔





2314



        (*ppRes) = NULL;




41,714✔





2315



        return code;




41,714✔





2316



      }










2317












2318



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




5,835,422✔





2319



      if (!tmp) {




5,843,662✔






UNCOV

2320



        taosRUnLockLatch(&pTaskInfo->lock);




×







2321



        (*ppRes) = NULL;




×







2322



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




×







2323



      }










2324












2325



      tInfo = *tmp;




5,843,662✔





2326



      taosRUnLockLatch(&pTaskInfo->lock);




5,825,851✔





2327












2328



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




5,849,997✔





2329



      QUERY_CHECK_CODE(code, lino, _end);




5,836,450✔





2330



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




5,836,450✔





2331



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










2332












2333



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




5,862,373✔





2334



      QUERY_CHECK_CODE(code, lino, _end);




5,825,495✔





2335



      pInfo->scanTimes = 0;




5,825,495✔





2336



    }










2337



  } else {  // scan table group by group sequentially










2338



    code = groupSeqTableScan(pOperator, ppRes);




801,873,506✔





2339



    QUERY_CHECK_CODE(code, lino, _end);




799,690,244✔





2340



  }










2341












2342



_end:




799,687,974✔





2343



  if (code != TSDB_CODE_SUCCESS) {




799,633,722✔





2344



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




2,912✔





2345



    pTaskInfo->code = code;




2,912✔





2346



    T_LONG_JMP(pTaskInfo->env, code);




2,912✔





2347



  }










2348












2349



  return code;




799,630,810✔





2350



}










2351












2352



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




1,920,080✔





2353



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




1,920,080✔





2354



  if (!pRecorder) {




1,920,080✔






UNCOV

2355



    return terrno;




×







2356



  }










2357



  STableScanInfo* pTableScanInfo = pOptr->info;




1,920,080✔





2358



  *pRecorder = pTableScanInfo->base.readRecorder;




1,919,565✔





2359



  *pOptrExplain = pRecorder;




1,920,595✔





2360



  *len = sizeof(SFileBlockLoadRecorder);




1,920,595✔





2361



  return 0;




1,920,595✔





2362



}










2363












2364



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




257,804,444✔





2365



  cleanupQueryTableDataCond(&pBase->cond);




257,804,444✔





2366



  cleanupQueryTableDataCond(&pBase->orgCond);




257,715,088✔





2367












2368



  if (pAPI->tsdReaderClose) {




257,787,680✔





2369



    pAPI->tsdReaderClose(pBase->dataReader);




257,828,592✔





2370



  }










2371



  pBase->dataReader = NULL;




257,579,034✔





2372












2373



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




257,626,156✔





2374



    taosArrayDestroy(pBase->matchInfo.pList);




257,674,564✔





2375



  }










2376












2377



  tableListDestroy(pBase->pTableListInfo);




257,541,082✔





2378



  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);




257,721,527✔





2379



  cleanupExprSupp(&pBase->pseudoSup);




257,715,804✔





2380



}




257,800,311✔





2381












2382



static void cleanReaderForVTable(STableScanInfo* pInfo){




7,717,495✔





2383



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




7,717,495✔





2384



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




7,719,678✔





2385



    while (pIter != NULL) {




7,741,420✔





2386



      void **reader = pIter;




23,462✔





2387



      if (*reader) {




23,462✔





2388



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




23,462✔





2389



          pInfo->base.dataReader = NULL;




21,092✔





2390



        }










2391



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




23,462✔





2392



      }










2393



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




23,462✔





2394



    }










2395



  }










2396



}




7,716,892✔





2397












2398



static void destroyTableScanOperatorInfo(void* param) {




232,862,221✔





2399



  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;




232,862,221✔





2400



  blockDataDestroy(pTableScanInfo->pResBlock);




232,862,221✔





2401



  blockDataDestroy(pTableScanInfo->pOrgBlock);




232,818,141✔





2402



  taosHashCleanup(pTableScanInfo->pIgnoreTables);




232,828,243✔





2403



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




232,739,722✔





2404



    cleanReaderForVTable(pTableScanInfo);




7,717,518✔





2405



    taosHashCleanup(pTableScanInfo->readerCache);




7,718,562✔





2406



  }










2407



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




232,744,870✔





2408



  taosArrayDestroy(pTableScanInfo->pBlockColMap);




232,716,960✔





2409



  taosMemoryFreeClear(param);




232,778,237✔





2410



}




232,711,350✔





2411












2412



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




232,399,488✔





2413



  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {




232,399,488✔





2414



    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);




7,737,305✔





2415



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




19,450,797✔





2416



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




11,775,944✔





2417



      if (pCol) {




11,782,657✔





2418



        pCol->info.noData = true;




11,786,011✔





2419



      }










2420



    }










2421



  }










2422



}




232,337,036✔





2423












2424



static int32_t resetTableScanOperatorState(SOperatorInfo* pOper) {




262,876✔





2425



  int32_t         code = TSDB_CODE_SUCCESS;




262,876✔





2426



  STableScanInfo*   pInfo = pOper->info;




262,876✔





2427



  pOper->status = OP_NOT_OPENED;




262,876✔





2428












2429



  pInfo->scanTimes = 0;




262,876✔





2430



  pInfo->currentGroupId = -1;




262,876✔





2431



  pInfo->tableEndIndex = -1;




262,876✔





2432



  pInfo->tableStartIndex = 0;




262,648✔





2433



  pInfo->currentTable = 0;




262,648✔





2434



  pInfo->scanMode = 0;




262,648✔





2435



  pInfo->countState = 0;




262,648✔





2436



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




262,876✔





2437












2438



  if (!pInfo->virtualStableScan) {




262,648✔





2439



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










2440



  //   cleanReaderForVTable(pInfo);










2441



  //   taosHashClear(pInfo->readerCache);










2442



  //   pInfo->readerCache = false;










2443



  // } else {










2444



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




140,396✔





2445



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




140,396✔





2446



    }










2447



    pInfo->base.dataReader = NULL;




140,396✔





2448



  }










2449



  tableListDestroy(pInfo->base.pTableListInfo);




262,648✔





2450



  pInfo->base.pTableListInfo = tableListCreate();




262,457✔





2451



  if (!pInfo->base.pTableListInfo) {




262,876✔






UNCOV

2452



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




×







2453



    return terrno;




×







2454



  }










2455



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




262,876✔





2456












2457



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




262,876✔





2458



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




262,876✔





2459



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




277,970✔





2460



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










2461



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




277,970✔





2462



    if (code) {




139,368✔






UNCOV

2463



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




×







2464



      return code;




×







2465



    }










2466



  }










2467












2468



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




262,876✔





2469



  cleanupQueryTableDataCond(&pInfo->base.cond);




262,876✔





2470



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




262,876✔





2471



  if (code) {




262,876✔






UNCOV

2472



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




×







2473



    return code;




×







2474



  }










2475



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




262,876✔





2476



    cleanupQueryTableDataCond(&pInfo->base.orgCond);




122,480✔





2477



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




122,480✔





2478



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




122,480✔





2479



  } 










2480












2481



  pOper->resultInfo.totalRows = 0;




262,876✔





2482



  blockDataEmpty(pInfo->pResBlock);




262,876✔





2483



  blockDataEmpty(pInfo->pOrgBlock);




262,876✔





2484



  taosHashClear(pInfo->pIgnoreTables);




262,876✔





2485



  taosArrayDestroy(pInfo->pBlockColMap);




262,876✔





2486



  pInfo->pBlockColMap = NULL;




262,848✔





2487



  return code;




262,848✔





2488



}










2489












2490



int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




232,827,285✔





2491



                                    STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










2492



                                    SOperatorInfo** pOptrInfo) {










2493



  QRY_PARAM_CHECK(pOptrInfo);




232,827,285✔





2494












2495



  int32_t         code = TSDB_CODE_SUCCESS;




232,860,653✔





2496



  int32_t         lino = 0;




232,860,653✔





2497



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




232,860,653✔





2498



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




232,831,634✔





2499



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




232,697,785✔





2500



    code = terrno;




219✔





2501



    goto _error;




×







2502



  }










2503












2504



  pOperator->pPhyNode = pTableScanNode;




232,701,716✔





2505



  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;




232,717,485✔





2506



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




232,732,198✔





2507












2508



  int32_t numOfCols = 0;




232,750,744✔





2509



  code =










2510



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




232,774,641✔





2511



  QUERY_CHECK_CODE(code, lino, _error);




232,531,431✔





2512












2513



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




232,531,431✔





2514



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




232,391,908✔





2515



  QUERY_CHECK_CODE(code, lino, _error);




231,918,529✔





2516












2517



  if (pScanNode->pScanPseudoCols != NULL) {




231,918,529✔





2518



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




53,372,748✔





2519



    pSup->pExprInfo = NULL;




53,340,030✔





2520



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




53,356,644✔





2521



    QUERY_CHECK_CODE(code, lino, _error);




53,314,983✔





2522












2523



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




53,314,983✔





2524



                                      &pTaskInfo->storageAPI.functionStore);










2525



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




53,243,430✔





2526



  }










2527












2528



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




231,851,799✔





2529



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




231,944,871✔





2530












2531



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




231,289,583✔





2532



  pInfo->base.readHandle = *readHandle;




231,722,076✔





2533



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




231,707,905✔





2534












2535



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




232,085,682✔





2536



  pInfo->sample.seed = taosGetTimestampSec();




231,818,896✔





2537












2538



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




232,059,696✔





2539



  initResultSizeInfo(&pOperator->resultInfo, 4096);




231,937,794✔





2540



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




231,962,118✔





2541



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




232,213,239✔





2542



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




231,741,284✔





2543












2544



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




231,148,365✔





2545



  QUERY_CHECK_CODE(code, lino, _error);




231,983,186✔





2546












2547



  pInfo->virtualStableScan = pScanNode->virtualStableScan;




231,983,186✔





2548



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




231,894,768✔





2549



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




7,700,899✔





2550



    pInfo->pResBlock = NULL;




7,701,432✔





2551



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




7,698,386✔





2552



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




7,703,148✔





2553



  }










2554












2555



  if (pInfo->virtualStableScan) {




231,958,738✔





2556



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




7,708,172✔





2557



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




7,720,781✔





2558



  }










2559












2560



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




232,084,984✔





2561



                            pTaskInfo->pStreamRuntimeInfo);




232,249,470✔





2562



  QUERY_CHECK_CODE(code, lino, _error);




231,893,503✔





2563












2564



  pInfo->currentGroupId = -1;




231,870,221✔





2565












2566



  pInfo->tableEndIndex = -1;




231,912,800✔





2567



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




231,846,762✔





2568



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




231,971,205✔





2569












2570



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




231,711,102✔





2571



                  pTaskInfo);










2572



  pOperator->exprSupp.numOfExprs = numOfCols;




231,467,529✔





2573












2574



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




231,379,533✔





2575



  pInfo->ignoreTag = false;




231,645,336✔





2576












2577



  pInfo->lastBatchIdx = -1;




231,899,499✔





2578



  pInfo->currentBatchIdx = 0;




231,671,275✔





2579



  pInfo->base.pTableListInfo = pTableListInfo;




231,408,135✔





2580



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




231,448,719✔






UNCOV

2581



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




×







2582



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




×







2583



      code = terrno;




×







2584



      QUERY_CHECK_CODE(code, lino, _error);




×







2585



    }










2586













UNCOV

2587



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




×







2588



  }










2589












2590



  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




231,448,719✔





2591












2592



  pOperator->fpSet = createOperatorFpSet(prepareTableScan, doTableScanNext,




232,008,978✔





2593



                                         NULL, destroyTableScanOperatorInfo,










2594



                                         optrDefaultBufFn,










2595



                                         getTableScannerExecInfo,










2596



                                         optrDefaultGetNextExtFn, NULL);










2597












2598



  setOperatorResetStateFn(pOperator, resetTableScanOperatorState); 




231,846,673✔





2599



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










2600



  pOperator->cost.openCost = 0;




231,623,725✔





2601



  *pOptrInfo = pOperator;




231,694,978✔





2602



  return TSDB_CODE_SUCCESS;




231,469,701✔





2603












2604



_error:




23,282✔





2605



  if (pInfo != NULL) {




23,282✔





2606



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




23,282✔





2607



    destroyTableScanOperatorInfo(pInfo);




23,282✔





2608



  }










2609












2610



  if (pOperator != NULL) {




23,282✔





2611



    pOperator->info = NULL;




23,282✔





2612



    destroyOperator(pOperator);




23,282✔





2613



  }










2614



  pTaskInfo->code = code;




23,282✔





2615



  return code;




23,282✔





2616



}










2617













UNCOV

2618



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




×







2619



  QRY_PARAM_CHECK(pOptrInfo);




×







2620













UNCOV

2621



  int32_t         code = 0;




×







2622



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




×







2623



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




×







2624



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




×







2625



    code = terrno;




×







2626



    goto _end;




×







2627



  }










2628













UNCOV

2629



  pInfo->base.dataReader = pReadHandle;




×







2630



  //  pInfo->prevGroupId       = -1;










2631













UNCOV

2632



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




×







2633



                  pInfo, pTaskInfo);











UNCOV

2634



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




×







2635



                                         optrDefaultGetNextExtFn, NULL);











UNCOV

2636



  *pOptrInfo = pOperator;




×







2637



  return code;




×







2638













UNCOV

2639



_end:




×







2640



  if (pInfo != NULL) {




×







2641



    taosMemoryFree(pInfo);




×







2642



  }










2643













UNCOV

2644



  if (pOperator != NULL) {




×







2645



    taosMemoryFree(pOperator);




×







2646



  }










2647













UNCOV

2648



  pTaskInfo->code = code;




×







2649



  return code;




×







2650



}










2651












2652



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




14,158✔





2653



  int32_t code = TSDB_CODE_SUCCESS;




14,158✔





2654



  int32_t lino = 0;




14,158✔





2655



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




14,158✔





2656



    return code;




1,662✔





2657



  }










2658



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




12,496✔





2659



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




12,496✔





2660



  bool hasUnqualified = false;




12,496✔





2661












2662



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




12,496✔





2663



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




12,496✔





2664












2665



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




12,496✔





2666



         VALUE_GET_TRIVIAL_DATUM(&offset->primaryKey));










2667



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




12,496✔





2668



                        TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);










2669












2670



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




12,496✔





2671



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




12,496✔





2672



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




45,064,936✔





2673



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




45,052,440✔





2674



    void*    data = colDataGetData(pColPk, i);




45,052,440✔





2675



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




45,054,856✔





2676



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




2,416✔






UNCOV

2677



        QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY, lino, _end);




×







2678



      }










2679



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




2,416✔





2680



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




2,416✔





2681



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




2,416✔





2682



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




2,416✔





2683



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




2,416✔





2684



      taosMemoryFree(tmq);




2,416✔





2685



    } else {










2686



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




45,050,024✔





2687



    }










2688












2689



    if (!p[i]) {




45,052,440✔





2690



      hasUnqualified = true;




16,081,500✔





2691



    }










2692



  }










2693












2694



  if (hasUnqualified) {




12,496✔





2695



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




4,228✔





2696



    QUERY_CHECK_CODE(code, lino, _end);




4,228✔





2697



  }










2698












2699



_end:




12,496✔





2700



  taosMemoryFree(p);




12,496✔





2701



  if (code != TSDB_CODE_SUCCESS) {




12,496✔






UNCOV

2702



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




×







2703



  }










2704



  return code;




12,496✔





2705



}










2706













UNCOV

2707



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




×







2708



  int32_t p1 = *(int32_t*)param1;




×







2709



  int32_t p2 = *(int32_t*)param2;




×







2710













UNCOV

2711



  if (p1 == p2) {




×







2712



    return 0;




×







2713



  } else {











UNCOV

2714



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




×







2715



  }










2716



}










2717












2718



static int32_t processBlock(STmqQueryScanInfo* pInfo) {




22,839,037✔





2719



  int32_t         code = TSDB_CODE_SUCCESS;




22,839,037✔





2720



  int32_t         lino = 0;




22,839,037✔





2721



  SOperatorInfo*  pOperator = pInfo->pTmqScanOp;




22,839,037✔





2722












2723



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




22,839,037✔





2724



  QUERY_CHECK_CODE(code, lino, _end);




22,839,037✔





2725












2726



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




22,839,037✔





2727



  QUERY_CHECK_CODE(code, lino, _end);




22,838,360✔





2728












2729



_end:




22,838,360✔





2730



  if (code != TSDB_CODE_SUCCESS) {




22,838,360✔






UNCOV

2731



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




×







2732



  }










2733



  return code;




22,838,710✔





2734



}










2735












2736



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




6,960,511✔





2737



  int32_t code = TSDB_CODE_SUCCESS;




6,960,511✔





2738



  int32_t lino = 0;




6,960,511✔





2739



  SValue  val = {0};




6,960,511✔





2740



  if (hasPrimaryKey) {




6,960,511✔





2741



    code = doBlockDataPrimaryKeyFilter(pBlock, offset);




14,158✔





2742



    if (code != TSDB_CODE_SUCCESS) {




14,158✔






UNCOV

2743



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




×







2744



      return code;




×







2745



    }










2746



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




14,158✔





2747












2748



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




14,158✔





2749



      return code;




3,926✔





2750



    }










2751



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




10,232✔





2752



    val.type = pColPk->info.type;




10,232✔





2753



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




10,232✔





2754



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




642✔






UNCOV

2755



        return TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY;




×







2756



      }










2757



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




642✔





2758



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




642✔





2759



      val.nData = varDataLen(tmp);




642✔





2760



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




642✔





2761



    } else {










2762



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




9,590✔





2763



    }










2764



  }










2765



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




6,956,585✔





2766












2767



_end:




6,956,230✔





2768



  if (code != TSDB_CODE_SUCCESS) {




6,957,803✔






UNCOV

2769



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




×







2770



  }










2771



  return code;




6,956,212✔





2772



}










2773












2774



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




23,018,936✔





2775



  int32_t        code = TSDB_CODE_SUCCESS;




23,018,936✔





2776



  int32_t        lino = 0;




23,018,936✔





2777



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




23,018,936✔





2778



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




23,020,989✔





2779












2780



  STmqQueryScanInfo* pInfo = pOperator->info;




23,020,327✔





2781



  const char*      id = GET_TASKID(pTaskInfo);




23,020,286✔





2782












2783



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




23,018,658✔





2784












2785



  if (isTaskKilled(pTaskInfo)) {




23,021,305✔






UNCOV

2786



    (*ppRes) = NULL;




×







2787



    return pTaskInfo->code;




×







2788



  }










2789












2790



  blockDataCleanup(pInfo->pRes);




23,021,345✔





2791



  int64_t st = taosGetTimestampMs();




23,020,645✔





2792



  










2793



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




23,020,645✔





2794



    while (1) {




5,940,707✔





2795



      SSDataBlock* pResult = NULL;




6,254,788✔





2796



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




6,254,515✔





2797



      QUERY_CHECK_CODE(code, lino, _end);




6,253,946✔





2798












2799



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




6,253,946✔





2800



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




6,213,786✔





2801



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




6,214,705✔





2802



        QUERY_CHECK_CODE(code, lino, _end);




6,211,596✔





2803



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




6,211,596✔





2804



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




6,213,169✔





2805



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




6,210,779✔





2806



          QUERY_CHECK_CODE(code, lino, _end);




6,209,827✔





2807



        }










2808



      } else {










2809



        break;










2810



      }










2811












2812



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




6,213,753✔





2813



        (*ppRes) = pInfo->pRes;




271,787✔





2814



        return code;




271,787✔





2815



      }










2816



      int64_t elapsed = taosGetTimestampMs() - st;




5,941,964✔





2817



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




5,941,964✔





2818



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




1,575✔






UNCOV

2819



          terrno = TSDB_CODE_TMQ_FETCH_TIMEOUT ;




×







2820



        }










2821



        (*ppRes) = pInfo->pRes;




1,260✔





2822



        return code;




1,260✔





2823



      }   










2824



    }










2825












2826



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




41,714✔





2827



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




41,714✔





2828












2829



    pTSInfo->base.dataReader = NULL;




41,714✔





2830



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




41,714✔





2831



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




41,714✔





2832



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




41,714✔





2833



    if (code == TSDB_CODE_WAL_LOG_NOT_EXIST) {




41,714✔





2834



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




10,643✔





2835



        (*ppRes) = NULL;




4,394✔





2836



      } else {










2837



        (*ppRes) = pInfo->pRes;




6,249✔





2838



      }










2839



      return 0;




10,643✔





2840



    }










2841



    QUERY_CHECK_CODE(code, lino, _end);




31,071✔





2842












2843



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




31,071✔





2844



  }










2845












2846



  while (1) {




101,382✔





2847



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




68,515,383✔





2848



                                                              pInfo->pCol2SlotId,










2849



                                                              pInfo->pPseudoExpr,










2850



                                                              pInfo->numOfPseudoExpr,










2851



                                                              pTaskInfo->tmqInfo.sourceExcluded,




22,838,677✔





2852



                                                              pTaskInfo->tmqInfo.minPollRows,










2853



                                                              pTaskInfo->tmqInfo.timeout,










2854



                                                              pTaskInfo->tmqInfo.enableReplay);




22,839,037✔





2855



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




22,838,687✔






UNCOV

2856



      goto _end;




×







2857



    }                                                              










2858



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




22,838,687✔





2859












2860



    // curVersion move to next










2861



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




22,838,337✔





2862












2863



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










2864



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




22,838,687✔





2865












2866



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




22,839,037✔





2867



            pTaskInfo->tmqInfo.currentOffset.version);










2868



    int32_t ret = processBlock(pInfo);




22,839,364✔





2869



    if (ret != 0) {




22,838,710✔






UNCOV

2870



      code = ret;




×







2871



      goto _end;




×







2872



    }










2873



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




22,838,710✔





2874



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










2875



    










2876



    if (code != 0) {




22,839,037✔





2877



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




22,272,907✔





2878



        (*ppRes) = NULL;




10,946,459✔





2879



      } else {










2880



        (*ppRes) = pInfo->pRes;




11,326,448✔





2881



      }










2882



      return 0;




22,272,907✔





2883



    }










2884












2885



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




566,130✔





2886



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




106,404✔





2887



      (*ppRes) = pInfo->pRes;




464,748✔





2888



      return 0;




464,748✔





2889



    }










2890



  }










2891













UNCOV

2892



_end:




×







2893



  if (code != TSDB_CODE_SUCCESS) {




×







2894



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




×







2895



    pTaskInfo->code = code;




×







2896



    T_LONG_JMP(pTaskInfo->env, code);




×







2897



  }











UNCOV

2898



  (*ppRes) = NULL;




×







2899



  return code;




×







2900



}










2901












2902



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




326,978✔





2903



  int32_t code = TSDB_CODE_SUCCESS;




326,978✔





2904



  int32_t lino = 0;




326,978✔





2905



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




326,978✔





2906



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




327,957✔





2907












2908



  // Transfer the Array of STableKeyInfo into uid list.










2909



  int32_t size = 0;




327,957✔





2910



  code = tableListGetSize(pTableListInfo, &size);




327,957✔





2911



  QUERY_CHECK_CODE(code, lino, _end);




327,957✔





2912



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




9,487,111✔





2913



    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);




9,157,761✔





2914



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




9,131,171✔





2915



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




9,131,171✔





2916



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




9,159,154✔





2917



  }










2918












2919



  (*ppArrayRes) = tableIdList;




329,350✔





2920












2921



_end:




327,957✔





2922



  if (code != TSDB_CODE_SUCCESS) {




327,957✔






UNCOV

2923



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




×







2924



  }










2925



  return code;




327,957✔





2926



}










2927












2928



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




1,527,844✔





2929



  int32_t        code = TSDB_CODE_SUCCESS;




1,527,844✔





2930



  int32_t        lino = 0;




1,527,844✔





2931



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,527,844✔





2932



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,527,844✔





2933












2934



  STmqRawScanInfo* pInfo = pOperator->info;




1,527,844✔





2935



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




1,527,844✔





2936



  pTaskInfo->tmqInfo.btMetaRsp.batchMetaLen = NULL;




1,527,844✔





2937












2938



  qDebug("tmqsnap doRawScan called");




1,527,844✔





2939



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




1,528,144✔





2940



    bool hasNext = false;




1,521,581✔





2941



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




1,521,581✔





2942



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




1,520,368✔





2943



      if (code != TSDB_CODE_SUCCESS) {




1,518,866✔






UNCOV

2944



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




×







2945



        QUERY_CHECK_CODE(code, lino, _end);




×







2946



      }










2947



    }










2948












2949



    if (pInfo->dataReader && hasNext) {




1,520,079✔





2950



      if (isTaskKilled(pTaskInfo)) {




748,560✔






UNCOV

2951



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




×







2952



        return code;




×







2953



      }










2954












2955



      SSDataBlock* pBlock = NULL;




748,260✔





2956



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




748,260✔





2957



      QUERY_CHECK_CODE(code, lino, _end);




747,958✔





2958












2959



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




747,958✔





2960



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




748,258✔





2961



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




747,960✔





2962



        QUERY_CHECK_CODE(code, lino, _end);




748,558✔





2963



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




748,558✔





2964



        (*ppRes) = pBlock;




748,858✔





2965



        return code;




748,860✔





2966



      }










2967



    }










2968












2969



    SMetaTableInfo mtInfo = {0};




771,819✔





2970



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




772,721✔





2971



    QUERY_CHECK_CODE(code, lino, _end);




771,515✔





2972



    if (code != 0) {




771,515✔





2973



      destroyMetaTableInfo(&mtInfo);











UNCOV

2974



      QUERY_CHECK_CODE(code, lino, _end);




×







2975



    }










2976



    STqOffsetVal offset = {0};




771,515✔





2977



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




770,913✔





2978



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




12,005✔





2979



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




12,005✔





2980



    } else {










2981



      SValue val = {0};




760,116✔





2982



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




760,116✔





2983



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




760,120✔





2984



    }










2985



    destroyMetaTableInfo(&mtInfo);










2986



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




772,721✔





2987



    QUERY_CHECK_CODE(code, lino, _end);




772,721✔





2988



    (*ppRes) = NULL;




772,721✔





2989



    return code;




772,721✔





2990



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




6,263✔





2991



    SSnapContext* sContext = pInfo->sContext;




6,263✔





2992



    int64_t st = taosGetTimestampMs();




6,263✔





2993



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




48,336✔





2994



      void*   data = NULL;




47,656✔





2995



      int32_t dataLen = 0;




47,656✔





2996



      int16_t type = 0;




47,656✔





2997



      int64_t uid = 0;




47,656✔





2998



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




47,656✔






UNCOV

2999



        qError("tmqsnap getTableInfoFromSnapshot error");




×







3000



        taosMemoryFreeClear(data);




×







3001



        break;




×







3002



      }










3003












3004



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




47,656✔





3005



        STqOffsetVal offset = {0};




5,583✔





3006



        SValue       val = {0};




5,583✔






UNCOV

3007



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




×







3008



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




5,583✔





3009



        QUERY_CHECK_CODE(code, lino, _end);




5,583✔





3010



        break;




5,583✔





3011



      } else {










3012



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




42,073✔





3013



        SMqMetaRsp tmpMetaRsp = {0};




42,073✔





3014



        tmpMetaRsp.resMsgType = type;




42,073✔





3015



        tmpMetaRsp.metaRspLen = dataLen;




42,073✔





3016



        tmpMetaRsp.metaRsp = data;




42,073✔





3017



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




42,073✔





3018



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




5,045✔





3019



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




5,045✔





3020












3021



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




5,045✔





3022



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




5,045✔





3023



        }










3024



        int32_t  tempRes = TSDB_CODE_SUCCESS;




42,073✔





3025



        uint32_t len = 0;




42,073✔





3026



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




42,073✔





3027



        if (TSDB_CODE_SUCCESS != tempRes) {




41,804✔






UNCOV

3028



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3029



          taosMemoryFreeClear(data);




×







3030



          break;




×







3031



        }










3032












3033



        int32_t tLen = sizeof(SMqRspHead) + len;




41,804✔





3034



        void*   tBuf = taosMemoryCalloc(1, tLen);




41,804✔





3035



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




42,073✔





3036












3037



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




42,073✔





3038



        SEncoder encoder = {0};




42,073✔





3039



        tEncoderInit(&encoder, metaBuff, len);




42,073✔





3040



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




42,073✔





3041



        if (tempLen < 0) {




42,073✔






UNCOV

3042



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3043



          tEncoderClear(&encoder);




×







3044



          taosMemoryFreeClear(tBuf);




×







3045



          taosMemoryFreeClear(data);




×







3046



          break;




×







3047



        }










3048



        taosMemoryFreeClear(data);




42,073✔





3049



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




42,073✔





3050



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




42,073✔





3051












3052



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




42,073✔





3053



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




42,073✔





3054












3055



        int64_t elapsed = taosGetTimestampMs() - st;




42,073✔





3056



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




42,073✔





3057



          break;










3058



        }










3059



      }










3060



    }










3061












3062



    (*ppRes) = NULL;




6,263✔





3063



    return code;




6,263✔





3064



  }










3065













UNCOV

3066



_end:




×







3067



  if (code != TSDB_CODE_SUCCESS) {




×







3068



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




×







3069



    pTaskInfo->code = code;




×







3070



    T_LONG_JMP(pTaskInfo->env, code);




×







3071



  }










3072













UNCOV

3073



  (*ppRes) = NULL;




×







3074



  return code;




×







3075



}










3076












3077



static void destroyTmqRawScanOperatorInfo(void* param) {




126,004✔





3078



  STmqRawScanInfo* pRawScan = (STmqRawScanInfo*)param;




126,004✔





3079



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




126,004✔





3080



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




125,735✔





3081



  tableListDestroy(pRawScan->pTableListInfo);




125,735✔





3082



  taosMemoryFree(pRawScan);




126,004✔





3083



}




125,735✔





3084












3085



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










3086



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










3087



// and schemas are decided when scanning










3088



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




126,004✔





3089



  // create operator










3090



  // create tb reader










3091



  // create meta reader










3092



  // create tq reader










3093












3094



  QRY_PARAM_CHECK(pOptrInfo);




126,004✔





3095



  int32_t code = TSDB_CODE_SUCCESS;




126,004✔





3096



  int32_t lino = 0;




126,004✔





3097












3098



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




126,004✔





3099



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




126,004✔





3100



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




126,004✔






UNCOV

3101



    code = terrno;




×







3102



    lino = __LINE__;




×







3103



    goto _end;




×







3104



  }










3105












3106



  pInfo->pTableListInfo = tableListCreate();




126,004✔





3107



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




126,004✔





3108



  pInfo->vnode = pHandle->vnode;




126,004✔





3109



  pInfo->pAPI = &pTaskInfo->storageAPI;




126,004✔





3110












3111



  pInfo->sContext = pHandle->sContext;




126,004✔





3112



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




126,004✔





3113



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




126,004✔





3114



                  pTaskInfo);










3115












3116



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




125,703✔





3117



                                         NULL, optrDefaultGetNextExtFn, NULL);










3118



  *pOptrInfo = pOperator;




126,004✔





3119



  return code;




126,004✔





3120













UNCOV

3121



_end:




×







3122



  if (code != TSDB_CODE_SUCCESS) {




×







3123



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




×







3124



  }











UNCOV

3125



  taosMemoryFree(pInfo);




×







3126



  taosMemoryFree(pOperator);




×







3127



  pTaskInfo->code = code;




×







3128



  return code;




×







3129



}










3130












3131



void destroyTmqScanOperatorInfo(void* param) {




325,737✔





3132



  if (param == NULL) {




325,737✔






UNCOV

3133



    return;




×







3134



  }










3135












3136



  STmqQueryScanInfo* pTmqScan = (STmqQueryScanInfo*)param;




325,737✔





3137



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




325,737✔





3138



    destroyOperator(pTmqScan->pTableScanOp);




327,957✔





3139



  }










3140












3141



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




327,638✔





3142



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




327,638✔





3143



  }










3144












3145



  if (pTmqScan->pTableListInfo) {




327,674✔





3146



    tableListDestroy(pTmqScan->pTableListInfo);




×







3147



    pTmqScan->pTableListInfo = NULL;




×







3148



  }










3149



  if (pTmqScan->pPseudoExpr) {




327,957✔





3150



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




192,267✔





3151



    taosMemoryFree(pTmqScan->pPseudoExpr);




192,267✔





3152



  }










3153












3154



  taosHashCleanup(pTmqScan->pCol2SlotId);




327,290✔





3155



  pTmqScan->pCol2SlotId = NULL;




327,957✔





3156












3157



  cleanupExprSupp(&pTmqScan->tagCalSup);




327,957✔





3158












3159



  blockDataDestroy(pTmqScan->pRes);




327,674✔





3160












3161



  taosMemoryFree(pTmqScan);




327,957✔





3162



}










3163













UNCOV

3164



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




×








UNCOV

3165



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

3166



  int32_t lino = 0;




×








UNCOV

3167



  pBlock->info.rowSize += bytes;




×








UNCOV

3168



  SColumnInfoData infoData = {0};




×








UNCOV

3169



  infoData.info.type = type;




×








UNCOV

3170



  infoData.info.bytes = bytes;




×








UNCOV

3171



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




×








UNCOV

3172



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




×







3173













UNCOV

3174



_end:




×








UNCOV

3175



  if (code != TSDB_CODE_SUCCESS) {




×








UNCOV

3176



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




×







3177



  }











UNCOV

3178



  return code;




×







3179



}










3180












3181



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




327,957✔





3182



  size_t  numOfCols = LIST_LENGTH(pNodeList);




327,957✔





3183



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




2,065,629✔





3184



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




1,737,672✔





3185



    if (pNode && nodeType(pNode->pExpr) == QUERY_NODE_COLUMN && ((SColumnNode*)pNode->pExpr)->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




1,738,036✔





3186



      *pTsSlotId = pNode->slotId;




327,957✔





3187



    }










3188



  }










3189



}




327,957✔





3190












3191



static int32_t buildCol2SlotId(SNodeList* pNodeList, SHashObj* pCol2SlotId) {




327,957✔





3192



  size_t  numOfCols = LIST_LENGTH(pNodeList);




327,957✔





3193



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




2,065,471✔





3194



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




1,737,514✔





3195



    if (pNode == NULL) {




1,738,036✔





3196



      return TSDB_CODE_INVALID_PARA;




×







3197



    }










3198



    if (nodeType(pNode->pExpr) == QUERY_NODE_COLUMN) {




1,738,036✔





3199



      SColumnNode* pColNode = (SColumnNode*)pNode->pExpr;




1,738,036✔





3200



      int32_t code = taosHashPut(pCol2SlotId, (const void*)&pColNode->colId, sizeof(pColNode->colId), (const void*)&pNode->slotId, sizeof(pNode->slotId));




1,738,036✔





3201



      if (code != TSDB_CODE_SUCCESS) {




1,737,514✔






UNCOV

3202



        return code;




×







3203



      }










3204



    }










3205



  }










3206



  return TSDB_CODE_SUCCESS;




327,957✔





3207



}










3208












3209



int32_t createTmqScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,




327,307✔





3210



                                                  SNode* pTagCond, STableListInfo* pTableListInfo,










3211



                                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3212



  QRY_PARAM_CHECK(pOptrInfo);




327,307✔





3213












3214



  int32_t          code = TSDB_CODE_SUCCESS;




327,957✔





3215



  int32_t          lino = 0;




327,957✔





3216



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




327,957✔





3217



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




327,957✔





3218



  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;




327,957✔





3219



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




327,957✔





3220












3221



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




327,957✔






UNCOV

3222



    code = terrno;




×








UNCOV

3223



    goto _error;




×







3224



  }










3225












3226



  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;




327,957✔





3227



  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;




327,957✔





3228












3229



  pInfo->pTagCond = pTagCond;




327,957✔





3230



  pInfo->pGroupTags = pTableScanNode->pGroupTags;




327,957✔





3231












3232



  pInfo->primaryTsIndex = -1;




327,957✔





3233



  getTsSlotId(pScanPhyNode->pScanCols, &pInfo->primaryTsIndex);




327,957✔





3234



  pInfo->pCol2SlotId = taosHashInit(LIST_LENGTH(pScanPhyNode->pScanCols), taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_ENTRY_LOCK);




327,957✔





3235



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




327,957✔





3236



  code = buildCol2SlotId(pScanPhyNode->pScanCols, pInfo->pCol2SlotId);




327,957✔





3237



  QUERY_CHECK_CODE(code, lino, _error);




327,957✔





3238












3239



  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pDescNode;




327,957✔





3240



  if (LIST_LENGTH(pNode->pSlots) != LIST_LENGTH(pScanPhyNode->pScanCols) + LIST_LENGTH(pScanPhyNode->pScanPseudoCols)) {




327,957✔





3241



    qError("%s column num mismatch between desc and scan node", __func__);




×








UNCOV

3242



    code = TSDB_CODE_TMQ_INVALID_MSG;




×








UNCOV

3243



    goto _error;




×







3244



  }










3245












3246



  if (pTableScanNode->pTags != NULL) {




327,957✔






UNCOV

3247



    int32_t    numOfTags;




×








UNCOV

3248



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




×








UNCOV

3249



    if (pTagExpr == NULL) {




×








UNCOV

3250



      goto _error;




×







3251



    }











UNCOV

3252



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




×








UNCOV

3253



    if (code != 0) {




×








UNCOV

3254



      goto _error;




×







3255



    }










3256



  }










3257












3258



  SOperatorInfo* pTableScanOp = NULL;




327,607✔





3259



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




327,607✔





3260



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




327,368✔





3261



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




630✔






UNCOV

3262



    goto _error;




×







3263



  }










3264












3265



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




326,738✔





3266



  if (pHandle->version > 0) {




327,327✔





3267



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




327,597✔





3268



  }










3269












3270



  STableKeyInfo* pList = NULL;




325,730✔





3271



  int32_t        num = 0;




325,734✔





3272



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




325,734✔





3273



  QUERY_CHECK_CODE(code, lino, _error);




327,680✔





3274












3275



  if (pHandle->initTableReader) {




327,680✔





3276



    pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;




327,680✔





3277



    pTSInfo->base.dataReader = NULL;




327,680✔





3278



  }










3279












3280



  if (pHandle->initTqReader) {




327,400✔





3281



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




327,050✔





3282



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




327,957✔





3283



  } else {










3284



    pInfo->tqReader = pHandle->tqReader;




627✔





3285



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




×







3286



  }










3287












3288



  pInfo->pTableScanOp = pTableScanOp;




327,957✔





3289












3290



  pInfo->readHandle = *pHandle;




327,957✔





3291



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




327,957✔





3292












3293



  SArray* tableIdList = NULL;




327,657✔





3294



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




327,657✔





3295



  QUERY_CHECK_CODE(code, lino, _error);




327,626✔





3296



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




327,626✔





3297



  QUERY_CHECK_CODE(code, lino, _error);




327,957✔





3298



  taosArrayDestroy(tableIdList);




327,957✔





3299



  memcpy(&pTaskInfo->tmqInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond));




327,957✔





3300












3301



  // create the pseduo columns info










3302



  code = createExprInfo(pScanPhyNode->pScanPseudoCols, NULL, &pInfo->pPseudoExpr, &pInfo->numOfPseudoExpr);




327,957✔





3303



  QUERY_CHECK_CODE(code, lino, _error);




327,957✔





3304












3305



  code = filterInitFromNode((SNode*)pScanPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0, NULL);




327,957✔





3306



  QUERY_CHECK_CODE(code, lino, _error);




327,957✔





3307












3308



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




327,957✔





3309



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




327,957✔





3310












3311



  pInfo->pTmqScanOp = pOperator;




327,680✔





3312



  pInfo->readerFn = pTaskInfo->storageAPI.tqReaderFn;




327,957✔





3313












3314



  setOperatorInfo(pOperator, STREAM_SCAN_OP_NAME, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, false, OP_NOT_OPENED, pInfo,




327,680✔





3315



                  pTaskInfo);










3316



  pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);




327,320✔





3317












3318



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doQueueScanNext, NULL, destroyTmqScanOperatorInfo, optrDefaultBufFn,




327,680✔





3319



                                         NULL, optrDefaultGetNextExtFn, NULL);










3320












3321



  *pOptrInfo = pOperator;




327,680✔





3322



  return code;




327,957✔





3323













UNCOV

3324



_error:




×








UNCOV

3325



  if (pInfo != NULL && pInfo->pTableScanOp != NULL) {




×








UNCOV

3326



    STableScanInfo* p = (STableScanInfo*)pInfo->pTableScanOp->info;




×








UNCOV

3327



    if (p != NULL) {




×








UNCOV

3328



      p->base.pTableListInfo = NULL;




×







3329



    }











UNCOV

3330



    destroyTmqScanOperatorInfo(pInfo);




×







3331



  }










3332













UNCOV

3333



  if (pOperator != NULL) {




×








UNCOV

3334



    pOperator->info = NULL;




×








UNCOV

3335



    destroyOperator(pOperator);




×







3336



  }











UNCOV

3337



  pTaskInfo->code = code;




×








UNCOV

3338



  return code;




×







3339



}










3340












3341



static int32_t doTagScanOneTable(SOperatorInfo* pOperator, SSDataBlock* pRes, SMetaReader* mr, SStorageAPI* pAPI) {




12,716,088✔





3342



  int32_t        code = TSDB_CODE_SUCCESS;




12,716,088✔





3343



  int32_t        lino = 0;




12,716,088✔





3344



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




12,716,088✔





3345



  STagScanInfo*  pInfo = pOperator->info;




12,722,826✔





3346



  SExprInfo*     pExprInfo = &pOperator->exprSupp.pExprInfo[0];




12,716,363✔





3347



  int32_t        count = pRes->info.rows;




12,713,473✔





3348












3349



  STableKeyInfo* item = tableListGetInfo(pInfo->pTableListInfo, pInfo->curPos);




12,716,305✔





3350



  if (!item) {




12,710,981✔






UNCOV

3351



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3352



           GET_TASKID(pTaskInfo));











UNCOV

3353



    tDecoderClear(&(*mr).coder);




×








UNCOV

3354



    goto _end;




×







3355



  }










3356












3357



  code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid);




12,710,981✔





3358



  tDecoderClear(&(*mr).coder);




12,726,137✔





3359



  if (code != TSDB_CODE_SUCCESS) {




12,722,775✔






UNCOV

3360



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3361



           GET_TASKID(pTaskInfo));











UNCOV

3362



    goto _end;




×







3363



  }










3364












3365



  char str[512];




12,722,684✔





3366



  for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




58,731,129✔





3367



    SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




46,011,137✔





3368












3369



    // refactor later










3370



    if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) {




46,011,069✔





3371



      STR_TO_VARSTR(str, (*mr).me.name);




5,496,783✔





3372



      code = colDataSetVal(pDst, (count), str, false);




5,495,376✔





3373



      QUERY_CHECK_CODE(code, lino, _end);




5,495,721✔





3374



    } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) {




40,522,227✔





3375



      code = colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false);




8,366,115✔





3376



      QUERY_CHECK_CODE(code, lino, _end);




8,362,874✔





3377



    } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) {




32,151,387✔





3378



      code = colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false);




15,580✔





3379



      QUERY_CHECK_CODE(code, lino, _end);




15,580✔





3380



    } else {  // it is a tag value










3381



      STagVal val = {0};




32,137,418✔





3382



      val.cid = pExprInfo[j].base.pParam[0].pCol->colId;




32,137,922✔





3383



      const char* p = pAPI->metaFn.extractTagVal((*mr).me.ctbEntry.pTags, pDst->info.type, &val);




32,143,953✔





3384












3385



      char* data = NULL;




32,136,917✔





3386



      if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {




32,136,917✔





3387



        data = tTagValToData((const STagVal*)p, false);




32,137,731✔





3388



      } else {










3389



        data = (char*)p;




1,383✔





3390



      }










3391












3392



      code = colDataSetVal(pDst, (count), data,




32,133,236✔





3393



                           (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));




32,134,280✔





3394



      QUERY_CHECK_CODE(code, lino, _end);




32,139,639✔





3395












3396



      if ((pDst->info.type != TSDB_DATA_TYPE_JSON) && (p != NULL) && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) &&




32,139,639✔





3397



          (data != NULL)) {










3398



        taosMemoryFree(data);




11,748,193✔





3399



      }










3400



    }










3401



  }










3402












3403



_end:




12,727,709✔





3404



  if (code != TSDB_CODE_SUCCESS) {




12,721,114✔





3405



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

3406



    pTaskInfo->code = code;




×







3407



  } else {










3408



    pRes->info.rows++;




12,721,114✔





3409



  }










3410












3411



  return code;




12,719,013✔





3412



}










3413












3414



static void tagScanFreeUidTag(void* p) {




7,353,749✔





3415



  STUidTagInfo* pInfo = p;




7,353,749✔





3416



  if (pInfo->pTagVal != NULL) {




7,353,749✔





3417



    taosMemoryFree(pInfo->pTagVal);




7,359,701✔





3418



  }










3419



}




7,352,058✔





3420












3421



static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) {




1,662,211✔





3422



  SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData));




1,662,211✔





3423



  if (pColumnData == NULL) {




1,665,331✔






UNCOV

3424



    return terrno;




×







3425



  }










3426












3427



  pColumnData->info.type = pType->type;




1,665,331✔





3428



  pColumnData->info.bytes = pType->bytes;




1,664,962✔





3429



  pColumnData->info.scale = pType->scale;




1,663,806✔





3430



  pColumnData->info.precision = pType->precision;




1,661,935✔





3431












3432



  int32_t code = colInfoDataEnsureCapacity(pColumnData, numOfRows, true);




1,663,167✔





3433



  if (code != TSDB_CODE_SUCCESS) {




1,661,700✔






UNCOV

3434



    terrno = code;




×








UNCOV

3435



    taosMemoryFree(pColumnData);




×








UNCOV

3436



    return terrno;




×







3437



  }










3438












3439



  pParam->columnData = pColumnData;




1,661,700✔





3440



  pParam->colAlloced = true;




1,664,176✔





3441



  return TSDB_CODE_SUCCESS;




1,662,661✔





3442



}










3443












3444



static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {




10,158,432✔





3445



  int32_t                code = TSDB_CODE_SUCCESS;




10,158,432✔





3446



  int32_t                lino = 0;




10,158,432✔





3447



  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;




10,158,432✔





3448



  SColumnNode*           pSColumnNode = NULL;




10,158,432✔





3449



  if (QUERY_NODE_COLUMN == nodeType((*pNode))) {




10,159,167✔





3450



    pSColumnNode = *(SColumnNode**)pNode;




2,840,557✔





3451



  } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {




7,326,229✔





3452



    SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);




514✔





3453



    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {




514✔






UNCOV

3454



      pSColumnNode = NULL;




×








UNCOV

3455



      pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);




×








UNCOV

3456



      if (NULL == pSColumnNode) {




×








UNCOV

3457



        return DEAL_RES_ERROR;




×







3458



      }











UNCOV

3459



      pSColumnNode->colId = -1;




×








UNCOV

3460



      pSColumnNode->colType = COLUMN_TYPE_TBNAME;




×








UNCOV

3461



      pSColumnNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




×








UNCOV

3462



      pSColumnNode->node.resType.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;




×








UNCOV

3463



      nodesDestroyNode(*pNode);




×








UNCOV

3464



      *pNode = (SNode*)pSColumnNode;




×







3465



    } else {










3466



      return DEAL_RES_CONTINUE;




514✔





3467



    }










3468



  } else {










3469



    return DEAL_RES_CONTINUE;




7,323,810✔





3470



  }










3471












3472



  void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));




2,843,313✔





3473



  if (!data) {




2,839,093✔





3474



    code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));




1,665,566✔





3475



    if (code == TSDB_CODE_DUP_KEY) {




1,671,543✔






UNCOV

3476



      code = TSDB_CODE_SUCCESS;




×







3477



    }










3478



    QUERY_CHECK_CODE(code, lino, _end);




1,671,543✔





3479



    pSColumnNode->slotId = pCtx->index++;




1,671,543✔





3480



    SColumnInfo cInfo = {.colId = pSColumnNode->colId,




1,666,895✔





3481



                         .type = pSColumnNode->node.resType.type,




1,665,201✔





3482



                         .bytes = pSColumnNode->node.resType.bytes};




1,667,035✔





3483



    void*       tmp = taosArrayPush(pCtx->cInfoList, &cInfo);




1,667,684✔





3484



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,670,427✔





3485



  } else {










3486



    SColumnNode* col = *(SColumnNode**)data;




1,173,527✔





3487



    pSColumnNode->slotId = col->slotId;




1,173,527✔





3488



  }










3489












3490



_end:




2,843,447✔





3491



  if (code != TSDB_CODE_SUCCESS) {




2,840,192✔





3492



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




10✔






UNCOV

3493



    return DEAL_RES_ERROR;




×







3494



  }










3495



  return DEAL_RES_CONTINUE;




2,840,546✔





3496



}










3497












3498



static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode,




1,667,208✔





3499



                                      SStorageAPI* pAPI, STagScanInfo* pInfo, void* pStreamRuntimeInfo) {










3500



  int32_t code = TSDB_CODE_SUCCESS;




1,667,208✔





3501



  int32_t lino = 0;




1,667,208✔





3502



  int32_t numOfTables = taosArrayGetSize(aUidTags);




1,667,208✔





3503



  SArray* pBlockList = NULL;




1,667,227✔





3504












3505



  SSDataBlock* pResBlock = createTagValBlockForFilter(pInfo->filterCtx.cInfoList, numOfTables, aUidTags, pVnode, pAPI);




1,667,227✔





3506



  QUERY_CHECK_NULL(pResBlock, code, lino, _end, terrno);




1,662,852✔





3507












3508



  pBlockList = taosArrayInit(1, POINTER_BYTES);




1,662,852✔





3509



  QUERY_CHECK_NULL(pBlockList, code, lino, _end, terrno);




1,662,457✔





3510












3511



  void* tmp = taosArrayPush(pBlockList, &pResBlock);




1,665,689✔





3512



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,665,689✔





3513












3514



  SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)};




1,665,689✔





3515












3516



  SScalarParam output = {0};




1,666,196✔





3517



  code = tagScanCreateResultData(&type, numOfTables, &output);




1,664,595✔





3518



  QUERY_CHECK_CODE(code, lino, _end);




1,662,429✔





3519












3520



  gTaskScalarExtra.pStreamInfo = (void*)pStreamRuntimeInfo;




1,662,429✔





3521



  gTaskScalarExtra.pStreamRange = NULL;




1,662,429✔





3522



  code = scalarCalculate(pTagCond, pBlockList, &output, &gTaskScalarExtra);




1,662,291✔





3523



  QUERY_CHECK_CODE(code, lino, _end);




1,661,481✔





3524












3525



  bool* result = (bool*)output.columnData->pData;




1,661,481✔





3526



  for (int32_t i = 0; i < numOfTables; ++i) {




4,157,107✔





3527



    if (result[i]) {




2,492,069✔





3528



      void* tmp = taosArrayPush(aFilterIdxs, &i);




2,321,725✔





3529



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




2,321,725✔





3530



    }










3531



  }










3532












3533



  colDataDestroy(output.columnData);




1,664,368✔





3534



  taosMemoryFreeClear(output.columnData);




1,661,992✔





3535












3536



_end:




1,659,830✔





3537



  blockDataDestroy(pResBlock);




1,661,109✔





3538



  taosArrayDestroy(pBlockList);




1,659,886✔





3539



  if (code != TSDB_CODE_SUCCESS) {




1,658,416✔






UNCOV

3540



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3541



  }










3542



  return code;




1,658,416✔





3543



}










3544












3545



static int32_t tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo,




29,905,721✔





3546



                                         SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex,










3547



                                         const SStorageAPI* pAPI, void* pVnode) {










3548



  int32_t code = TSDB_CODE_SUCCESS;




29,905,721✔





3549



  int32_t lino = 0;




29,905,721✔





3550



  if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) {




29,905,721✔





3551



    if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) {  // tbname




14,272,848✔






UNCOV

3552



      char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×








UNCOV

3553



      STR_TO_VARSTR(str, "ctbidx");




×







3554













UNCOV

3555



      code = colDataSetVal(pColInfo, rowIndex, str, false);




×








UNCOV

3556



      QUERY_CHECK_CODE(code, lino, _end);




×







3557



    } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) {




14,255,491✔





3558



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false);




7,122,344✔





3559



      QUERY_CHECK_CODE(code, lino, _end);




7,134,812✔





3560



    } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) {




7,137,144✔





3561



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false);




7,125,160✔





3562



      QUERY_CHECK_CODE(code, lino, _end);




7,134,831✔





3563



    }










3564



  } else {










3565



    STagVal tagVal = {0};




15,633,168✔





3566



    tagVal.cid = pExprInfo->base.pParam[0].pCol->colId;




15,631,658✔





3567



    if (pUidTagInfo->pTagVal == NULL) {




15,638,771✔






UNCOV

3568



      colDataSetNULL(pColInfo, rowIndex);




×







3569



    } else {










3570



      const char* p = pAPI->metaFn.extractTagVal(pUidTagInfo->pTagVal, pColInfo->info.type, &tagVal);




15,626,150✔





3571












3572



      if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {




15,641,209✔





3573



        colDataSetNULL(pColInfo, rowIndex);




7,996✔





3574



      } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {




15,635,373✔






UNCOV

3575



        code = colDataSetVal(pColInfo, rowIndex, p, false);




×








UNCOV

3576



        QUERY_CHECK_CODE(code, lino, _end);




×







3577



      } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {




19,182,670✔





3578



        if (IS_STR_DATA_BLOB(pColInfo->info.type)) {




3,587,244✔






UNCOV

3579



          QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_TAG, lino, _end);




×







3580



        }










3581



        char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);




3,565,551✔





3582



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




3,560,227✔





3583












3584



        varDataSetLen(tmp, tagVal.nData);




3,560,227✔





3585



        memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);




3,557,479✔





3586



        code = colDataSetVal(pColInfo, rowIndex, tmp, false);




3,559,722✔





3587



        taosMemoryFree(tmp);




3,565,451✔





3588



        QUERY_CHECK_CODE(code, lino, _end);




3,564,586✔





3589



      } else {










3590



        code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false);




12,042,179✔





3591



        QUERY_CHECK_CODE(code, lino, _end);




12,062,610✔





3592



      }










3593



    }










3594



  }










3595












3596



_end:




29,911,819✔





3597



  if (code != TSDB_CODE_SUCCESS) {




29,911,819✔






UNCOV

3598



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3599



  }










3600



  return code;




29,893,975✔





3601



}










3602












3603



static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags,




4,709,640✔





3604



                                      SArray* aFilterIdxs, bool ignoreFilterIdx, SStorageAPI* pAPI) {










3605



  int32_t       code = TSDB_CODE_SUCCESS;




4,709,640✔





3606



  int32_t       lino = 0;




4,709,640✔





3607



  STagScanInfo* pInfo = pOperator->info;




4,709,640✔





3608



  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];




4,714,046✔





3609



  if (!ignoreFilterIdx) {




4,710,265✔





3610



    size_t szTables = taosArrayGetSize(aFilterIdxs);




1,660,972✔





3611



    for (int i = 0; i < szTables; ++i) {




3,982,705✔





3612



      int32_t       idx = *(int32_t*)taosArrayGet(aFilterIdxs, i);




2,317,782✔





3613



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);




2,318,778✔





3614



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




2,319,872✔





3615



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




13,249,810✔





3616



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




10,921,994✔





3617



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




10,932,980✔





3618



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




10,932,980✔





3619



        QUERY_CHECK_CODE(code, lino, _end);




10,929,938✔





3620



      }










3621



    }










3622



  } else {










3623



    size_t szTables = taosArrayGetSize(aUidTags);




3,049,293✔





3624



    for (int i = 0; i < szTables; ++i) {




7,920,550✔





3625



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);




4,871,244✔





3626



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




4,871,244✔





3627



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




23,828,738✔





3628



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




18,960,609✔





3629



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




18,959,746✔





3630



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




18,959,746✔





3631



        QUERY_CHECK_CODE(code, lino, _end);




18,957,873✔





3632



      }










3633



    }










3634



  }










3635












3636



_end:




3,049,306✔





3637



  if (code != TSDB_CODE_SUCCESS) {




4,714,229✔






UNCOV

3638



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3639



  }










3640



  return code;




4,710,877✔





3641



}










3642












3643



static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




9,376,234✔





3644



  int32_t        code = TSDB_CODE_SUCCESS;




9,376,234✔





3645



  int32_t        lino = 0;




9,376,234✔





3646



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,376,234✔





3647



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




9,377,706✔





3648












3649



  STagScanInfo* pInfo = pOperator->info;




9,375,377✔





3650



  SSDataBlock*  pRes = pInfo->pRes;




9,376,378✔





3651












3652



  QRY_PARAM_CHECK(ppRes);




9,373,575✔





3653












3654



  if (pOperator->status == OP_EXEC_DONE) {




9,373,335✔





3655



    return TSDB_CODE_SUCCESS;




4,588,737✔





3656



  }










3657



  blockDataCleanup(pRes);




4,780,485✔





3658












3659



  if (pInfo->pCtbCursor == NULL) {




4,788,235✔





3660



    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);




4,790,264✔





3661



    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);




4,791,116✔





3662



  } else {











UNCOV

3663



    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);




×








UNCOV

3664



    QUERY_CHECK_CODE(code, lino, _end);




×







3665



  }










3666












3667



  SArray* aUidTags = pInfo->aUidTags;




4,789,738✔





3668



  SArray* aFilterIdxs = pInfo->aFilterIdxs;




4,791,140✔





3669



  int32_t count = 0;




4,790,973✔





3670



  bool    ctbCursorFinished = false;




4,790,973✔





3671



  while (1) {




112,662✔





3672



    taosArrayClearEx(aUidTags, tagScanFreeUidTag);




4,903,635✔





3673



    taosArrayClear(aFilterIdxs);




4,904,753✔





3674












3675



    int32_t numTables = 0;




4,904,591✔





3676



    while (numTables < pOperator->resultInfo.capacity) {




12,274,911✔





3677



      SMCtbCursor* pCur = pInfo->pCtbCursor;




12,277,052✔





3678



      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);




12,274,526✔





3679



      if (uid == 0) {




12,266,664✔





3680



        ctbCursorFinished = true;




4,905,756✔





3681



        break;




4,905,756✔





3682



      }










3683



      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};




7,360,908✔





3684



      info.pTagVal = taosMemoryMalloc(pCur->vLen);




7,364,387✔





3685



      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);




7,352,681✔





3686












3687



      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);




7,352,681✔





3688



      void* tmp = taosArrayPush(aUidTags, &info);




7,370,159✔





3689



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




7,370,159✔





3690



      ++numTables;




7,370,159✔





3691



    }










3692












3693



    if (numTables == 0) {




4,906,125✔





3694



      break;




188,857✔





3695



    }










3696



    bool ignoreFilterIdx = true;




4,717,268✔





3697



    if (pInfo->pTagCond != NULL) {




4,717,268✔





3698



      ignoreFilterIdx = false;




1,667,227✔





3699



      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo, pTaskInfo->pStreamRuntimeInfo);




1,667,227✔





3700



      QUERY_CHECK_CODE(code, lino, _end);




1,660,332✔





3701



    } else {










3702



      ignoreFilterIdx = true;




3,049,025✔





3703



    }










3704












3705



    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);




4,709,357✔





3706



    QUERY_CHECK_CODE(code, lino, _end);




4,711,753✔





3707












3708



    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);




4,711,753✔





3709












3710



    if (count != 0) {




4,709,001✔





3711



      break;




4,596,339✔





3712



    }










3713



  }










3714












3715



  if (count > 0) {




4,785,196✔





3716



    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);




4,595,242✔





3717



  }










3718



  if (count == 0 || ctbCursorFinished) {




4,789,093✔





3719



    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




4,789,457✔





3720



    pInfo->pCtbCursor = NULL;




4,785,769✔





3721



    setOperatorCompleted(pOperator);




4,785,769✔





3722



  }










3723












3724



  pRes->info.rows = count;




4,784,253✔





3725



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




4,784,112✔





3726



  if (bLimitReached) {




4,782,464✔






UNCOV

3727



    setOperatorCompleted(pOperator);




×







3728



  }










3729












3730



  pOperator->resultInfo.totalRows += pRes->info.rows;




4,782,464✔





3731



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




4,782,644✔





3732












3733



_end:




4,776,423✔





3734



  if (code != TSDB_CODE_SUCCESS) {




4,776,423✔






UNCOV

3735



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

3736



    pTaskInfo->code = code;




×








UNCOV

3737



    T_LONG_JMP(pTaskInfo->env, code);




×







3738



  }










3739












3740



  return code;




4,776,423✔





3741



}










3742












3743



static int32_t createTagScanTableListInfoFromParam(SOperatorInfo* pOperator) {




3,831,355✔





3744



  STagScanInfo*          pInfo = pOperator->info;




3,831,355✔





3745



  SExecTaskInfo*         pTaskInfo = pOperator->pTaskInfo;




3,831,355✔





3746



  int32_t                code = 0;




3,831,355✔





3747



  STableListInfo*        pListInfo = pInfo->pTableListInfo;




3,831,355✔





3748



  STagScanOperatorParam* pParam = (STagScanOperatorParam*)pOperator->pOperatorGetParam->value;




3,831,355✔





3749



  tb_uid_t               pUid = pParam->vcUid;




3,831,355✔





3750












3751



  // qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",










3752



  //        pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList),










3753



  //        pOperator->status);










3754












3755



  STableKeyInfo info = {.groupId = 0};




3,831,355✔





3756












3757



  int32_t tableIdx = 0;




3,831,355✔





3758



  taosHashClear(pListInfo->map);




3,831,355✔





3759



  taosArrayClear(pListInfo->pTableList);




3,831,355✔





3760












3761



  if (taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {




3,831,355✔






UNCOV

3762



    if (TSDB_CODE_DUP_KEY == terrno) {




×







3763



    } else {











UNCOV

3764



      return terrno;




×







3765



    }










3766



  }










3767












3768



  info.uid = pUid;




3,831,355✔





3769



  void* p = taosArrayPush(pListInfo->pTableList, &info);




3,831,355✔





3770



  if (p == NULL) {




3,831,355✔






UNCOV

3771



    return terrno;




×







3772



  }










3773












3774



  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));




3,831,355✔





3775












3776



  return code;




3,831,355✔





3777



}










3778












3779



static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




8,452,708✔





3780



  int32_t       code = TSDB_CODE_SUCCESS;




8,452,708✔





3781



  int32_t       lino = 0;




8,452,708✔





3782



  STagScanInfo* pInfo = pOperator->info;




8,452,708✔





3783



  if (pOperator->pOperatorGetParam) {




8,452,681✔





3784



    pOperator->resultInfo.totalRows = 0;




3,831,355✔





3785



    pOperator->dynamicTask = true;




3,831,355✔





3786



    pInfo->curPos = 0;




3,831,355✔





3787



    code = createTagScanTableListInfoFromParam(pOperator);




3,831,355✔





3788



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




3,831,355✔





3789



    pOperator->pOperatorGetParam = NULL;




3,831,355✔





3790



    QUERY_CHECK_CODE(code, lino, _end);




3,831,355✔





3791












3792



    if (pOperator->status == OP_EXEC_DONE) {




3,831,355✔





3793



      pOperator->status = OP_OPENED;




2,112,421✔





3794



    }










3795



  }










3796












3797



  if (pOperator->status == OP_EXEC_DONE) {




8,454,896✔





3798



    (*ppRes) = NULL;




2,298,234✔





3799



    return code;




2,297,181✔





3800



  }










3801












3802



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




6,148,510✔





3803



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




6,146,926✔





3804












3805



  SExprInfo*   pExprInfo = &pOperator->exprSupp.pExprInfo[0];




6,152,359✔





3806



  SSDataBlock* pRes = pInfo->pRes;




6,149,050✔





3807



  blockDataCleanup(pRes);




6,152,359✔





3808












3809



  int32_t size = 0;




6,154,470✔





3810



  code = tableListGetSize(pInfo->pTableListInfo, &size);




6,155,532✔





3811



  QUERY_CHECK_CODE(code, lino, _end);




6,151,111✔





3812












3813



  if (size == 0) {




6,151,111✔





3814



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




19,108✔





3815



    (*ppRes) = NULL;




19,108✔





3816



    return code;




19,108✔





3817



  }










3818












3819



  SMetaReader mr = {0};




6,132,003✔





3820



  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




6,133,083✔





3821



  pRes->info.rows = 0;




6,137,554✔





3822












3823



  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {




18,855,700✔





3824



    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);




12,716,374✔





3825



    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD &&




12,719,017✔





3826



        code != TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED) {










3827



      // ignore other error










3828



      code = TSDB_CODE_SUCCESS;




12,719,079✔





3829



    }










3830



    QUERY_CHECK_CODE(code, lino, _end);




12,719,017✔





3831












3832



    if (++pInfo->curPos >= size) {




12,719,017✔





3833



      setOperatorCompleted(pOperator);




6,139,634✔





3834



    }










3835



  }










3836












3837



  pAPI->metaReaderFn.clearReader(&mr);




6,142,577✔





3838



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




6,140,209✔





3839



  if (bLimitReached) {




6,139,634✔






UNCOV

3840



    setOperatorCompleted(pOperator);




×







3841



  }










3842












3843



  // qDebug("QInfo:0x%" PRIx64 ", create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);










3844



  if (pOperator->status == OP_EXEC_DONE) {




6,139,634✔





3845



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




6,139,634✔





3846



  }










3847












3848



  pOperator->resultInfo.totalRows += pRes->info.rows;




6,139,634✔





3849












3850



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




6,140,209✔





3851



_end:




6,140,196✔





3852



  if (code != TSDB_CODE_SUCCESS) {




6,140,209✔






UNCOV

3853



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

3854



    pTaskInfo->code = code;




×








UNCOV

3855



    T_LONG_JMP(pTaskInfo->env, code);




×







3856



  }










3857



  return code;




6,140,209✔





3858



}










3859












3860



static void destroyTagScanOperatorInfo(void* param) {




9,169,353✔





3861



  STagScanInfo* pInfo = (STagScanInfo*)param;




9,169,353✔





3862



  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {




9,169,353✔






UNCOV

3863



    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




×







3864



  }










3865



  taosHashCleanup(pInfo->filterCtx.colHash);




9,173,651✔





3866



  taosArrayDestroy(pInfo->filterCtx.cInfoList);




9,159,883✔





3867



  taosArrayDestroy(pInfo->aFilterIdxs);




9,161,640✔





3868



  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);




9,162,214✔





3869












3870



  blockDataDestroy(pInfo->pRes);




9,160,461✔





3871



  taosArrayDestroy(pInfo->matchInfo.pList);




9,170,270✔





3872



  tableListDestroy(pInfo->pTableListInfo);




9,170,176✔





3873












3874



  pInfo->pRes = NULL;




9,176,956✔





3875



  pInfo->pTableListInfo = NULL;




9,177,123✔





3876



  taosMemoryFreeClear(param);




9,178,421✔





3877



}




9,172,670✔





3878












3879



static int32_t resetTagScanOperatorState(SOperatorInfo* pOper) {




4,768✔





3880



  int32_t         code = TSDB_CODE_SUCCESS;




4,768✔





3881



  STagScanInfo*   pInfo = pOper->info;




4,768✔





3882












3883



  pOper->status = OP_NOT_OPENED;




4,768✔





3884



  STagScanPhysiNode* pTagScanNode = (STagScanPhysiNode*)pOper->pPhyNode;




4,768✔





3885



  if (pTagScanNode->onlyMetaCtbIdx) {




4,768✔





3886



      SExecTaskInfo* pTaskInfo = pOper->pTaskInfo;




2,056✔





3887



      SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




2,056✔





3888



      pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




2,056✔





3889



      pInfo->pCtbCursor = NULL;




2,056✔





3890



  } else {










3891



      pInfo->curPos = 0;




2,712✔





3892



  }










3893












3894



  return code;




4,768✔





3895



}










3896












3897



int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,




9,173,453✔





3898



                                  STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond,










3899



                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3900



  QRY_PARAM_CHECK(pOptrInfo);




9,173,453✔





3901












3902



  int32_t         code = TSDB_CODE_SUCCESS;




9,181,313✔





3903



  int32_t         lino = 0;




9,181,313✔





3904



  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;




9,181,313✔





3905



  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));




9,181,313✔





3906



  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




9,163,265✔





3907



  if (pInfo == NULL || pOperator == NULL) {




9,150,817✔






UNCOV

3908



    code = terrno;




×








UNCOV

3909



    goto _error;




×







3910



  }










3911



  pOperator->pPhyNode = pTagScanNode;




9,150,817✔





3912



  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;




9,150,145✔





3913












3914



  int32_t    numOfExprs = 0;




9,154,953✔





3915



  SExprInfo* pExprInfo = NULL;




9,157,271✔





3916












3917



  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);




9,159,345✔





3918



  QUERY_CHECK_CODE(code, lino, _error);




9,173,580✔





3919












3920



  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);




9,173,580✔





3921



  QUERY_CHECK_CODE(code, lino, _error);




9,152,728✔





3922












3923



  int32_t num = 0;




9,152,728✔





3924



  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




9,148,195✔





3925



  QUERY_CHECK_CODE(code, lino, _error);




9,149,306✔





3926












3927



  pInfo->pTagCond = pTagCond;




9,149,306✔





3928



  pInfo->pTagIndexCond = pTagIndexCond;




9,158,706✔





3929



  pInfo->suid = pPhyNode->suid;




9,150,382✔





3930



  pInfo->pStorageAPI = &pTaskInfo->storageAPI;




9,144,280✔





3931












3932



  pInfo->pTableListInfo = pTableListInfo;




9,148,032✔





3933



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




9,133,029✔





3934



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




9,166,861✔





3935












3936



  pInfo->readHandle = *pReadHandle;




9,145,284✔





3937



  pInfo->curPos = 0;




9,155,375✔





3938












3939



  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);




9,140,843✔





3940



  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,




9,144,077✔





3941



                  pTaskInfo);










3942



  initResultSizeInfo(&pOperator->resultInfo, 4096);




9,133,810✔





3943



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




9,153,829✔





3944



  QUERY_CHECK_CODE(code, lino, _error);




9,176,663✔





3945












3946



  if (pTagScanNode->onlyMetaCtbIdx) {




9,176,663✔





3947



    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));




4,794,660✔





3948



    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);




4,798,167✔





3949












3950



    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));




4,797,798✔





3951



    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);




4,795,905✔





3952












3953



    pInfo->filterCtx.colHash =




4,796,904✔





3954



        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);




4,797,285✔





3955



    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);




4,797,788✔





3956












3957



    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));




4,792,524✔





3958



    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);




4,794,455✔





3959












3960



    if (pInfo->pTagCond != NULL) {




4,792,800✔





3961



      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);




1,670,077✔





3962



    }










3963



  }










3964



  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;




9,177,698✔





3965



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,




9,175,779✔





3966



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










3967



  setOperatorResetStateFn(pOperator, resetTagScanOperatorState);     




9,166,837✔





3968



  










3969



  *pOptrInfo = pOperator;




9,168,899✔





3970



  return code;




9,167,774✔





3971













UNCOV

3972



_error:




×








UNCOV

3973



  if (pInfo) {




×








UNCOV

3974



    pInfo->pTableListInfo = NULL;




×







3975



  }










3976













UNCOV

3977



  if (pInfo != NULL) destroyTagScanOperatorInfo(pInfo);




×








UNCOV

3978



  if (pOperator != NULL) {




×








UNCOV

3979



    pOperator->info = NULL;




×








UNCOV

3980



    destroyOperator(pOperator);




×







3981



  }











UNCOV

3982



  return code;




×







3983



}










3984












3985



// table merge scan operator










3986












3987



static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {




2,147,483,647✔





3988



  int32_t                 left = *(int32_t*)pLeft;




2,147,483,647✔





3989



  int32_t                 right = *(int32_t*)pRight;




2,147,483,647✔





3990



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




2,147,483,647✔





3991












3992



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




2,147,483,647✔





3993



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




2,147,483,647✔





3994












3995



  if (leftIdx == -1) {




2,147,483,647✔





3996



    return 1;




1,151,364,620✔





3997



  } else if (rightIdx == -1) {




1,438,973,453✔





3998



    return -1;




442,293✔





3999



  }










4000












4001



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




1,438,531,160✔





4002



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




1,438,582,755✔





4003



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




1,439,923,697✔





4004



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




1,439,923,697✔






UNCOV

4005



    ret = -1 * ret;




×







4006



  }










4007



  return ret;




1,438,670,889✔





4008



}










4009













UNCOV

4010



static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) {




×








UNCOV

4011



  int32_t                 left = *(int32_t*)pLeft;




×








UNCOV

4012



  int32_t                 right = *(int32_t*)pRight;




×








UNCOV

4013



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




×







4014













UNCOV

4015



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




×








UNCOV

4016



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




×







4017













UNCOV

4018



  if (leftIdx == -1) {




×








UNCOV

4019



    return 1;




×








UNCOV

4020



  } else if (rightIdx == -1) {




×








UNCOV

4021



    return -1;




×







4022



  }










4023













UNCOV

4024



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




×








UNCOV

4025



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




×








UNCOV

4026



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




×








UNCOV

4027



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




×








UNCOV

4028



    ret = -1 * ret;




×







4029



  }











UNCOV

4030



  if (ret == 0 && pInfo->pPkOrderInfo) {




×








UNCOV

4031



    ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx,




×








UNCOV

4032



                               pInfo->pPkOrderInfo);




×







4033



  }











UNCOV

4034



  return ret;




×







4035



}










4036












4037



int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {




3,319,987✔





4038



  int32_t code = TSDB_CODE_SUCCESS;




3,319,987✔





4039



  int32_t lino = 0;




3,319,987✔





4040



  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));




3,319,987✔





4041



  dst->colList = NULL;




3,319,987✔





4042



  dst->pSlotList = NULL;




3,317,055✔





4043












4044



  if (src->numOfCols > 0) {




3,329,521✔





4045



    dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));




3,300,261✔





4046



    QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);




3,297,818✔





4047



    memcpy(dst->colList, src->colList, src->numOfCols * sizeof(SColumnInfo));




3,272,567✔





4048












4049



    if (src->pSlotList != NULL) {




3,307,197✔





4050



      dst->pSlotList = taosMemoryMalloc(src->numOfCols * sizeof(int32_t));




3,317,170✔





4051



      QUERY_CHECK_NULL(dst->pSlotList, code, lino, _end, terrno);




3,313,779✔





4052



      memcpy(dst->pSlotList, src->pSlotList, src->numOfCols * sizeof(int32_t));




3,257,174✔





4053



    }










4054



  }










4055













UNCOV

4056



_end:




×







4057



  if (code != TSDB_CODE_SUCCESS) {




3,303,996✔






UNCOV

4058



    taosMemoryFreeClear(dst->colList);




×








UNCOV

4059



    taosMemoryFreeClear(dst->pSlotList);




×








UNCOV

4060



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4061



  }










4062



  return code;




3,269,994✔





4063



}










4064












4065



static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,




5,295,727✔





4066



                                                bool* pSubTableHasBlock) {










4067



  int32_t code = 0;




5,295,727✔





4068












4069



  STableMergeScanInfo*    pInfo = pOperator->info;




5,295,727✔





4070



  SReadHandle*            pHandle = &pInfo->base.readHandle;




5,306,019✔





4071



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




5,306,313✔





4072



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




5,285,460✔





4073



  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;




5,300,534✔





4074












4075



  blockDataCleanup(pInput->pReaderBlock);




5,303,780✔





4076



  if (!pInput->bInMemReader) {




5,296,136✔





4077



    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,




5,172,635✔





4078



                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




2,590,132✔





4079



    if (code != 0) {




2,583,914✔





4080



      return code;




×







4081



    }










4082



  }










4083












4084



  pInfo->base.dataReader = pInput->pReader;




5,304,518✔





4085












4086



  while (true) {




7,380✔





4087



    bool hasNext = false;




5,303,456✔





4088



    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);




5,304,189✔





4089



    if (code != 0) {




5,324,035✔






UNCOV

4090



      pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4091



      pInfo->base.dataReader = NULL;




×







4092



      return code;




×







4093



    }










4094












4095



    if (!hasNext || isTaskKilled(pTaskInfo)) {




5,324,035✔





4096



      if (isTaskKilled(pTaskInfo)) {




3,299,985✔





4097



        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4098



        pInfo->base.dataReader = NULL;




×







4099



        return code;




×







4100



      }










4101












4102



      *pSubTableHasBlock = false;




3,304,717✔





4103



      break;




3,302,897✔





4104



    }










4105












4106



    if (pInput->tblCond.order == TSDB_ORDER_ASC) {




2,024,414✔





4107



      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;




1,998,210✔





4108



    } else {










4109



      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;




26,568✔





4110



    }










4111












4112



    uint32_t status = 0;




2,024,414✔





4113



    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);




2,024,414✔





4114



    if (code != 0) {




2,024,409✔






UNCOV

4115



      pInfo->base.dataReader = NULL;




×








UNCOV

4116



      return code;




×







4117



    }










4118












4119



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




2,024,409✔






UNCOV

4120



      *pSubTableHasBlock = false;




×








UNCOV

4121



      break;




×







4122



    }










4123



    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {




2,024,409✔





4124



      continue;




7,380✔





4125



    }










4126












4127



    *pSubTableHasBlock = true;




2,017,034✔





4128



    break;




2,017,034✔





4129



  }










4130












4131



  if (*pSubTableHasBlock) {




5,321,013✔





4132



    pInput->pReaderBlock->info.id.groupId =




4,034,063✔





4133



        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);




4,034,063✔





4134



    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;




2,017,034✔





4135



  }










4136



  if (!pInput->bInMemReader || !*pSubTableHasBlock) {




5,321,382✔





4137



    pAPI->tsdReader.tsdReaderClose(pInput->pReader);




3,873,083✔





4138



    pInput->pReader = NULL;




3,867,244✔





4139



  }










4140












4141



  pInfo->base.dataReader = NULL;




5,314,815✔





4142



  return TSDB_CODE_SUCCESS;




5,313,728✔





4143



}










4144












4145



static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {




1,987,769✔





4146



  pInfo->bGroupProcessed = false;




1,987,769✔





4147












4148



  int32_t numOfTables = 0;




2,002,753✔





4149



  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




1,940,239✔





4150



  if (code != TSDB_CODE_SUCCESS) {




1,914,295✔






UNCOV

4151



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×








UNCOV

4152



    return code;




×







4153



  }










4154












4155



  int32_t i = pInfo->tableStartIndex + 1;




1,914,295✔





4156



  for (; i < numOfTables; ++i) {




3,172,613✔





4157



    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




1,325,968✔





4158



    if (!tableKeyInfo) {




1,323,385✔





4159



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×








UNCOV

4160



      return terrno;




×







4161



    }










4162



    if (tableKeyInfo->groupId != pInfo->groupId) {




1,323,385✔





4163



      break;




58,071✔





4164



    }










4165



  }










4166



  pInfo->tableEndIndex = i - 1;




1,904,716✔





4167



  return TSDB_CODE_SUCCESS;




2,011,075✔





4168



}










4169












4170



static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {




2,024,698✔





4171



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




5,322,863✔





4172



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,300,344✔





4173



    if (pInput->rowIdx == -1) {




3,294,161✔





4174



      continue;




1,579,775✔





4175



    }










4176












4177



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,718,390✔





4178



      pInput->rowIdx = 0;




1,718,390✔





4179



      pInput->pageIdx = -1;




1,718,390✔





4180



    }










4181












4182



    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,717,662✔





4183



    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




1,717,657✔





4184



    if (!col) {




1,717,288✔






UNCOV

4185



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×








UNCOV

4186



      return terrno;




×







4187



    }










4188



    pInput->aTs = (int64_t*)col->pData;




1,717,288✔





4189



  }










4190












4191



  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;




2,023,247✔





4192



  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);




2,026,523✔





4193



}










4194












4195



static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {




1,987,390✔





4196



  int32_t code = setGroupStartEndIndex(pInfo);




1,987,390✔





4197



  if (code != TSDB_CODE_SUCCESS) {




1,991,289✔






UNCOV

4198



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×








UNCOV

4199



    return code;




×







4200



  }










4201



  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));




1,991,289✔





4202



  if (pSubTblsInfo == NULL) {




1,966,791✔






UNCOV

4203



    return terrno;




×







4204



  }










4205



  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);




1,966,791✔





4206



  if (!pSubTblsInfo->pTsOrderInfo) {




1,990,965✔






UNCOV

4207



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×








UNCOV

4208



    return terrno;




×







4209



  }










4210



  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {




1,952,271✔






UNCOV

4211



    pSubTblsInfo->pPkOrderInfo = taosArrayGet(pInfo->pSortInfo, 1);




×








UNCOV

4212



    if (!pSubTblsInfo->pPkOrderInfo) {




×








UNCOV

4213



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×








UNCOV

4214



      return terrno;




×







4215



    }










4216



  } else {










4217



    pSubTblsInfo->pPkOrderInfo = NULL;




1,942,393✔





4218



  }










4219



  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




1,992,466✔





4220



  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));




1,946,083✔





4221



  if (pSubTblsInfo->aInputs == NULL) {




1,929,259✔






UNCOV

4222



    taosMemoryFree(pSubTblsInfo);




×








UNCOV

4223



    return terrno;




×







4224



  }










4225



  int32_t bufPageSize = pInfo->bufPageSize;




1,945,330✔





4226



  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;




1,949,763✔





4227



  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);




1,962,154✔





4228



  if (code != TSDB_CODE_SUCCESS) {




1,962,523✔






UNCOV

4229



    taosMemoryFree(pSubTblsInfo->aInputs);




×








UNCOV

4230



    taosMemoryFree(pSubTblsInfo);




×








UNCOV

4231



    return code;




×







4232



  }










4233



  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;




1,962,523✔





4234



  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;




1,990,641✔





4235












4236



  pInfo->pSubTablesMergeInfo = pSubTblsInfo;




1,972,406✔





4237



  return TSDB_CODE_SUCCESS;




1,953,762✔





4238



}










4239












4240



/*










4241



 * Resolve suid for one subtable and write it into query condition.










4242



 *










4243



 * @param pInfo Table-merge scan runtime info.










4244



 * @param pAPI Storage API set.










4245



 * @param uid Table uid to resolve.










4246



 * @param pCond Query condition to update.










4247



 *










4248



 * @return TSDB_CODE_SUCCESS on success, otherwise error code.










4249



 */










4250



static int32_t setSubTableCondSuidByUid(STableMergeScanInfo* pInfo, SStorageAPI* pAPI, uint64_t uid,




3,278,718✔





4251



                                        SQueryTableDataCond* pCond) {










4252



  int32_t     code = TSDB_CODE_SUCCESS;




3,278,718✔





4253



  int32_t     lino = 0;




3,278,718✔





4254



  SMetaReader tableReader = {0};




3,278,718✔





4255












4256



  QUERY_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);




3,287,489✔





4257



  QUERY_CHECK_NULL(pAPI, code, lino, _end, TSDB_CODE_INVALID_PARA);




3,287,489✔





4258



  QUERY_CHECK_NULL(pCond, code, lino, _end, TSDB_CODE_INVALID_PARA);




3,287,489✔





4259












4260



  pAPI->metaReaderFn.initReader(&tableReader, pInfo->base.readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




3,287,489✔





4261



  code = pAPI->metaReaderFn.getTableEntryByUid(&tableReader, uid);




3,288,656✔





4262



  pAPI->metaReaderFn.readerReleaseLock(&tableReader);




3,271,478✔





4263



  QUERY_CHECK_CODE(code, lino, _end);




3,280,952✔





4264












4265



  if (tableReader.me.type == TSDB_CHILD_TABLE) {




3,280,952✔





4266



    pCond->suid = tableReader.me.ctbEntry.suid;




3,175,832✔





4267



  } else if (tableReader.me.type == TSDB_NORMAL_TABLE) {




105,120✔





4268



    pCond->suid = 0;




105,120✔





4269



  } else {










4270



    code = TSDB_CODE_INVALID_PARA;




×








UNCOV

4271



    QUERY_CHECK_CODE(code, lino, _end);




×







4272



  }










4273












4274



_end:




3,278,763✔





4275



  if (code != TSDB_CODE_SUCCESS) {




3,267,015✔






UNCOV

4276



    qError("%s failed at line %d since %s, uid:%" PRIu64, __func__, lino, tstrerror(code), uid);




×







4277



  }










4278



  pAPI->metaReaderFn.clearReader(&tableReader);




3,267,015✔





4279



  return code;




3,274,405✔





4280



}










4281












4282



static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {




1,989,594✔





4283



  int32_t        code = TSDB_CODE_SUCCESS;




1,989,594✔





4284



  int32_t        lino = 0;




1,989,594✔





4285



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,989,594✔





4286



  SReadHandle*   pHandle = &pInfo->base.readHandle;




1,995,034✔





4287



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,977,572✔





4288












4289



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




1,960,000✔





4290












4291



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




5,227,434✔





4292



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,265,235✔





4293



    pInput->type = SUB_TABLE_MEM_BLOCK;




3,233,412✔





4294












4295



    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);




3,217,311✔





4296



    QUERY_CHECK_CODE(code, lino, _end);




3,203,145✔





4297












4298



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);




3,203,145✔





4299



    QUERY_CHECK_CODE(code, lino, _end);




3,299,571✔





4300












4301



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);




3,299,571✔





4302



    QUERY_CHECK_CODE(code, lino, _end);




3,306,158✔





4303












4304



    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);




3,306,158✔





4305



    pInput->pKeyInfo = keyInfo;




3,303,605✔





4306



    QUERY_CHECK_NULL(pInput->pKeyInfo, code, lino, _end, terrno);




3,303,605✔





4307












4308



    code = setSubTableCondSuidByUid(pInfo, pAPI, pInput->pKeyInfo->uid, &pInput->tblCond);




3,280,189✔





4309



    QUERY_CHECK_CODE(code, lino, _end);




3,260,159✔





4310












4311



    if (isTaskKilled(pTaskInfo)) {




3,260,159✔






UNCOV

4312



      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);




×







4313



    }










4314












4315



    if (i + 1 < pSubTblsInfo->numInMemReaders) {




3,275,118✔





4316



      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,




2,539,484✔





4317



                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




1,274,539✔





4318



      QUERY_CHECK_CODE(code, lino, _end);




1,268,635✔





4319



      pInput->bInMemReader = true;




1,268,635✔





4320



    } else {










4321



      pInput->pReader = NULL;




2,016,291✔





4322



      pInput->bInMemReader = false;




2,017,383✔





4323



    }










4324



    bool hasNext = true;




3,272,435✔





4325



    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);




3,271,313✔





4326



    QUERY_CHECK_CODE(code, lino, _end);




3,302,897✔





4327



    if (!hasNext) {




3,302,897✔





4328



      pInput->rowIdx = -1;




1,584,507✔





4329



      ++pSubTblsInfo->numSubTablesCompleted;




1,581,959✔





4330



      continue;




1,581,959✔





4331



    } else {










4332



      pInput->rowIdx = 0;




1,718,390✔





4333



      pInput->pageIdx = -1;




1,718,390✔





4334



    }










4335



  }










4336












4337



_end:




2,025,062✔





4338



  if (code != TSDB_CODE_SUCCESS) {




2,025,062✔






UNCOV

4339



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4340



  }










4341



  return code;




2,016,326✔





4342



}










4343












4344



static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




2,017,398✔





4345



  int32_t              code = TSDB_CODE_SUCCESS;




2,017,398✔





4346



  int32_t              lino = 0;




2,017,398✔





4347



  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;




2,017,398✔





4348



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




2,017,398✔





4349



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




2,017,398✔





4350



  bool                 hasNext = true;




2,017,398✔





4351



  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);




2,017,398✔





4352



  QUERY_CHECK_CODE(code, lino, _end);




2,017,029✔





4353












4354



  if (!hasNext) {




2,017,029✔





4355



    pInput->rowIdx = -1;




1,718,021✔





4356



    ++pSubTblsInfo->numSubTablesCompleted;




1,718,021✔





4357



  } else {










4358



    pInput->rowIdx = 0;




299,008✔





4359



  }










4360












4361



_end:




2,017,398✔





4362



  if (code != TSDB_CODE_SUCCESS) {




2,017,398✔






UNCOV

4363



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

4364



    pTaskInfo->code = code;




×








UNCOV

4365



    T_LONG_JMP(pTaskInfo->env, code);




×







4366



  }










4367



}




2,017,029✔





4368












4369



static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




1,774,052,462✔





4370



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




1,774,052,462✔





4371



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




1,774,152,492✔





4372












4373



  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,774,499,927✔





4374



  if (pInput->rowIdx < pInputBlock->info.rows - 1) {




1,774,160,720✔





4375



    ++pInput->rowIdx;




1,772,038,569✔





4376



  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {




2,017,398✔





4377



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




2,017,398✔





4378



      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);




2,017,398✔





4379



    }










4380



    if (pInput->rowIdx != -1) {




2,017,029✔





4381



      SColumnInfoData* col = taosArrayGet(pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




299,008✔





4382



      if (!col) {




299,008✔






UNCOV

4383



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×








UNCOV

4384



        return terrno;




×







4385



      }










4386



      pInput->pInputBlock = pInputBlock;




299,008✔





4387



      pInput->aTs = (int64_t*)col->pData;




299,008✔





4388



    }










4389



  }










4390












4391



  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));




1,775,176,490✔





4392



}










4393












4394



static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {




1,775,810,434✔





4395



  int32_t            code = TSDB_CODE_SUCCESS;




1,775,810,434✔





4396



  int32_t            lino = 0;




1,775,810,434✔





4397



  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




1,775,810,434✔





4398



  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,776,194,864✔





4399












4400



  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {




2,147,483,647✔





4401



    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);




2,147,483,647✔





4402



    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);




2,147,483,647✔





4403












4404



    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);




2,147,483,647✔





4405



    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);




2,147,483,647✔





4406



    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);




2,147,483,647✔





4407












4408



    if (isNull) {




2,147,483,647✔





4409



      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);




106,071,888✔





4410



      QUERY_CHECK_CODE(code, lino, _end);




106,074,102✔





4411



    } else {










4412



      if (pSrcColInfo->pData != NULL) {




2,147,483,647✔





4413



        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);




2,147,483,647✔





4414



        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);




2,147,483,647✔





4415



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





4416



      }










4417



    }










4418



  }










4419



  pBlock->info.dataLoad = 1;




1,774,663,088✔





4420



  pBlock->info.scanFlag = pInputBlock->info.scanFlag;




1,774,683,755✔





4421



  pBlock->info.rows += 1;




1,774,581,089✔





4422












4423



_end:




1,774,652,171✔





4424



  if (code != TSDB_CODE_SUCCESS) {




1,774,652,171✔






UNCOV

4425



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4426



  }










4427



  return code;




1,773,842,120✔





4428



}










4429












4430



static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,




4,725,776✔





4431



                                       SSDataBlock** pResBlock) {










4432



  int32_t                 code = TSDB_CODE_SUCCESS;




4,725,776✔





4433



  int32_t                 lino = 0;




4,725,776✔





4434



  STableMergeScanInfo*    pInfo = pOperator->info;




4,725,776✔





4435



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




4,730,872✔





4436



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




4,728,324✔





4437



  bool                    finished = false;




4,726,863✔





4438












4439



  QRY_PARAM_CHECK(pResBlock);




4,726,863✔





4440












4441



  blockDataCleanup(pBlock);




4,719,942✔





4442













UNCOV

4443



  while (true) {




×







4444



    while (true) {










4445



      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {




1,779,423,874✔





4446



        finished = true;




3,307,645✔





4447



        break;




3,307,645✔





4448



      }










4449












4450



      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);




1,776,095,738✔





4451



      QUERY_CHECK_CODE(code, lino, _end);




1,774,102,128✔





4452












4453



      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);




1,774,102,128✔





4454



      QUERY_CHECK_CODE(code, lino, _end);




1,776,072,777✔





4455












4456



      if (pBlock->info.rows >= capacity) {




1,776,072,777✔





4457



        break;




1,431,968✔





4458



      }










4459



    }










4460












4461



    if (isTaskKilled(pTaskInfo)) {




4,739,613✔






UNCOV

4462



      return pTaskInfo->code;




×







4463



    }










4464












4465



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);




4,738,157✔





4466



    if (finished || limitReached || pBlock->info.rows > 0) {




4,733,061✔





4467



      break;










4468



    }










4469



  }










4470












4471



  if (pBlock->info.rows > 0) {




4,733,061✔





4472



    *pResBlock = pBlock;




2,709,814✔





4473



  }










4474












4475



_end:




2,027,615✔





4476



  if (code != TSDB_CODE_SUCCESS) {




4,737,429✔






UNCOV

4477



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

4478



    pTaskInfo->code = code;




×







4479



  }










4480



  return code;




4,737,429✔





4481



}










4482












4483



static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {




1,991,419✔





4484



  int32_t              code = TSDB_CODE_SUCCESS;




1,991,419✔





4485



  int32_t              lino = 0;




1,991,419✔





4486



  STableMergeScanInfo* pInfo = pOperator->info;




1,991,419✔





4487












4488



  code = initSubTablesMergeInfo(pInfo);




2,007,520✔





4489



  QUERY_CHECK_CODE(code, lino, _end);




1,942,767✔





4490












4491



  code = initSubTableInputs(pOperator, pInfo);




1,942,767✔





4492



  QUERY_CHECK_CODE(code, lino, _end);




2,026,523✔





4493












4494



  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);




2,026,523✔





4495



  QUERY_CHECK_CODE(code, lino, _end);




2,010,138✔





4496












4497



_end:




2,010,138✔





4498



  if (code != TSDB_CODE_SUCCESS) {




2,010,138✔






UNCOV

4499



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4500



  }










4501



  return code;




2,014,137✔





4502



}










4503












4504



static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {




29,146,433✔





4505



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




29,146,433✔





4506



  if (pSubTblsInfo != NULL) {




29,163,874✔





4507



    tMergeTreeDestroy(&pSubTblsInfo->pTree);




2,023,975✔





4508












4509



    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




5,331,604✔





4510



      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,302,897✔





4511



      cleanupQueryTableDataCond(&pInput->tblCond);




3,296,345✔





4512



      blockDataDestroy(pInput->pReaderBlock);




3,292,695✔





4513



      blockDataDestroy(pInput->pPageBlock);




3,303,625✔





4514



      taosArrayDestroy(pInput->aBlockPages);




3,306,173✔





4515



      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);




3,306,537✔





4516



      pInput->pReader = NULL;




3,306,537✔





4517



    }










4518












4519



    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);




2,031,255✔





4520



    taosMemoryFree(pSubTblsInfo->aInputs);




2,021,058✔





4521












4522



    taosMemoryFree(pSubTblsInfo);




2,018,510✔





4523



    pInfo->pSubTablesMergeInfo = NULL;




2,022,519✔





4524












4525



    // taosMemoryTrim(0);










4526



  }










4527



}




29,163,510✔





4528












4529



void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




33,163,394✔





4530



  STableMergeScanInfo* pInfo = pOperator->info;




33,163,394✔





4531



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




33,168,207✔





4532



  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));




33,167,160✔





4533












4534



  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);




33,172,359✔





4535



  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;




33,155,148✔





4536



  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;




33,156,536✔





4537



  pInfo->sortExecInfo.loops += sortExecInfo.loops;




33,154,401✔





4538



  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;




33,149,365✔





4539



  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;




33,147,599✔





4540












4541



  tsortDestroySortHandle(pInfo->pSortHandle);




33,147,072✔





4542



  pInfo->pSortHandle = NULL;




33,153,097✔





4543



}




33,151,327✔





4544












4545



/*










4546



 * Rebuild table-merge scan runtime state from dynamic batch scan params.










4547



 *










4548



 * @param pOperator Table-merge scan operator.










4549



 *










4550



 * @return TSDB_CODE_SUCCESS on success, otherwise error code.










4551



 */










4552



static int32_t createVTableMergeScanInfoFromBatchParam(SOperatorInfo* pOperator) {




65,408✔





4553



  int32_t                  code = TSDB_CODE_SUCCESS;




65,408✔





4554



  int32_t                  lino = 0;




65,408✔





4555



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




65,408✔





4556



  STableMergeScanInfo*     pInfo = pOperator->info;




65,408✔





4557



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




65,408✔





4558



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




65,408✔





4559



  SMetaReader              orgTable = {0};




65,408✔





4560



  SOperatorParam*          pGetParam = pOperator->pOperatorGetParam;




65,408✔





4561



  STableScanOperatorParam* pParam = (STableScanOperatorParam*)pGetParam->value;




65,408✔





4562












4563



  if (pParam->paramType != DYN_TYPE_SCAN_PARAM) {




65,408✔






UNCOV

4564



    code = TSDB_CODE_INVALID_PARA;




×








UNCOV

4565



    QUERY_CHECK_CODE(code, lino, _return);




×







4566



  }










4567



  if (pInfo->pSubTablesMergeInfo) {




65,408✔






UNCOV

4568



    stopSubTablesTableMergeScan(pInfo);




×







4569



  }










4570



  if (pInfo->pSortHandle) {




65,408✔






UNCOV

4571



    stopDurationForGroupTableMergeScan(pOperator);




×







4572



  }










4573



  if (pInfo->base.dataReader) {




65,408✔






UNCOV

4574



    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);




×








UNCOV

4575



    pInfo->base.dataReader = NULL;




×







4576



  }










4577












4578



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




65,408✔






UNCOV

4579



    if (pInfo->nextDurationBlocks[i]) {




×








UNCOV

4580



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




×








UNCOV

4581



      pInfo->nextDurationBlocks[i] = NULL;




×







4582



    }










4583



  }










4584



  pInfo->numNextDurationBlocks = 0;




65,408✔





4585



  pInfo->nextDurationBlocksIdx = 0;




65,408✔





4586



  pInfo->rtnNextDurationBlocks = false;




65,408✔





4587



  pInfo->bNewFilesetEvent = false;




65,408✔





4588



  pInfo->bNextDurationBlockEvent = false;




65,408✔





4589



  taosHashCleanup(pInfo->mSkipTables);




65,408✔





4590



  pInfo->mSkipTables = NULL;




65,408✔





4591












4592



  if (pInfo->base.orgCond.colList && pInfo->base.orgCond.numOfCols > 0) {




65,408✔





4593



    cleanupQueryTableDataCond(&pInfo->base.cond);




65,408✔





4594



    code = dumpQueryTableCond(&pInfo->base.orgCond, &pInfo->base.cond);




65,408✔





4595



    QUERY_CHECK_CODE(code, lino, _return);




65,408✔





4596



  }










4597












4598



  if (pParam->window.skey == INT64_MAX && pParam->window.ekey == INT64_MIN) {




65,408✔





4599



    if (pInfo->base.orgCond.colList && pInfo->base.orgCond.numOfCols > 0) {




65,408✔





4600



      pInfo->base.cond.twindows.skey = pInfo->base.orgCond.twindows.skey;




65,408✔





4601



      pInfo->base.cond.twindows.ekey = pInfo->base.orgCond.twindows.ekey;




65,408✔





4602



    }










4603



  } else {











UNCOV

4604



    pInfo->base.cond.twindows.skey = pParam->window.skey;




×








UNCOV

4605



    pInfo->base.cond.twindows.ekey = pParam->window.ekey;




×







4606



  }










4607












4608



  pInfo->tableStartIndex = 0;




65,408✔





4609



  pInfo->tableEndIndex = 0;




65,408✔





4610



  pInfo->hasGroupId = false;




65,408✔





4611



  pInfo->groupId = pParam->groupid;




65,408✔





4612



  pInfo->bGroupProcessed = false;




65,408✔





4613



  pOperator->status = OP_NOT_OPENED;




65,408✔





4614












4615



  pListInfo->oneTableForEachGroup = true;




65,408✔





4616



  pListInfo->numOfOuputGroups = 1;




65,408✔





4617



  taosHashClear(pListInfo->map);




65,408✔





4618



  taosArrayClear(pListInfo->pTableList);




65,408✔





4619












4620



  int32_t tableIdx = 0;




65,408✔





4621



  if (pParam->pBatchTbInfo) {




65,408✔





4622



    int32_t numOfBatchTables = taosArrayGetSize(pParam->pBatchTbInfo);




65,408✔





4623



    for (int32_t i = 0; i < numOfBatchTables; ++i) {




230,096✔





4624



      SOrgTbInfo* pOrgTbInfo = taosArrayGet(pParam->pBatchTbInfo, i);




164,688✔





4625



      QUERY_CHECK_NULL(pOrgTbInfo, code, lino, _return, terrno);




164,688✔





4626












4627



      const char* pTableName = strstr(pOrgTbInfo->tbName, ".");




164,688✔





4628



      pTableName = pTableName ? (pTableName + 1) : pOrgTbInfo->tbName;




164,688✔





4629



      pAPI->metaReaderFn.initReader(&orgTable, pInfo->base.readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




164,688✔





4630



      code = pAPI->metaReaderFn.getTableEntryByName(&orgTable, pTableName);




164,688✔





4631



      pAPI->metaReaderFn.readerReleaseLock(&orgTable);




164,688✔





4632



      QUERY_CHECK_CODE(code, lino, _return);




164,688✔





4633












4634



      uint64_t uid = orgTable.me.uid;




164,688✔





4635



      code = taosHashPut(pListInfo->map, &uid, sizeof(uid), &tableIdx, sizeof(tableIdx));




164,688✔





4636



      if (code == TSDB_CODE_DUP_KEY) {




164,688✔






UNCOV

4637



        pAPI->metaReaderFn.clearReader(&orgTable);




×







4638



        continue;




×







4639



      }










4640



      QUERY_CHECK_CODE(code, lino, _return);




164,688✔





4641












4642



      STableKeyInfo keyInfo = {.groupId = pParam->groupid, .uid = uid};




164,688✔





4643



      QUERY_CHECK_NULL(taosArrayPush(pListInfo->pTableList, &keyInfo), code, lino, _return, terrno);




329,376✔





4644



      ++tableIdx;




164,688✔





4645












4646



      qDebug("%s table merge dynamic batch add table name:%s uid:%" PRIu64 " group:%" PRIu64, GET_TASKID(pTaskInfo),




164,688✔





4647



             pOrgTbInfo->tbName, uid, pParam->groupid);










4648



      pAPI->metaReaderFn.clearReader(&orgTable);




164,688✔





4649



    }










4650



  }










4651












4652



  qDebug("%s table merge dynamic batch param consumed, group:%" PRIu64 ", tables:%d", GET_TASKID(pTaskInfo),




65,408✔





4653



         pParam->groupid, tableIdx);










4654












4655



_return:




65,408✔





4656



  if (code != TSDB_CODE_SUCCESS) {




65,408✔






UNCOV

4657



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4658



  }










4659



  pAPI->metaReaderFn.clearReader(&orgTable);




65,408✔





4660



  return code;




65,408✔





4661



}










4662












4663



int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




4,681,907✔





4664



  int32_t              code = TSDB_CODE_SUCCESS;




4,681,907✔





4665



  int32_t              lino = 0;




4,681,907✔





4666



  int32_t              tableListSize = 0;




4,681,907✔





4667



  int64_t              st = taosGetTimestampUs();




4,669,845✔





4668



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




4,669,845✔





4669



  STableMergeScanInfo* pInfo = pOperator->info;




4,667,282✔





4670












4671



  QRY_PARAM_CHECK(ppRes);




4,644,953✔





4672












4673



  if (pOperator->status == OP_EXEC_DONE && !pOperator->pOperatorGetParam) {




4,648,987✔






UNCOV

4674



    *ppRes = NULL;




×








UNCOV

4675



    return TSDB_CODE_SUCCESS;




×







4676



  }










4677












4678



  if (pOperator->pOperatorGetParam) {




4,629,620✔





4679



    code = createVTableMergeScanInfoFromBatchParam(pOperator);




65,408✔





4680



    QUERY_CHECK_CODE(code, lino, _end);




65,408✔





4681












4682



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




65,408✔





4683



    pOperator->pOperatorGetParam = NULL;




65,408✔





4684



    pOperator->dynamicTask = true;




65,408✔





4685



  }










4686












4687



  code = pOperator->fpSet._openFn(pOperator);




4,623,392✔





4688



  QUERY_CHECK_CODE(code, lino, _end);




4,624,120✔





4689












4690



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




4,624,120✔





4691



  QUERY_CHECK_CODE(code, lino, _end);




4,661,069✔





4692












4693



  if (!pInfo->hasGroupId) {




4,661,069✔





4694



    pInfo->hasGroupId = true;




1,952,686✔





4695












4696



    if (tableListSize == 0) {




1,917,273✔





4697



      setOperatorCompleted(pOperator);




37,638✔





4698



      (*ppRes) = NULL;




37,638✔





4699



      return code;




37,638✔





4700



    }










4701












4702



    pInfo->tableStartIndex = 0;




1,879,635✔





4703



    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,878,124✔





4704



    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




1,877,730✔





4705



    pInfo->groupId = pTmpGpId->groupId;




1,877,730✔





4706



    code = startSubTablesTableMergeScan(pOperator);




1,919,431✔





4707



    QUERY_CHECK_CODE(code, lino, _end);




1,965,166✔





4708



  }










4709












4710



  SSDataBlock* pBlock = NULL;




4,676,112✔





4711



  while (pInfo->tableStartIndex < tableListSize) {




4,730,867✔





4712



    if (isTaskKilled(pTaskInfo)) {




4,733,061✔






UNCOV

4713



      break;




×







4714



    }










4715












4716



    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);




4,729,780✔





4717



    QUERY_CHECK_CODE(code, lino, _end);




4,735,609✔





4718












4719



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




4,735,609✔






UNCOV

4720



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




×








UNCOV

4721



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




×







4722













UNCOV

4723



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




×







4724



    }










4725












4726



    if (pBlock != NULL) {




4,737,429✔





4727



      pBlock->info.id.groupId = pInfo->groupId;




2,709,814✔





4728



      pOperator->resultInfo.totalRows += pBlock->info.rows;




2,709,814✔





4729



      pInfo->bGroupProcessed = true;




2,709,814✔





4730



      break;




2,709,445✔





4731



    } else {










4732



      // Data of this group are all dumped, let's try the next group










4733



      stopSubTablesTableMergeScan(pInfo);




2,027,615✔





4734



      if (pInfo->tableEndIndex >= tableListSize - 1) {




2,021,058✔





4735



        setOperatorCompleted(pOperator);




1,961,521✔





4736



        break;




1,962,249✔





4737



      }










4738












4739



      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




58,440✔





4740



      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




58,440✔





4741



      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




58,440✔





4742












4743



      pInfo->groupId = pTmpGpId->groupId;




58,440✔





4744



      code = startSubTablesTableMergeScan(pOperator);




58,440✔





4745



      QUERY_CHECK_CODE(code, lino, _end);




58,440✔





4746



      resetLimitInfoForNextGroup(&pInfo->limitInfo);




58,440✔





4747



    }










4748



  }










4749












4750



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




4,670,020✔





4751












4752



_end:




4,679,489✔





4753



  if (code != TSDB_CODE_SUCCESS) {




4,678,761✔






UNCOV

4754



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

4755



    pTaskInfo->code = code;




×








UNCOV

4756



    T_LONG_JMP(pTaskInfo->env, code);




×







4757



  } else {










4758



    (*ppRes) = pBlock;




4,678,761✔





4759



  }










4760












4761



  return code;




4,676,577✔





4762



}










4763












4764



static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {




3,540,661✔





4765



  int32_t              code = TSDB_CODE_SUCCESS;




3,540,661✔





4766



  int32_t              lino = 0;




3,540,661✔





4767



  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;




3,540,661✔





4768



  STableMergeScanInfo* pInfo = pOperator->info;




3,540,661✔





4769



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,540,661✔





4770












4771



  if (pInfo->mSkipTables == NULL) {




3,540,661✔





4772



    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,




297,936✔





4773



                                      taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);










4774



    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);




297,936✔





4775



  }










4776



  int bSkip = 1;




3,540,661✔





4777



  if (pInfo->mSkipTables != NULL) {




3,540,661✔





4778



    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));




3,538,991✔





4779



    if (code == TSDB_CODE_DUP_KEY) {




3,540,026✔





4780



      code = TSDB_CODE_SUCCESS;




×







4781



    }










4782



    QUERY_CHECK_CODE(code, lino, _end);




3,540,026✔





4783



  }










4784












4785



_end:




3,540,026✔





4786



  if (code != TSDB_CODE_SUCCESS) {




3,540,026✔





4787



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4788



    pTaskInfo->code = code;




×








UNCOV

4789



    T_LONG_JMP(pTaskInfo->env, code);




×







4790



  }










4791



}




3,540,026✔





4792












4793



static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {




162,526,054✔





4794



  STableMergeScanInfo* pInfo = pOperator->info;




162,526,054✔





4795



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




162,559,089✔





4796



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




162,522,287✔





4797



  SSDataBlock*         pBlock = pInfo->pReaderBlock;




162,502,046✔





4798



  int32_t              code = 0;




162,475,792✔





4799



  bool                 hasNext = false;




162,475,792✔





4800



  STsdbReader*         reader = pInfo->base.dataReader;




162,494,157✔





4801












4802



  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);




162,502,402✔





4803



  if (code != 0) {




162,474,347✔






UNCOV

4804



    pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×








UNCOV

4805



    qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo));




×








UNCOV

4806



    pTaskInfo->code = code;




×








UNCOV

4807



    return code;




×







4808



  }










4809












4810



  if (!hasNext || isTaskKilled(pTaskInfo)) {




162,474,347✔





4811



    if (isTaskKilled(pTaskInfo)) {




28,375,302✔






UNCOV

4812



      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));




×








UNCOV

4813



      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4814



    }










4815



    *pFinished = true;




28,323,785✔





4816



    return code;




28,294,288✔





4817



  }










4818












4819



  uint32_t status = 0;




134,153,432✔





4820



  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);




134,136,384✔





4821












4822



  if (code != TSDB_CODE_SUCCESS) {




134,106,332✔





4823



    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));




16,992✔





4824



    pTaskInfo->code = code;




16,992✔





4825



    return code;




16,992✔





4826



  }










4827












4828



  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




134,089,340✔






UNCOV

4829



    *pFinished = true;




×








UNCOV

4830



    return code;




×







4831



  }










4832












4833



  // current block is filter out according to filter condition, continue load the next block










4834



  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {




134,089,340✔





4835



    *pSkipped = true;




6,302,760✔





4836



    return code;




6,296,382✔





4837



  }










4838












4839



  return code;




127,786,154✔





4840



}










4841












4842



static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {




160,756,521✔





4843



  STableMergeScanSortSourceParam* source = param;




160,756,521✔





4844












4845



  SOperatorInfo*       pOperator = source->pOperator;




160,756,521✔





4846



  STableMergeScanInfo* pInfo = pOperator->info;




160,777,592✔





4847



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




160,820,778✔





4848



  SSDataBlock*         pBlock = NULL;




160,814,554✔





4849



  int64_t              st = taosGetTimestampUs();




160,805,237✔





4850



  int32_t              code = TSDB_CODE_SUCCESS;




160,805,237✔





4851












4852



  while (true) {










4853



    if (pInfo->rtnNextDurationBlocks) {




171,166,031✔





4854



      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",




8,648,749✔





4855



             GET_TASKID(pTaskInfo), pInfo->nextDurationBlocksIdx, pInfo->numNextDurationBlocks);










4856












4857



      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {




8,668,862✔





4858



        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];




4,073,463✔





4859



        ++pInfo->nextDurationBlocksIdx;




4,072,705✔





4860



      } else {










4861



        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




8,658,757✔





4862



          blockDataDestroy(pInfo->nextDurationBlocks[i]);




4,071,992✔





4863



          pInfo->nextDurationBlocks[i] = NULL;




4,068,581✔





4864



        }










4865












4866



        pInfo->rtnNextDurationBlocks = false;




4,587,902✔





4867



        pInfo->nextDurationBlocksIdx = 0;




4,587,523✔





4868



        pInfo->numNextDurationBlocks = 0;




4,586,007✔





4869



        continue;




4,584,870✔





4870



      }










4871



    } else {










4872



      bool bFinished = false;




162,519,423✔





4873



      bool bSkipped = false;




162,493,116✔





4874












4875



      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);




162,549,829✔





4876



      if (code != 0) {




162,409,911✔





4877



        return code;




16,992✔





4878



      }










4879












4880



      pBlock = pInfo->pReaderBlock;




162,392,919✔





4881



      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",




162,445,813✔





4882



             GET_TASKID(pTaskInfo), bFinished, bSkipped, pInfo->bNextDurationBlockEvent, pInfo->bNewFilesetEvent);










4883



      if (bFinished) {




162,580,146✔





4884



        pInfo->bNewFilesetEvent = false;




28,346,983✔





4885



        break;




28,347,514✔





4886



      }










4887












4888



      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {




134,233,163✔





4889



        if (!bSkipped) {




4,590,301✔





4890



          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);




4,073,463✔





4891



          if (code) {




4,061,010✔






UNCOV

4892



            *ppBlock = NULL;




×








UNCOV

4893



            return code;




×







4894



          }










4895












4896



          ++pInfo->numNextDurationBlocks;




4,061,010✔





4897



          if (pInfo->numNextDurationBlocks > 2) {




4,056,825✔






UNCOV

4898



            qError("%s table merge scan prefetch %d next duration blocks. end early.", GET_TASKID(pTaskInfo),




×







4899



                   pInfo->numNextDurationBlocks);











UNCOV

4900



            pInfo->bNewFilesetEvent = false;




×








UNCOV

4901



            break;




×







4902



          }










4903



        }










4904












4905



        if (pInfo->bNewFilesetEvent) {




4,576,262✔





4906



          pInfo->rtnNextDurationBlocks = true;




4,579,082✔





4907



          *ppBlock = NULL;




4,579,071✔





4908



          return code;




4,567,906✔





4909



        }










4910













UNCOV

4911



        if (pInfo->bNextDurationBlockEvent) {




×








UNCOV

4912



          pInfo->bNextDurationBlockEvent = false;




×








UNCOV

4913



          continue;




×







4914



        }










4915



      }










4916



      if (bSkipped) continue;




129,649,878✔





4917



    }










4918












4919



    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);




127,942,129✔





4920












4921



    pOperator->resultInfo.totalRows += pBlock->info.rows;




127,950,615✔





4922



    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;




127,937,684✔





4923



    *ppBlock = pBlock;




127,935,548✔





4924












4925



    return code;




127,931,176✔





4926



  }










4927












4928



  *ppBlock = NULL;




28,347,007✔





4929



  return code;




28,347,514✔





4930



}










4931












4932



int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {




24,947,926✔





4933



  int32_t code = TSDB_CODE_SUCCESS;




24,947,926✔





4934



  int32_t lino = 0;




24,947,926✔





4935



  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));




24,947,926✔





4936



  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);




24,859,140✔





4937



  SBlockOrderInfo biTs = {0};




24,859,140✔





4938



  SBlockOrderInfo biPk = {0};




24,859,125✔





4939












4940



  int32_t tsTargetSlotId = 0;




24,902,802✔





4941



  int32_t pkTargetSlotId = -1;




24,902,802✔





4942



  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {




94,475,166✔





4943



    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);




69,760,743✔





4944



    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);




69,786,190✔





4945



    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




69,786,190✔





4946



      tsTargetSlotId = colInfo->dstSlotId;




24,970,643✔





4947



      biTs.order = order;




24,965,182✔





4948



      biTs.slotId = tsTargetSlotId;




24,965,182✔





4949



      biTs.nullFirst = (order == TSDB_ORDER_ASC);




24,965,182✔





4950



      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);




24,965,182✔





4951



    }










4952



    // TODO: order by just ts










4953



    if (colInfo->isPk) {




69,558,074✔





4954



      pkTargetSlotId = colInfo->dstSlotId;




1,872,189✔





4955



      biPk.order = order;




1,873,495✔





4956



      biPk.slotId = pkTargetSlotId;




1,873,495✔





4957



      biPk.nullFirst = (order == TSDB_ORDER_ASC);




1,873,495✔





4958



      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);




1,873,495✔





4959



    }










4960



  }










4961












4962



  void* tmp = taosArrayPush(pSortInfo, &biTs);




24,959,127✔





4963



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




24,959,127✔





4964



  if (pkTargetSlotId != -1) {




24,959,127✔





4965



    tmp = taosArrayPush(pSortInfo, &biPk);




1,876,706✔





4966



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,876,706✔





4967



  }










4968












4969



  (*ppSortArray) = pSortInfo;




24,958,468✔





4970












4971



_end:




24,809,419✔





4972



  if (code != TSDB_CODE_SUCCESS) {




24,862,084✔






UNCOV

4973



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4974



  }










4975



  return code;




24,862,084✔





4976



}










4977












4978



void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {




12,151,067✔





4979



  STableMergeScanInfo* pTmsInfo = param;




12,151,067✔





4980



  if (type == TSD_READER_NOTIFY_DURATION_START) {




12,151,067✔





4981



    pTmsInfo->bNewFilesetEvent = true;




12,164,923✔






UNCOV

4982



  } else if (type == TSD_READER_NOTIFY_NEXT_DURATION_BLOCK) {




×








UNCOV

4983



    pTmsInfo->bNextDurationBlockEvent = true;




×







4984



  }










4985



  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);




12,137,921✔





4986












4987



  return;




12,201,641✔





4988



}










4989












4990



int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




33,086,300✔





4991



  STableMergeScanInfo* pInfo = pOperator->info;




33,086,300✔





4992



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




33,130,139✔





4993












4994



  int32_t code = TSDB_CODE_SUCCESS;




33,086,595✔





4995



  int32_t lino = 0;




33,086,595✔





4996



  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




33,086,595✔





4997












4998



  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));




33,061,820✔





4999



  pInfo->bNewFilesetEvent = false;




33,202,336✔





5000



  pInfo->bNextDurationBlockEvent = false;




33,162,602✔





5001












5002



  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;




33,159,023✔





5003



  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;




33,148,919✔





5004












5005



  pInfo->pSortHandle = NULL;




33,155,047✔





5006



  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,




66,303,289✔





5007



                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);




33,148,892✔





5008



  if (code) {




33,083,163✔






UNCOV

5009



    return code;




×







5010



  }










5011












5012



  if (pInfo->bSortRowId && numOfTable != 1) {




33,083,163✔





5013



    int32_t memSize = 512 * 1024 * 1024;




3,099,681✔





5014



    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);




3,099,681✔





5015



    QUERY_CHECK_CODE(code, lino, _end);




3,096,467✔





5016



  }










5017












5018



  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);




33,077,498✔





5019



  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);




33,096,519✔





5020



  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);




33,051,710✔





5021












5022



  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);




33,060,104✔





5023



  QUERY_CHECK_CODE(code, lino, _end);




33,010,513✔





5024












5025



  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));




33,010,513✔





5026



  QUERY_CHECK_NULL(param, code, lino, _end, terrno);




33,049,153✔





5027



  param->pOperator = pOperator;




33,049,153✔





5028












5029



  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));




33,037,036✔





5030



  if (ps == NULL) {




33,019,655✔






UNCOV

5031



    taosMemoryFree(param);




×








UNCOV

5032



    QUERY_CHECK_NULL(ps, code, lino, _end, terrno);




×







5033



  }










5034












5035



  ps->param = param;




33,019,655✔





5036



  ps->onlyRef = false;




33,039,635✔





5037



  code = tsortAddSource(pInfo->pSortHandle, ps);




33,060,601✔





5038



  QUERY_CHECK_CODE(code, lino, _end);




33,136,720✔





5039












5040



  if (numOfTable == 1) {




33,136,720✔





5041



    tsortSetSingleTableMerge(pInfo->pSortHandle);




23,289,746✔





5042



  } else {










5043



    code = tsortOpen(pInfo->pSortHandle);




9,846,974✔





5044



    QUERY_CHECK_CODE(code, lino, _end);




9,858,316✔





5045



  }










5046












5047



_end:




9,849,820✔





5048



  if (code != TSDB_CODE_SUCCESS) {




33,100,090✔





5049



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




8,496✔





5050



  }










5051



  return code;




33,104,386✔





5052



}










5053












5054



void startGroupTableMergeScan(SOperatorInfo* pOperator) {




28,551,089✔





5055



  int32_t              code = TSDB_CODE_SUCCESS;




28,551,089✔





5056



  int32_t              lino = 0;




28,551,089✔





5057



  STableMergeScanInfo* pInfo = pOperator->info;




28,551,089✔





5058



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




28,559,128✔





5059



  SReadHandle*         pHandle = &pInfo->base.readHandle;




28,490,717✔





5060



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




28,500,359✔





5061



  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




28,500,376✔





5062












5063



  {










5064



    int32_t numOfTables = 0;




28,523,187✔





5065



    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




28,513,932✔





5066



    QUERY_CHECK_CODE(code, lino, _end);




28,504,089✔





5067












5068



    int32_t i = pInfo->tableStartIndex + 1;




28,504,089✔





5069



    for (; i < numOfTables; ++i) {




137,023,101✔





5070



      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




114,937,298✔





5071



      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);




114,939,917✔





5072



      if (tableKeyInfo->groupId != pInfo->groupId) {




114,939,917✔





5073



        break;




6,413,803✔





5074



      }










5075



    }










5076



    pInfo->tableEndIndex = i - 1;




28,499,606✔





5077



  }










5078



  pInfo->bGroupProcessed = false;




28,561,548✔





5079



  int32_t tableStartIdx = pInfo->tableStartIndex;




28,567,352✔





5080



  int32_t tableEndIdx = pInfo->tableEndIndex;




28,567,170✔





5081












5082



  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;




28,567,455✔





5083



  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);




28,567,455✔





5084



  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,




57,099,622✔





5085



                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);




28,547,687✔





5086



  QUERY_CHECK_CODE(code, lino, _end);




28,507,449✔





5087



  if (pInfo->filesetDelimited) {




28,507,449✔





5088



    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);




28,532,746✔





5089



  }










5090



  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);




28,512,161✔





5091












5092



  code = startDurationForGroupTableMergeScan(pOperator);




28,383,301✔





5093



  QUERY_CHECK_CODE(code, lino, _end);




28,502,086✔





5094












5095



_end:




28,493,590✔





5096



  if (code != TSDB_CODE_SUCCESS) {




28,507,670✔





5097



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




8,496✔





5098



    pTaskInfo->code = code;




8,496✔





5099



    T_LONG_JMP(pTaskInfo->env, code);




8,496✔





5100



  }










5101



}




28,499,174✔





5102












5103



void stopGroupTableMergeScan(SOperatorInfo* pOperator) {




28,573,736✔





5104



  STableMergeScanInfo* pInfo = pOperator->info;




28,573,736✔





5105



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




28,576,659✔





5106



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




28,574,726✔





5107












5108



  stopDurationForGroupTableMergeScan(pOperator);




28,571,391✔





5109












5110



  if (pInfo->base.dataReader != NULL) {




28,565,503✔





5111



    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);




28,567,412✔





5112



    pInfo->base.dataReader = NULL;




28,474,382✔





5113



  }










5114



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




28,487,216✔





5115



    if (pInfo->nextDurationBlocks[i]) {




1,092✔





5116



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




1,092✔





5117



      pInfo->nextDurationBlocks[i] = NULL;




1,092✔





5118



    }










5119



    pInfo->numNextDurationBlocks = 0;




1,092✔





5120



    pInfo->nextDurationBlocksIdx = 0;




1,092✔





5121



  }










5122



  resetLimitInfoForNextGroup(&pInfo->limitInfo);




28,489,687✔





5123



  taosHashCleanup(pInfo->mSkipTables);




28,399,733✔





5124



  pInfo->mSkipTables = NULL;




28,456,300✔





5125



  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




28,453,448✔





5126



}




28,573,153✔





5127












5128



// all data produced by this function only belongs to one group










5129



// slimit/soffset does not need to be concerned here, since this function only deal with data within one group.










5130



SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,




70,551,802✔





5131



                                              SOperatorInfo* pOperator) {










5132



  STableMergeScanInfo* pInfo = pOperator->info;




70,551,802✔





5133



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




70,583,560✔





5134



  STupleHandle*        pTupleHandle = NULL;




70,566,938✔





5135












5136



  blockDataCleanup(pResBlock);




70,567,745✔





5137













UNCOV

5138



  while (1) {




×







5139



    while (1) {




2,147,483,647✔





5140



      pTupleHandle = NULL;




2,147,483,647✔





5141



      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);




2,147,483,647✔





5142



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5143



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




381,999✔





5144



        T_LONG_JMP(pOperator->pTaskInfo->env, code);




381,999✔





5145



      }










5146



      if (pTupleHandle == NULL) {




2,147,483,647✔





5147



        break;




53,705,428✔





5148



      }










5149












5150



      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);




2,147,483,647✔





5151



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔






UNCOV

5152



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×








UNCOV

5153



        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5154



      }










5155












5156



      if (pResBlock->info.rows >= capacity) {




2,147,483,647✔





5157



        break;




16,885,551✔





5158



      }










5159



    }










5160












5161



    if (tsortIsClosed(pHandle)) {




70,590,979✔






UNCOV

5162



      terrno = TSDB_CODE_TSC_QUERY_CANCELLED;




×








UNCOV

5163



      T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5164



    }










5165












5166



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);




70,604,566✔





5167



    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,




70,605,856✔





5168



           pInfo->limitInfo.numOfOutputRows);










5169



    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {




70,624,015✔





5170



      break;










5171



    }










5172



  }










5173



  return (pResBlock->info.rows > 0) ? pResBlock : NULL;




70,624,015✔





5174



}










5175












5176



int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




62,585,312✔





5177



  if (pOperator->status == OP_EXEC_DONE) {




62,585,312✔





5178



    (*ppRes) = NULL;




45,329✔





5179



    return TSDB_CODE_SUCCESS;




45,329✔





5180



  }










5181












5182



  int32_t              code = TSDB_CODE_SUCCESS;




62,537,592✔





5183



  int32_t              lino = 0;




62,537,592✔





5184



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




62,537,592✔





5185



  STableMergeScanInfo* pInfo = pOperator->info;




62,525,220✔





5186












5187



  code = pOperator->fpSet._openFn(pOperator);




62,508,502✔





5188



  QUERY_CHECK_CODE(code, lino, _end);




62,482,699✔





5189












5190



  int64_t st = taosGetTimestampUs();




62,490,002✔





5191












5192



  int32_t tableListSize = 0;




62,490,002✔





5193



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




62,475,826✔





5194



  QUERY_CHECK_CODE(code, lino, _end);




62,523,856✔





5195












5196



  if (!pInfo->hasGroupId) {




62,523,856✔





5197



    pInfo->hasGroupId = true;




25,090,421✔





5198












5199



    if (tableListSize == 0) {




25,048,986✔





5200



      setOperatorCompleted(pOperator);




2,958,490✔





5201



      (*ppRes) = NULL;




2,960,390✔





5202



      return code;




2,960,002✔





5203



    }










5204



    pInfo->tableStartIndex = 0;




22,090,496✔





5205



    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




22,102,578✔





5206



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




22,101,088✔





5207



    pInfo->groupId = tmp->groupId;




22,101,088✔





5208



    startGroupTableMergeScan(pOperator);




22,110,719✔





5209



  }










5210












5211



  SSDataBlock* pBlock = NULL;




59,556,641✔





5212



  while (pInfo->tableStartIndex < tableListSize) {




70,554,697✔





5213



    if (isTaskKilled(pTaskInfo)) {




70,570,143✔






UNCOV

5214



      goto _end;




×







5215



    }










5216












5217



    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,




70,559,888✔





5218



                                              pOperator);










5219



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




70,623,224✔





5220



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,872,495✔





5221



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




1,872,495✔





5222



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




1,872,495✔





5223



    }










5224



    if (pBlock != NULL) {




70,623,504✔





5225



      pBlock->info.id.groupId = pInfo->groupId;




37,456,430✔





5226



      pOperator->resultInfo.totalRows += pBlock->info.rows;




37,456,970✔





5227



      pInfo->bGroupProcessed = true;




37,455,931✔





5228



      break;




37,453,303✔





5229



    } else {










5230



      if (pInfo->bNewFilesetEvent) {




33,167,074✔





5231



        stopDurationForGroupTableMergeScan(pOperator);




4,591,647✔





5232



        code = startDurationForGroupTableMergeScan(pOperator);




4,585,583✔





5233



        QUERY_CHECK_CODE(code, lino, _end);




4,583,752✔





5234



      } else {










5235



        // Data of this group are all dumped, let's try the next group










5236



        stopGroupTableMergeScan(pOperator);




28,573,527✔





5237



        if (pInfo->tableEndIndex >= tableListSize - 1) {




28,564,687✔





5238



          setOperatorCompleted(pOperator);




22,155,627✔





5239



          break;




22,146,229✔





5240



        }










5241












5242



        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




6,414,304✔





5243



        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




6,414,304✔





5244



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




6,414,304✔





5245



        pInfo->groupId = tmp->groupId;




6,414,304✔





5246



        startGroupTableMergeScan(pOperator);




6,414,304✔





5247



        resetLimitInfoForNextGroup(&pInfo->limitInfo);




6,413,782✔





5248



      }










5249



    }










5250



  }










5251












5252



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




59,594,056✔





5253












5254



_end:




59,599,805✔





5255



  if (code != TSDB_CODE_SUCCESS) {




59,602,163✔






UNCOV

5256



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

5257



    pTaskInfo->code = code;




×








UNCOV

5258



    T_LONG_JMP(pTaskInfo->env, code);




×







5259



  } else {










5260



    (*ppRes) = pBlock;




59,602,163✔





5261



  }










5262












5263



  return code;




59,593,357✔





5264



}










5265













UNCOV

5266



static SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {




×








UNCOV

5267



  SSDataBlock* pRes = NULL;




×








UNCOV

5268



  int32_t      code = doTableMergeScanNext(pOperator, &pRes);




×








UNCOV

5269



  return pRes;




×







5270



}










5271












5272



void destroyTableMergeScanOperatorInfo(void* param) {




25,027,446✔





5273



  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;




25,027,446✔





5274












5275



  // start one reader variable










5276



  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {




25,027,446✔





5277



    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);




25,028,270✔





5278



    pTableScanInfo->base.dataReader = NULL;




25,016,992✔





5279



  }










5280












5281



  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {




25,025,234✔






UNCOV

5282



    if (pTableScanInfo->nextDurationBlocks[i] != NULL) {




×








UNCOV

5283



      blockDataDestroy(pTableScanInfo->nextDurationBlocks[i]);




×








UNCOV

5284



      pTableScanInfo->nextDurationBlocks[i] = NULL;




×







5285



    }










5286



  }










5287












5288



  tsortDestroySortHandle(pTableScanInfo->pSortHandle);




25,023,873✔





5289



  pTableScanInfo->pSortHandle = NULL;




25,008,722✔





5290



  taosHashCleanup(pTableScanInfo->mSkipTables);




25,012,164✔





5291



  pTableScanInfo->mSkipTables = NULL;




25,008,498✔





5292



  blockDataDestroy(pTableScanInfo->pSortInputBlock);




25,015,139✔





5293



  pTableScanInfo->pSortInputBlock = NULL;




25,015,217✔





5294



  // end one reader variable










5295












5296



  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);




25,015,581✔





5297












5298



  blockDataDestroy(pTableScanInfo->pResBlock);




25,011,825✔





5299



  pTableScanInfo->pResBlock = NULL;




25,017,314✔





5300












5301



  // remove it from the task->result list










5302



  blockDataDestroy(pTableScanInfo->pReaderBlock);




25,016,967✔





5303



  pTableScanInfo->pReaderBlock = NULL;




25,022,852✔





5304



  taosArrayDestroy(pTableScanInfo->pSortInfo);




25,025,982✔





5305












5306



  stopSubTablesTableMergeScan(pTableScanInfo);




25,010,391✔





5307












5308



  taosMemoryFreeClear(param);




24,989,479✔





5309



}




24,976,758✔





5310












5311



int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {




1,242,789✔





5312



  if (pOptr == NULL) {




1,242,789✔






UNCOV

5313



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));




×








UNCOV

5314



    return TSDB_CODE_INVALID_PARA;




×







5315



  }










5316



  // TODO: merge these two info into one struct










5317



  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));




1,242,789✔





5318



  if (!execInfo) {




1,239,739✔






UNCOV

5319



    return terrno;




×







5320



  }










5321



  STableMergeScanInfo* pInfo = pOptr->info;




1,239,739✔





5322



  execInfo->blockRecorder = pInfo->base.readRecorder;




1,241,652✔





5323



  execInfo->sortExecInfo = pInfo->sortExecInfo;




1,240,515✔





5324












5325



  *pOptrExplain = execInfo;




1,242,419✔





5326



  *len = sizeof(STableMergeScanExecInfo);




1,240,109✔





5327












5328



  return TSDB_CODE_SUCCESS;




1,242,807✔





5329



}










5330












5331



static int32_t resetTableMergeScanOperatorState(SOperatorInfo* pOper) {




2,113,530✔





5332



  int32_t         code = TSDB_CODE_SUCCESS;




2,113,530✔





5333



  STableMergeScanInfo*   pInfo = pOper->info;




2,113,530✔





5334



  pOper->status = OP_NOT_OPENED;




2,113,530✔





5335












5336



  pInfo->tableEndIndex = 0;




2,113,530✔





5337



  pInfo->tableStartIndex = 0;




2,113,530✔





5338



  pInfo->hasGroupId = false;




2,113,530✔





5339



  if (pInfo->base.readerAPI.tsdReaderClose) {




2,113,530✔





5340



    pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);




2,113,530✔





5341



  }










5342



  pInfo->base.dataReader = NULL;




2,113,530✔





5343



  pInfo->base.scanFlag = MAIN_SCAN;




2,113,530✔





5344












5345



  pInfo->base.limitInfo = (SLimitInfo){0};




2,113,530✔





5346



  pInfo->base.limitInfo.limit.limit = -1;




2,113,530✔





5347



  pInfo->base.limitInfo.slimit.limit = -1;




2,113,530✔





5348












5349



  tableListDestroy(pInfo->base.pTableListInfo);




2,113,530✔





5350



  pInfo->base.pTableListInfo = tableListCreate();




2,113,530✔





5351



  if (!pInfo->base.pTableListInfo) {




2,113,530✔






UNCOV

5352



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×








UNCOV

5353



    return terrno;




×







5354



  }










5355



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




2,113,530✔





5356












5357



  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;




2,113,530✔





5358



  code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,




4,227,060✔





5359



                                  &pInfo->base.readHandle, pInfo->base.pTableListInfo, 










5360



                                  pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);




4,227,060✔





5361



  if (code) {




2,113,530✔






UNCOV

5362



    qError("%s failed to createScanTableListInfo, code:%s", __func__, tstrerror(code));




×








UNCOV

5363



    return code;




×







5364



  }










5365












5366



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




2,113,530✔





5367



  cleanupQueryTableDataCond(&pInfo->base.cond);




2,113,281✔





5368



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, false);




2,113,530✔





5369



  if (code) {




2,113,530✔






UNCOV

5370



    qError("%s failed to initQueryTableDataCond, code:%s", __func__, tstrerror(code));




×








UNCOV

5371



    return code;




×







5372



  }










5373












5374



  tsortDestroySortHandle(pInfo->pSortHandle);




2,113,530✔





5375



  pInfo->pSortHandle = NULL;




2,113,269✔





5376












5377



  taosHashCleanup(pInfo->mSkipTables);




2,113,269✔





5378



  pInfo->mSkipTables = NULL;




2,113,269✔





5379



  pOper->resultInfo.totalRows = 0;




2,113,269✔





5380



  










5381



  pInfo->bGroupProcessed = false;




2,113,269✔





5382



  pInfo->bNewFilesetEvent = false;




2,113,290✔





5383



  pInfo->bNextDurationBlockEvent = false;




2,113,044✔





5384



  pInfo->rtnNextDurationBlocks = false;




2,113,113✔





5385



  pInfo->nextDurationBlocksIdx = 0;




2,113,107✔





5386



  pInfo->bSortRowId = false;




2,112,867✔





5387












5388



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




2,113,290✔






UNCOV

5389



    if (pInfo->nextDurationBlocks[i] != NULL) {




×








UNCOV

5390



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




×








UNCOV

5391



      pInfo->nextDurationBlocks[i] = NULL;




×







5392



    }










5393



  }










5394



  pInfo->numNextDurationBlocks = 0;




2,113,530✔





5395












5396



  stopSubTablesTableMergeScan(pInfo);




2,113,269✔





5397



  return code;




2,113,023✔





5398



}










5399












5400



int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




24,908,700✔





5401



                                         STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










5402



                                         SOperatorInfo** pOptrInfo) {










5403



  QRY_PARAM_CHECK(pOptrInfo);




24,908,700✔





5404












5405



  int32_t              code = TSDB_CODE_SUCCESS;




24,942,554✔





5406



  int32_t              lino = 0;




24,942,554✔





5407



  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));




24,942,554✔





5408



  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




24,879,147✔





5409



  if (pInfo == NULL || pOperator == NULL) {




24,764,322✔






UNCOV

5410



    code = terrno;




×








UNCOV

5411



    goto _error;




×







5412



  }










5413












5414



  pOperator->pPhyNode = pTableScanNode;




24,765,351✔





5415



  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;




24,769,480✔





5416












5417



  int32_t numOfCols = 0;




24,824,506✔





5418



  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,




24,858,357✔





5419



                             &pInfo->base.matchInfo);










5420



  QUERY_CHECK_CODE(code, lino, _error);




24,810,017✔





5421












5422



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, false);




24,810,017✔





5423



  QUERY_CHECK_CODE(code, lino, _error);




24,745,970✔





5424












5425



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




24,745,970✔





5426



    SExprSupp* pSup = &pInfo->base.pseudoSup;




10,741,470✔





5427



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);




10,744,775✔





5428



    QUERY_CHECK_CODE(code, lino, _error);




10,746,256✔





5429












5430



    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,




10,746,256✔





5431



                                      &pTaskInfo->storageAPI.functionStore);










5432



    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);




10,700,512✔





5433



  }










5434












5435



  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};




24,711,723✔





5436












5437



  if (tsMetaEntryCache && readHandle->streamRtInfo == NULL) {




24,655,964✔





5438



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(tsMetaEntryCacheSize, -1, .5);




×








UNCOV

5439



    QUERY_CHECK_NULL(pInfo->base.metaCache.pTableMetaEntryCache, code, lino, _error, terrno);




×







5440



  }










5441












5442



  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;




24,655,964✔





5443



  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




24,882,729✔





5444



  pInfo->base.scanFlag = MAIN_SCAN;




24,413,869✔





5445



  pInfo->base.readHandle = *readHandle;




24,685,347✔





5446












5447



  pInfo->readIdx = -1;




24,696,884✔





5448












5449



  pInfo->base.limitInfo.limit.limit = -1;




24,598,325✔





5450



  pInfo->base.limitInfo.slimit.limit = -1;




24,580,381✔





5451



  pInfo->base.pTableListInfo = pTableListInfo;




24,668,424✔





5452












5453



  pInfo->sample.sampleRatio = pTableScanNode->ratio;




24,683,143✔





5454



  pInfo->sample.seed = taosGetTimestampSec();




24,662,994✔





5455












5456



  int32_t sortOrder = pInfo->base.cond.order;




24,820,652✔





5457



  if (pTableScanNode->scan.node.dynamicOp) {




24,832,151✔





5458



    memcpy(&pInfo->base.orgCond, &pInfo->base.cond, sizeof(SQueryTableDataCond));




65,408✔





5459



    sortOrder = pInfo->base.orgCond.order;




65,408✔





5460



    memset(&pInfo->base.cond, 0, sizeof(SQueryTableDataCond));




65,408✔





5461



  }










5462












5463



  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,




24,807,908✔





5464



                            pTaskInfo->pStreamRuntimeInfo);




24,796,914✔





5465



  QUERY_CHECK_CODE(code, lino, _error);




24,744,307✔





5466












5467



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




24,744,307✔





5468












5469



  pInfo->mergeLimit = -1;




24,700,477✔





5470



  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;




24,715,667✔





5471



  if (hasLimit) {




24,789,200✔





5472



    pInfo->mergeLimit = pInfo->limitInfo.limit.offset != -1




3,948,192✔





5473



                            ? pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset




798,248✔





5474



                            : pInfo->limitInfo.limit.limit;




2,764,412✔





5475



    pInfo->mSkipTables = NULL;




1,974,044✔





5476



  }










5477












5478



  initResultSizeInfo(&pOperator->resultInfo, 1024);




24,786,504✔





5479



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




24,751,629✔





5480



  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);




24,857,654✔





5481



  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);




24,786,303✔





5482



  QUERY_CHECK_CODE(code, lino, _error);




24,978,296✔





5483



  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {




24,978,296✔





5484



    pInfo->bSortRowId = true;




5,261,637✔





5485



  } else {










5486



    pInfo->bSortRowId = false;




19,720,104✔





5487



  }










5488












5489



  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);




24,947,406✔





5490



  QUERY_CHECK_CODE(code, lino, _error);




24,905,107✔





5491












5492



  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, sortOrder, &pInfo->pSortInfo);




24,905,107✔





5493



  QUERY_CHECK_CODE(code, lino, _error);




24,788,610✔





5494












5495



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);




24,788,610✔





5496



  QUERY_CHECK_CODE(code, lino, _error);




24,909,096✔





5497












5498



  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;




24,909,096✔





5499












5500



  int32_t  rowSize = pInfo->pResBlock->info.rowSize;




24,942,242✔





5501



  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);




24,878,584✔





5502












5503



  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);




24,782,241✔





5504












5505



  // start one reader variable










5506



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);




24,937,371✔





5507



  QUERY_CHECK_CODE(code, lino, _error);




24,926,248✔





5508












5509



  if (!tsExperimental) {




24,926,248✔






UNCOV

5510



    pInfo->filesetDelimited = false;




×







5511



  } else {










5512



    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




24,926,248✔





5513



  }










5514



  // end one reader variable










5515



  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,




24,881,417✔





5516



                  pInfo, pTaskInfo);










5517



  pOperator->exprSupp.numOfExprs = numOfCols;




24,770,860✔





5518












5519



  pOperator->fpSet = createOperatorFpSet(




24,780,948✔





5520



      optrDummyOpenFn, (pTableScanNode->paraTablesSort || pTableScanNode->scan.node.dynamicOp) ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,




24,852,594✔





5521



      destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn,










5522



      NULL);










5523



  setOperatorResetStateFn(pOperator, resetTableMergeScanOperatorState);     




24,826,843✔





5524



  pOperator->cost.openCost = 0;




24,797,070✔





5525












5526



  *pOptrInfo = pOperator;




24,810,889✔





5527



  return code;




24,731,548✔





5528













UNCOV

5529



_error:




×








UNCOV

5530



  if (code != TSDB_CODE_SUCCESS) {




×








UNCOV

5531



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5532



  }











UNCOV

5533



  pTaskInfo->code = code;




×








UNCOV

5534



  if (pInfo != NULL) {




×








UNCOV

5535



    pInfo->base.pTableListInfo = NULL;




×








UNCOV

5536



    destroyTableMergeScanOperatorInfo(pInfo);




×







5537



  }











UNCOV

5538



  if (pOperator != NULL) {




×








UNCOV

5539



    pOperator->info = NULL;




×








UNCOV

5540



    destroyOperator(pOperator);




×







5541



  }











UNCOV

5542



  return code;




×







5543



}










5544












5545



// ====================================================================================================================










5546



// TableCountScanOperator










5547



static void        destoryTableCountScanOperator(void* param);










5548



static int32_t     buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5549



                                                  SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI);










5550



static int32_t     buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5551



                                                  SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI);










5552



static int32_t     buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5553



                                             STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName);










5554



static int32_t     buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5555



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName);










5556



static int32_t     buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5557



                                          STableCountScanSupp* pSupp, SSDataBlock* pRes);










5558



static void        buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5559



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5560



                                               size_t perfdbTableNum);










5561



static void        buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,










5562



                                              size_t infodbTableNum, size_t perfdbTableNum);










5563



static const char* GROUP_TAG_DB_NAME = "db_name";










5564



static const char* GROUP_TAG_STABLE_NAME = "stable_name";










5565












5566



int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {




29,041✔





5567



  if (scanCols != NULL) {




29,041✔





5568



    SNode* pNode = NULL;




15,574✔





5569



    FOREACH(pNode, scanCols) {




36,394✔





5570



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




20,820✔






UNCOV

5571



        return TSDB_CODE_QRY_SYS_ERROR;




×







5572



      }










5573



      STargetNode* targetNode = (STargetNode*)pNode;




20,820✔





5574



      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {




20,820✔






UNCOV

5575



        return TSDB_CODE_QRY_SYS_ERROR;




×







5576



      }










5577



      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);




20,820✔





5578



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




20,820✔





5579



        supp->dbNameSlotId = targetNode->slotId;




10,314✔





5580



      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




10,506✔





5581



        supp->stbNameSlotId = targetNode->slotId;




10,506✔





5582



      }










5583



    }










5584



  }










5585



  return TSDB_CODE_SUCCESS;




28,802✔





5586



}










5587












5588



int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {




28,863✔





5589



  if (pseudoCols != NULL) {




28,863✔





5590



    SNode* pNode = NULL;




28,890✔





5591



    FOREACH(pNode, pseudoCols) {




57,690✔





5592



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




28,802✔






UNCOV

5593



        return TSDB_CODE_QRY_SYS_ERROR;




×







5594



      }










5595



      STargetNode* targetNode = (STargetNode*)pNode;




28,980✔





5596



      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {




28,980✔





5597



        return TSDB_CODE_QRY_SYS_ERROR;




×







5598



      }










5599



      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);




29,051✔





5600



      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {




29,024✔





5601



        supp->tbCountSlotId = targetNode->slotId;




28,829✔





5602



      }










5603



    }










5604



  }










5605



  return TSDB_CODE_SUCCESS;




28,817✔





5606



}










5607












5608



int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {




29,068✔





5609



  if (groupTags != NULL) {




29,068✔





5610



    SNode* pNode = NULL;




15,574✔





5611



    FOREACH(pNode, groupTags) {




36,394✔





5612



      if (nodeType(pNode) != QUERY_NODE_COLUMN) {




20,820✔






UNCOV

5613



        return TSDB_CODE_QRY_SYS_ERROR;




×







5614



      }










5615



      SColumnNode* colNode = (SColumnNode*)pNode;




20,820✔





5616



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




20,820✔





5617



        supp->groupByDbName = true;




10,314✔





5618



      }










5619



      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




20,820✔





5620



        supp->groupByStbName = true;




10,506✔





5621



      }










5622



    }










5623



  } else {










5624



    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);




13,494✔





5625



    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);




13,467✔





5626



  }










5627



  return TSDB_CODE_SUCCESS;




29,041✔





5628



}










5629












5630



int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,




29,037✔





5631



                              STableCountScanSupp* supp, SExecTaskInfo* taskInfo) {










5632



  int32_t code = 0;




29,037✔





5633



  code = tblCountScanGetInputs(groupTags, tableName, supp);




29,037✔





5634



  if (code != TSDB_CODE_SUCCESS) {




29,024✔






UNCOV

5635



    qError("%s get table count scan supp. get inputs error", GET_TASKID(taskInfo));




×








UNCOV

5636



    return code;




×







5637



  }










5638












5639



  supp->dbNameSlotId = -1;




29,024✔





5640



  supp->stbNameSlotId = -1;




29,041✔





5641



  supp->tbCountSlotId = -1;




29,034✔





5642












5643



  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);




29,024✔





5644



  if (code != TSDB_CODE_SUCCESS) {




28,792✔






UNCOV

5645



    qError("%s get table count scan supp. get group tags slot id error", GET_TASKID(taskInfo));




×








UNCOV

5646



    return code;




×







5647



  }










5648












5649



  code = tblCountScanGetCountSlotId(pseudoCols, supp);




28,792✔





5650



  if (code != TSDB_CODE_SUCCESS) {




28,800✔





5651



    qError("%s get table count scan supp. get count error", GET_TASKID(taskInfo));




54✔






UNCOV

5652



    return code;




×







5653



  }










5654



  return code;




28,746✔





5655



}










5656












5657



int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,




28,890✔





5658



                                         SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










5659



  QRY_PARAM_CHECK(pOptrInfo);




28,890✔





5660












5661



  int32_t                      code = TSDB_CODE_SUCCESS;




29,068✔





5662



  int32_t                      lino = 0;




29,068✔





5663



  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;




29,068✔





5664



  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));




29,014✔





5665



  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




29,041✔





5666



  if (!pInfo || !pOperator) {




29,068✔





5667



    code = terrno;




27✔






UNCOV

5668



    goto _error;




×







5669



  }










5670












5671



  pInfo->readHandle = *readHandle;




29,041✔





5672












5673



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




29,041✔





5674



  initResultSizeInfo(&pOperator->resultInfo, 1);




28,863✔





5675



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




29,041✔





5676



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




29,051✔





5677












5678



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




29,068✔





5679



  QUERY_CHECK_CODE(code, lino, _error);




29,007✔





5680












5681



  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,




29,007✔





5682



                               pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp,










5683



                               pTaskInfo);










5684



  QUERY_CHECK_CODE(code, lino, _error);




28,746✔





5685












5686



  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,




28,746✔





5687



                  pInfo, pTaskInfo);










5688



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,




28,953✔





5689



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










5690



  *pOptrInfo = pOperator;




28,846✔





5691



  return code;




29,024✔





5692













UNCOV

5693



_error:




×








UNCOV

5694



  if (pInfo != NULL) {




×








UNCOV

5695



    destoryTableCountScanOperator(pInfo);




×







5696



  }











UNCOV

5697



  if (pOperator != NULL) {




×








UNCOV

5698



    pOperator->info = NULL;




×








UNCOV

5699



    destroyOperator(pOperator);




×







5700



  }











UNCOV

5701



  pTaskInfo->code = code;




×







5702



  return code;




×







5703



}










5704












5705



int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,




39,665✔





5706



                                    SSDataBlock* pRes) {










5707



  int32_t code = TSDB_CODE_SUCCESS;




39,665✔





5708



  int32_t lino = 0;




39,665✔





5709



  if (pSupp->dbNameSlotId != -1) {




39,665✔





5710



    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




15,562✔





5711



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);




15,562✔





5712



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




15,562✔





5713












5714



    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




15,562✔





5715



    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);




15,562✔





5716












5717



    varDataSetLen(varDbName, strlen(dbName));




15,562✔





5718



    code = colDataSetVal(colInfoData, 0, varDbName, false);




15,562✔





5719



    QUERY_CHECK_CODE(code, lino, _end);




15,562✔





5720



  }










5721












5722



  if (pSupp->stbNameSlotId != -1) {




39,692✔





5723



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);




19,958✔





5724



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




20,123✔





5725



    if (strlen(stbName) != 0) {




20,123✔





5726



      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




14,498✔





5727



      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);




14,498✔





5728



      varDataSetLen(varStbName, strlen(stbName));




14,498✔





5729



      code = colDataSetVal(colInfoData, 0, varStbName, false);




14,498✔





5730



      QUERY_CHECK_CODE(code, lino, _end);




14,498✔





5731



    } else {










5732



      colDataSetNULL(colInfoData, 0);










5733



    }










5734



  }










5735












5736



  if (pSupp->tbCountSlotId != -1) {




39,796✔





5737



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);




39,682✔





5738



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




39,614✔





5739



    code = colDataSetVal(colInfoData, 0, (char*)&count, false);




39,614✔





5740



    QUERY_CHECK_CODE(code, lino, _end);




39,621✔





5741



  }










5742



  pRes->info.rows = 1;




39,604✔





5743












5744



_end:




39,587✔





5745



  if (code != TSDB_CODE_SUCCESS) {




39,587✔






UNCOV

5746



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5747



  }










5748



  return code;




39,378✔





5749



}










5750












5751



static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {




11,331✔





5752



  STableCountScanSupp* pSupp = &pInfo->supp;




11,331✔





5753



  SSDataBlock*         pRes = pInfo->pRes;




11,331✔





5754












5755



  size_t infodbTableNum;




11,331✔





5756



  getInfosDbMeta(NULL, &infodbTableNum);




11,331✔





5757



  infodbTableNum -= 1;




11,331✔





5758



  size_t perfdbTableNum;




11,331✔





5759



  getPerfDbMeta(NULL, &perfdbTableNum);




11,331✔





5760












5761



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




11,331✔





5762



    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);




9,747✔





5763



    return (pRes->info.rows > 0) ? pRes : NULL;




9,747✔





5764



  } else {










5765



    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);




1,584✔





5766



    return (pRes->info.rows > 0) ? pRes : NULL;




1,584✔





5767



  }










5768



}










5769












5770



static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,




1,584✔





5771



                                       size_t infodbTableNum, size_t perfdbTableNum) {










5772



  int32_t        code = TSDB_CODE_SUCCESS;




1,584✔





5773



  int32_t        lino = 0;




1,584✔





5774



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,584✔





5775



  if (strlen(pSupp->stbNameFilter) != 0) {




1,584✔





5776



    // sys dbs do not contain any stable, so the count is always 0










5777



    code = fillTableCountScanDataBlock(pSupp, "", "", 0, pRes);




534✔





5778



    QUERY_CHECK_CODE(code, lino, _end);




534✔





5779



  } else if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) {




1,050✔





5780



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




178✔





5781



    QUERY_CHECK_CODE(code, lino, _end);




178✔





5782



  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {




872✔






UNCOV

5783



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




×








UNCOV

5784



    QUERY_CHECK_CODE(code, lino, _end);




×







5785



  } else if (strlen(pSupp->dbNameFilter) == 0) {




872✔





5786



    code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes);




694✔





5787



    QUERY_CHECK_CODE(code, lino, _end);




694✔





5788



  } else {










5789



    // other dbs do not exist in sys dbs, so the count is always 0










5790



    code = fillTableCountScanDataBlock(pSupp, pSupp->dbNameFilter, pSupp->stbNameFilter, 0, pRes);




178✔





5791



    QUERY_CHECK_CODE(code, lino, _end);




178✔





5792



  }










5793












5794



_end:




178✔





5795



  if (code != TSDB_CODE_SUCCESS) {




1,584✔






UNCOV

5796



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

5797



    pTaskInfo->code = code;




×








UNCOV

5798



    T_LONG_JMP(pTaskInfo->env, code);




×







5799



  }










5800



  setOperatorCompleted(pOperator);




1,584✔





5801



}




1,584✔





5802












5803



static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




9,747✔





5804



                                        STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5805



                                        size_t perfdbTableNum) {










5806



  int32_t        code = TSDB_CODE_SUCCESS;




9,747✔





5807



  int32_t        lino = 0;




9,747✔





5808



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,747✔





5809



  if (pInfo->currGrpIdx == 0) {




9,747✔





5810



    uint64_t groupId = 0;




3,249✔





5811



    if (pSupp->groupByDbName) {




3,249✔





5812



      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));




2,226✔





5813



    } else {










5814



      groupId = calcGroupId("", 0);




1,023✔





5815



    }










5816












5817



    pRes->info.id.groupId = groupId;




3,249✔





5818



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




3,249✔





5819



    QUERY_CHECK_CODE(code, lino, _end);




3,249✔





5820



  } else if (pInfo->currGrpIdx == 1) {




6,498✔





5821



    uint64_t groupId = 0;




3,249✔





5822



    if (pSupp->groupByDbName) {




3,249✔





5823



      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));




2,226✔





5824



    } else {










5825



      groupId = calcGroupId("", 0);




1,023✔





5826



    }










5827












5828



    pRes->info.id.groupId = groupId;




3,249✔





5829



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




3,249✔





5830



    QUERY_CHECK_CODE(code, lino, _end);




3,249✔





5831



  } else {










5832



    setOperatorCompleted(pOperator);




3,249✔





5833



  }










5834



  pInfo->currGrpIdx++;




9,747✔





5835












5836



_end:




9,747✔





5837



  if (code != TSDB_CODE_SUCCESS) {




9,747✔






UNCOV

5838



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

5839



    pTaskInfo->code = code;




×








UNCOV

5840



    T_LONG_JMP(pTaskInfo->env, code);




×







5841



  }










5842



}




9,747✔





5843












5844



static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




68,672✔





5845



  int32_t                      code = TSDB_CODE_SUCCESS;




68,672✔





5846



  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;




68,672✔





5847



  STableCountScanOperatorInfo* pInfo = pOperator->info;




68,682✔





5848



  STableCountScanSupp*         pSupp = &pInfo->supp;




68,672✔





5849



  SSDataBlock*                 pRes = pInfo->pRes;




68,672✔





5850












5851



  blockDataCleanup(pRes);




68,672✔





5852



  QRY_PARAM_CHECK(ppRes);




68,777✔





5853












5854



  if (pOperator->status == OP_EXEC_DONE) {




68,777✔





5855



    return code;




17,521✔





5856



  }










5857












5858



  if (pInfo->readHandle.mnd != NULL) {




51,239✔





5859



    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);




11,331✔





5860



    return code;




11,331✔





5861



  }










5862












5863



  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);




39,908✔





5864



  if (code != TSDB_CODE_SUCCESS) {




39,662✔





5865



    qError("%s failed since %s", __func__, tstrerror(code));




×








UNCOV

5866



    pTaskInfo->code = code;




×








UNCOV

5867



    T_LONG_JMP(pTaskInfo->env, code);




×







5868



  }










5869



  if (pRes->info.rows > 0) {




39,662✔





5870



    *ppRes = pRes;




31,610✔





5871



  }










5872












5873



  return code;




39,618✔





5874



}










5875












5876



static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




39,908✔





5877



                                      STableCountScanSupp* pSupp, SSDataBlock* pRes) {










5878



  int32_t        code = TSDB_CODE_SUCCESS;




39,908✔





5879



  int32_t        lino = 0;




39,908✔





5880



  const char*    db = NULL;




39,908✔





5881



  int32_t        vgId = 0;




39,908✔





5882



  char           dbName[TSDB_DB_NAME_LEN] = {0};




39,908✔





5883



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




39,908✔





5884



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




39,908✔





5885












5886



  // get dbname










5887



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);




39,908✔





5888



  SName sn = {0};




39,891✔





5889












5890



  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);




39,891✔





5891



  QUERY_CHECK_CODE(code, lino, _end);




39,891✔





5892












5893



  code = tNameGetDbName(&sn, dbName);




39,891✔





5894



  QUERY_CHECK_CODE(code, lino, _end);




39,864✔





5895












5896



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




39,864✔





5897



    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);




28,005✔





5898



  } else {










5899



    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);




11,849✔





5900



  }










5901












5902



_end:




39,823✔





5903



  if (code != TSDB_CODE_SUCCESS) {




39,823✔






UNCOV

5904



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5905



    pTaskInfo->code = code;




×







5906



  }










5907












5908



  return code;




39,823✔





5909



}










5910












5911



static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




27,998✔





5912



                                           STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) {










5913



  int32_t        code = TSDB_CODE_SUCCESS;




27,998✔





5914



  int32_t        lino = 0;




27,998✔





5915



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




27,998✔





5916



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




27,998✔





5917












5918



  if (pSupp->groupByStbName) {




27,998✔





5919



    if (pInfo->stbUidList == NULL) {




23,954✔





5920



      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));




8,281✔





5921



      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);




8,281✔





5922



      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);




8,281✔





5923



      QUERY_CHECK_CODE(code, lino, _end);




8,281✔





5924



    }










5925












5926



    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {




23,954✔





5927



      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);




14,498✔





5928



      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);




14,498✔





5929



      QUERY_CHECK_CODE(code, lino, _end);




14,498✔





5930












5931



      pInfo->currGrpIdx++;




14,498✔





5932



    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {




9,456✔





5933



      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);




8,281✔





5934



      QUERY_CHECK_CODE(code, lino, _end);




8,281✔





5935












5936



      pInfo->currGrpIdx++;




8,281✔





5937



    } else {










5938



      setOperatorCompleted(pOperator);




1,175✔





5939



    }










5940



  } else {










5941



    uint64_t groupId = calcGroupId(dbName, strlen(dbName));




4,044✔





5942



    pRes->info.id.groupId = groupId;




4,044✔





5943












5944



    int64_t dbTableCount = 0;




4,044✔





5945



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);




4,044✔





5946



    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);




4,044✔





5947



    QUERY_CHECK_CODE(code, lino, _end);




4,044✔





5948



    setOperatorCompleted(pOperator);




4,044✔





5949



  }










5950












5951



_end:




27,998✔





5952



  if (code != TSDB_CODE_SUCCESS) {




27,998✔






UNCOV

5953



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×








UNCOV

5954



    pTaskInfo->code = code;




×







5955



  }










5956



  return code;




27,998✔





5957



}










5958












5959



static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




11,866✔





5960



                                         STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) {










5961



  int32_t        code = TSDB_CODE_SUCCESS;




11,866✔





5962



  int32_t        lino = 0;




11,866✔





5963



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




11,866✔





5964



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




11,866✔





5965












5966



  if (strlen(pSupp->dbNameFilter) != 0 && strcmp(dbName, pSupp->dbNameFilter) != 0) {




11,893✔





5967



    // db name not match, return count 0











UNCOV

5968



    code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




×








UNCOV

5969



    QUERY_CHECK_CODE(code, lino, _end);




×







5970



  } else if (strlen(pSupp->stbNameFilter) != 0) {




11,849✔





5971



    uint64_t uid = 0;




5,849✔





5972



    code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid);




5,876✔





5973



    if (code == TSDB_CODE_TDB_TABLE_NOT_EXIST) {




5,781✔





5974



      // table not exist, return count 0










5975



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




1,424✔





5976



      QUERY_CHECK_CODE(code, lino, _end);




1,485✔





5977



    } else {










5978



      QUERY_CHECK_CODE(code, lino, _end);




4,357✔





5979












5980



      int64_t numOfChildTables = 0;




4,357✔





5981



      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL, NULL);




4,357✔





5982



      QUERY_CHECK_CODE(code, lino, _end);




4,391✔





5983












5984



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes);




4,391✔





5985



      QUERY_CHECK_CODE(code, lino, _end);




4,313✔





5986



    }










5987



  } else {










5988



    int64_t tbNumVnode = 0;




6,000✔





5989



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);




6,017✔





5990



    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);




6,017✔





5991



    QUERY_CHECK_CODE(code, lino, _end);




6,017✔





5992



  }










5993












5994



_end:




11,842✔





5995



  if (code != TSDB_CODE_SUCCESS) {




11,842✔






UNCOV

5996



    pTaskInfo->code = code;




×








UNCOV

5997



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5998



  }










5999












6000



  setOperatorCompleted(pOperator);




11,842✔





6001



  return code;




11,761✔





6002



}










6003












6004



static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




8,281✔





6005



                                              SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) {










6006



  int32_t code = TSDB_CODE_SUCCESS;




8,281✔





6007



  int32_t lino = 0;




8,281✔





6008



  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




8,281✔





6009



  if (pSupp->groupByDbName) {




8,281✔





6010



    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");




4,044✔





6011



  }










6012












6013



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




8,281✔





6014



  pRes->info.id.groupId = groupId;




8,281✔





6015












6016



  int64_t numOfTables = 0;




8,281✔





6017



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);




8,281✔





6018












6019



  if (numOfTables != 0) {




8,281✔





6020



    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);




1,175✔





6021



  }










6022












6023



_end:




7,106✔





6024



  if (code != TSDB_CODE_SUCCESS) {




8,281✔






UNCOV

6025



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







6026



  }










6027



  return code;




8,281✔





6028



}










6029












6030



static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




14,498✔





6031



                                              SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) {










6032



  int32_t code = TSDB_CODE_SUCCESS;




14,498✔





6033



  int32_t lino = 0;




14,498✔





6034



  char    stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




14,498✔





6035



  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);




14,498✔





6036



  QUERY_CHECK_CODE(code, lino, _end);




14,498✔





6037












6038



  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




14,498✔





6039



  if (pSupp->groupByDbName) {




14,498✔





6040



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));




6,736✔





6041



  } else {










6042



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));




7,762✔





6043



  }










6044












6045



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




14,498✔





6046



  pRes->info.id.groupId = groupId;




14,498✔





6047












6048



  int64_t ctbNum = 0;




14,498✔





6049



  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL, NULL);




14,498✔





6050



  QUERY_CHECK_CODE(code, lino, _end);




14,498✔





6051



  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);




14,498✔





6052



  QUERY_CHECK_CODE(code, lino, _end);




14,498✔





6053












6054



_end:




14,498✔





6055



  if (code != TSDB_CODE_SUCCESS) {




14,498✔






UNCOV

6056



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







6057



  }










6058



  return code;




14,498✔





6059



}










6060












6061



static void destoryTableCountScanOperator(void* param) {




29,068✔





6062



  STableCountScanOperatorInfo* pTableCountScanInfo = param;




29,068✔





6063



  blockDataDestroy(pTableCountScanInfo->pRes);




29,068✔





6064












6065



  taosArrayDestroy(pTableCountScanInfo->stbUidList);




29,051✔





6066



  taosMemoryFreeClear(param);




29,068✔





6067



}




29,068✔



















    

  • 

    •