taosdata / TDengine / #4937

coverage: 66.794% (+0.05%) from 66.746%
#4937

push

travis-ci

web-flow 
fix: case failuer caused by the modification of the error description (#34391)

204171 of 305671 relevant lines covered (66.79%)

127025939.33 hits per line

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

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









16



#include "executor.h"










17



#include "executorInt.h"










18



#include "filter.h"










19



#include "function.h"










20



#include "functionMgt.h"










21



#include "os.h"










22



#include "querynodes.h"










23



#include "streamexecutorInt.h"










24



#include "systable.h"










25



#include "tname.h"










26












27



#include "tdatablock.h"










28



#include "tmsg.h"










29



#include "ttime.h"










30












31



#include "operator.h"










32



#include "query.h"










33



#include "querytask.h"










34



#include "tcompare.h"










35



#include "thash.h"










36



#include "ttypes.h"










37












38



#include "function.h"










39



#include "storageapi.h"










40



#include "wal.h"










41












42



int32_t scanDebug = 0;










43












44



#define MULTI_READER_MAX_TABLE_NUM     5000










45



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










46



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










47



#define STREAM_SCAN_OP_NAME            "StreamScanOperator"










48



#define STREAM_SCAN_OP_STATE_NAME      "StreamScanFillHistoryState"










49



#define STREAM_SCAN_OP_CHECKPOINT_NAME "StreamScanOperator_Checkpoint"










50












51



typedef struct STableMergeScanExecInfo {










52



  SFileBlockLoadRecorder blockRecorder;










53



  SSortExecInfo          sortExecInfo;










54



} STableMergeScanExecInfo;










55












56



typedef struct STableMergeScanSortSourceParam {










57



  SOperatorInfo* pOperator;










58



  int32_t        readerIdx;










59



  uint64_t       uid;










60



  STsdbReader*   reader;










61



} STableMergeScanSortSourceParam;










62












63



typedef struct STableCountScanOperatorInfo {










64



  SReadHandle  readHandle;










65



  SSDataBlock* pRes;










66












67



  STableCountScanSupp supp;










68












69



  int32_t currGrpIdx;










70



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










71



} STableCountScanOperatorInfo;










72












73



static bool    processBlockWithProbability(const SSampleExecInfo* pInfo);










74



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










75












76



bool processBlockWithProbability(const SSampleExecInfo* pInfo) {




585,077,752✔





77



#if 0










78



  if (pInfo->sampleRatio == 1) {










79



    return true;










80



  }










81












82



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










83



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










84



#else










85



  return true;




585,077,752✔





86



#endif










87



}










88












89



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




66,207✔





90



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




66,207✔





91



    SWITCH_ORDER(pCtx[i].order);




×







92



  }










93



}




66,207✔





94












95



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




627,722,764✔





96



  int32_t     code = TSDB_CODE_SUCCESS;




627,722,764✔





97



  STimeWindow w = {0};




627,722,764✔





98












99



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










100



  if (pInterval->interval == 0) {




627,758,464✔





101



    *overlap = false;




588,667,922✔





102



    return code;




588,703,815✔





103



  }










104












105



  if (order == TSDB_ORDER_ASC) {




39,158,986✔





106



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




37,143,992✔





107



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




37,142,135✔





108



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




×







109



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







110



    }










111












112



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




37,137,312✔





113



      *overlap = true;




31,808,518✔





114



      return code;




31,808,946✔





115



    }










116












117



    while (1) {










118



      getNextTimeWindow(pInterval, &w, order);




5,332,859✔





119



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




5,343,010✔





120



        break;




5,078,231✔





121



      }










122












123



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




263,533✔





124



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




×







125



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







126



      }










127



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




263,533✔





128



        *overlap = true;




263,533✔





129



        return code;




263,533✔





130



      }










131



    }










132



  } else {










133



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




2,041,311✔





134



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




2,041,903✔





135



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




×







136



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







137



    }










138












139



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




2,042,393✔





140



      *overlap = true;




1,602,389✔





141



      return code;




1,602,981✔





142



    }










143












144



    while (1) {










145



      getNextTimeWindow(pInterval, &w, order);




439,412✔





146



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




439,412✔





147



        break;




436,850✔





148



      }










149












150



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




2,562✔





151



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




×







152



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







153



      }










154



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




2,562✔





155



        *overlap = true;




2,562✔





156



        return code;




2,562✔





157



      }










158



    }










159



  }










160












161



  *overlap = false;




5,515,081✔





162



  return code;




5,514,539✔





163



}










164












165



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










166



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




159,941,964✔





167



  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {




159,941,964✔





168



    return NULL;




×







169



  }










170












171



  int64_t buf[2] = {0};




159,948,145✔





172



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




159,930,558✔





173












174



  STableScanInfo* pTableScanInfo = pOperator->info;




159,940,728✔





175












176



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




159,914,667✔





177



                                                               buf, GET_RES_WINDOW_KEY_LEN(sizeof(groupId)));










178












179



  if (p1 == NULL) {




159,965,217✔





180



    return NULL;




49,593,738✔





181



  }










182












183



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




110,371,479✔





184



  if (NULL == *pPage) {




110,363,208✔





185



    return NULL;




×







186



  }










187












188



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




110,364,588✔





189



}










190












191



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




12,617,726✔





192



  if (NULL == pTableScanInfo->pIgnoreTables) {




12,617,726✔





193



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




1,891,118✔





194



    pTableScanInfo->pIgnoreTables =




1,891,118✔





195



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




1,891,118✔





196



    if (NULL == pTableScanInfo->pIgnoreTables) {




1,891,118✔





197



      return terrno;




×







198



    }










199



  }










200












201



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




12,617,726✔





202



                                sizeof(pTableScanInfo->scanTimes));










203



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




12,616,078✔





204



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




×







205



    return tempRes;




×







206



  }










207



  return TSDB_CODE_SUCCESS;




12,616,078✔





208



}










209












210



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




693,967,435✔





211



  STableScanInfo* pTableScanInfo = pOperator->info;




693,967,435✔





212



  int32_t         code = TSDB_CODE_SUCCESS;




694,305,461✔





213












214



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




694,305,461✔





215



    return TSDB_CODE_SUCCESS;




534,335,013✔





216



  }










217












218



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




159,914,747✔





219












220



  SFilePage*  pPage = NULL;




159,929,910✔





221



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




159,895,682✔





222












223



  if (pRow == NULL) {




159,934,170✔





224



    return TSDB_CODE_SUCCESS;




49,583,233✔





225



  }










226












227



  bool notLoadBlock = true;




110,350,937✔





228



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




2,147,483,647✔





229



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




2,147,483,647✔





230












231



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




2,147,483,647✔





232












233



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




2,147,483,647✔





234



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




2,147,483,647✔





235



      notLoadBlock = false;




97,752,693✔





236



      break;




97,752,693✔





237



    }










238



  }










239












240



  // release buffer pages










241



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




109,919,343✔





242












243



  if (notLoadBlock) {




110,367,941✔





244



    *status = FUNC_DATA_REQUIRED_NOT_LOAD;




12,617,726✔





245



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




12,617,726✔





246



  }










247












248



  return code;




110,355,937✔





249



}










250












251



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




9,538,331✔





252



                                  int32_t numOfRows, bool* keep) {










253



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




9,538,331✔





254



    *keep = true;




×







255



    return TSDB_CODE_SUCCESS;




×







256



  }










257












258



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




9,538,331✔





259



}










260












261



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




150,150,671✔





262



                              bool* pLoad) {










263



  SStorageAPI* pAPI = &pTaskInfo->storageAPI;




150,150,671✔





264



  bool         allColumnsHaveAgg = true;




150,196,458✔





265



  bool         hasNullSMA = false;




150,206,775✔





266



  if (pLoad != NULL) {




150,197,372✔





267



    *pLoad = false;




150,179,916✔





268



  }










269












270



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




150,175,348✔





271



                                                               &hasNullSMA);










272



  if (code != TSDB_CODE_SUCCESS) {




150,149,092✔





273



    return code;




×







274



  }










275












276



  if (!allColumnsHaveAgg || hasNullSMA) {




150,149,092✔





277



    *pLoad = false;




135,056,872✔





278



  } else {










279



    *pLoad = true;




15,092,220✔





280



  }










281












282



  return code;




150,141,198✔





283



}










284












285



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




728,552,974✔





286



                                  int32_t rows) {










287



  int32_t    code = 0;




728,552,974✔





288



  SExprSupp* pSup = &pTableScanInfo->pseudoSup;




728,552,974✔





289



  if (pSup->numOfExprs > 0) {




728,846,930✔





290



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




328,025,597✔





291



                                  pTaskInfo, &pTableScanInfo->metaCache);










292



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










293



    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




327,889,778✔





294



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




12,159✔





295



      code = 0;




×







296



    }










297



  }










298












299



  return code;




728,664,031✔





300



}










301












302



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




1,221,915,897✔





303



  SLimit*     pLimit = &pLimitInfo->limit;




1,221,915,897✔





304



  const char* id = GET_TASKID(pTaskInfo);




1,222,015,661✔





305












306



  if (pLimitInfo->remainOffset > 0) {




1,222,113,772✔





307



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




5,172,917✔





308



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




2,602,290✔





309



      blockDataEmpty(pBlock);




2,602,290✔





310



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




2,602,290✔





311



      return false;




2,602,290✔





312



    } else {










313



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




2,570,627✔





314



      if (code != TSDB_CODE_SUCCESS) {




2,570,627✔





315



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




×







316



        pTaskInfo->code = code;




×







317



        T_LONG_JMP(pTaskInfo->env, code);




×







318



      }










319



      pLimitInfo->remainOffset = 0;




2,570,627✔





320



    }










321



  }










322












323



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




1,219,509,820✔





324



    // limit the output rows










325



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




31,512,736✔





326



    blockDataKeepFirstNRows(pBlock, keep);




31,512,201✔





327












328



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




31,512,079✔





329



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




31,511,483✔





330



    return true;




31,512,873✔





331



  }










332












333



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




1,187,806,825✔





334



  return false;




1,187,976,183✔





335



}










336












337



static bool isDynVtbScan(SOperatorInfo* pOperator) {




×







338



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




×







339



}










340












341



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




726,051,815✔





342



                             uint32_t* status) {










343



  int32_t        code = TSDB_CODE_SUCCESS;




726,051,815✔





344



  int32_t        lino = 0;




726,051,815✔





345



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




726,051,815✔





346



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




726,250,730✔





347



  bool           loadSMA = false;




726,164,430✔





348












349



  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;




726,164,430✔





350












351



  pCost->totalBlocks += 1;




726,258,147✔





352



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




726,198,345✔





353



  *status = pTableScanInfo->dataBlockLoadFlag;




726,243,426✔





354












355



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




726,148,980✔





356



    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




98,269,526✔





357



  } else {










358



    bool overlap = false;




627,870,604✔





359



    int  ret =










360



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




627,933,533✔





361



    if (ret != TSDB_CODE_SUCCESS) {




627,475,283✔





362



      return ret;




×







363



    }










364



    if (overlap) {




627,475,283✔





365



      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




33,671,245✔





366



    }










367



  }










368












369



  SDataBlockInfo* pBlockInfo = &pBlock->info;




725,985,236✔





370



  taosMemoryFreeClear(pBlock->pBlockAgg);




726,083,918✔





371












372



  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {




726,157,293✔





373



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




×







374



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










375



    pCost->filterOutBlocks += 1;




×







376



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




×







377



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




×







378



    return TSDB_CODE_SUCCESS;




×







379



  } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




725,774,389✔





380



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




22,961,545✔





381



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










382



           pBlockInfo->id.uid);










383



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




22,965,493✔





384



    pCost->skipBlocks += 1;




22,967,437✔





385



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




22,966,921✔





386



    return code;




22,964,341✔





387



  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {




702,787,283✔





388



    pCost->loadBlockStatis += 1;




51,924,102✔





389



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




51,910,045✔





390



    bool success = true;




51,910,045✔





391



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




51,922,347✔





392



    if (code) {




51,908,363✔





393



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




×







394



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




×







395



      QUERY_CHECK_CODE(code, lino, _end);




5,389✔





396



    }










397












398



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




51,913,752✔





399



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




5,554,405✔





400



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










401



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




5,554,405✔





402



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




5,554,405✔





403



      return code;




5,624,805✔





404



    } else {










405



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




46,359,347✔





406



      *status = FUNC_DATA_REQUIRED_DATA_LOAD;




46,370,475✔





407



    }










408



  }










409












410



  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {




697,248,940✔





411



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




×







412



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




×







413



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







414



  }










415












416



  // try to filter data block according to sma info










417



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




697,230,370✔





418



    bool success = true;




98,269,029✔





419



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




98,271,727✔





420



    if (code) {




98,221,927✔





421



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




×







422



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




×







423



      QUERY_CHECK_CODE(code, lino, _end);




5,394✔





424



    }










425












426



    if (success) {




98,225,832✔





427



      size_t size = taosArrayGetSize(pBlock->pDataBlock);




9,537,815✔





428



      bool   keep = false;




9,538,331✔





429



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




9,538,331✔





430



      if (code) {




9,538,331✔





431



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




×







432



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




×







433



        QUERY_CHECK_CODE(code, lino, _end);




×







434



      }










435












436



      if (!keep) {




9,537,815✔





437



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




3,327,224✔





438



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










439



        pCost->filterOutBlocks += 1;




3,327,224✔





440



        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;




3,327,224✔





441



        taosMemoryFreeClear(pBlock->pBlockAgg);




3,327,224✔





442












443



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




3,327,224✔





444



        return TSDB_CODE_SUCCESS;




3,327,224✔





445



      }










446



    }










447



  }










448












449



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










450



  taosMemoryFreeClear(pBlock->pBlockAgg);




694,121,014✔





451












452



  // try to filter data block according to current results










453



  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);




693,958,480✔





454



  if (code) {




694,045,164✔





455



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




57,664✔





456



    QUERY_CHECK_CODE(code, lino, _end);




×







457



  }










458












459



  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




693,987,500✔





460



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




12,617,726✔





461



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










462



    pCost->skipBlocks += 1;




12,618,550✔





463



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




12,617,726✔





464












465



    STableScanInfo* p1 = pOperator->info;




12,617,726✔





466



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




12,617,726✔





467



      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;




3,560,423✔





468



    } else {










469



      *status = FUNC_DATA_REQUIRED_FILTEROUT;




9,057,303✔





470



    }










471



    return TSDB_CODE_SUCCESS;




12,617,726✔





472



  }










473












474



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




681,251,577✔





475



  pCost->loadBlocks += 1;




681,568,822✔





476












477



  SSDataBlock* p = NULL;




681,437,560✔





478



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




681,425,134✔





479



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




681,550,531✔





480



    return code;




×







481



  }










482












483



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




681,612,812✔





484



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




542,337,563✔





485



    // do nothing










486



  } else {










487



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










488



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




654,274,393✔





489



    if (code) {




654,342,090✔





490



      return code;




×







491



    }










492



  }










493












494



  // restore the previous value










495



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




681,454,860✔





496












497



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




681,553,111✔





498



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




94,920,617✔





499



    QUERY_CHECK_CODE(code, lino, _end);




94,892,465✔





500












501



    int64_t st = taosGetTimestampUs();




94,076,358✔





502



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




94,075,800✔





503



    pTableScanInfo->readRecorder.filterTime += el;




94,075,800✔





504












505



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




94,069,428✔





506



      pCost->filterOutBlocks += 1;




18,596,960✔





507



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




18,595,408✔





508



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










509



    } else {










510



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




75,450,219✔





511



    }










512



  }










513












514



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




680,697,710✔





515



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




680,839,953✔





516



    setOperatorCompleted(pOperator);




3,244,285✔





517



  }










518












519



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




680,897,984✔





520












521



_end:




681,764,452✔





522



  if (code != TSDB_CODE_SUCCESS) {




681,739,423✔





523



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




851,361✔





524



  }










525



  return code;




681,479,142✔





526



}










527












528



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




66,207✔





529



  SET_REVERSE_SCAN_FLAG(pTableScanInfo);




66,207✔





530












531



  switchCtxOrder(pCtx, numOfOutput);




66,207✔





532



  pTableScanInfo->cond.order = TSDB_ORDER_DESC;




66,207✔





533



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










534



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










535



}




66,207✔





536












537



typedef struct STableCachedVal {










538



  const char* pName;










539



  STag*       pTags;










540



} STableCachedVal;










541












542



static void freeTableCachedVal(void* param) {




×







543



  if (param == NULL) {




×







544



    return;




×







545



  }










546












547



  STableCachedVal* pVal = param;




×







548



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




×







549



  taosMemoryFree(pVal->pTags);




×







550



  taosMemoryFree(pVal);




×







551



}










552












553



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




×







554



  int32_t          code = TSDB_CODE_SUCCESS;




×







555



  int32_t          lino = 0;




×







556



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




×







557



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




×







558












559



  pVal->pTags = NULL;




×







560



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




×







561



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




×







562












563



  // only child table has tag value










564



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




×







565



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




×







566



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




×







567



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




×







568



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




×







569



  }










570












571



  (*ppResVal) = pVal;




×







572












573



_end:




×







574



  if (code != TSDB_CODE_SUCCESS) {




×







575



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




×







576



    freeTableCachedVal(pVal);




×







577



  }










578



  return code;




×







579



}










580












581



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










582



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




×







583



  (void)key;










584



  (void)keyLen;










585



  (void)ud;










586



  freeTableCachedVal(value);




×







587



}




×







588












589



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




×







590



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




×







591



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




×







592












593



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




×







594



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




×







595



  }










596



}




×







597












598



static void freeTableCachedValObj(STableCachedVal* pVal) {




×







599



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




×







600



  taosMemoryFree(pVal->pTags);




×







601



}




×







602












603



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




391,688,018✔





604



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










605



  int32_t          code = TSDB_CODE_SUCCESS;




391,688,018✔





606



  int32_t          lino = 0;




391,688,018✔





607



  bool             freeReader = false;




391,688,018✔





608



  LRUHandle*       h = NULL;




391,688,018✔





609



  STableCachedVal  val = {0};




391,688,018✔





610



  SMetaReader      mr = {0};




391,688,018✔





611



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




391,725,084✔





612



  int32_t          insertRet = TAOS_LRU_STATUS_OK;




391,778,842✔





613



  STableCachedVal* pVal = NULL;




391,778,842✔





614












615



  // currently only the tbname pseudo column










616



  if (numOfExpr <= 0) {




391,771,761✔





617



    return TSDB_CODE_SUCCESS;




316,908✔





618



  }










619












620



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










621












622



  // backup the rows










623



  int32_t backupRows = pBlock->info.rows;




391,454,853✔





624



  pBlock->info.rows = rows;




391,570,152✔





625












626



  // todo refactor: extract method










627



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










628












629



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










630



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




391,521,559✔





631



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




391,533,831✔





632



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




391,609,308✔





633



    if (code != TSDB_CODE_SUCCESS) {




391,270,716✔





634



      // when encounter the TSDB_CODE_PAR_TABLE_NOT_EXIST error, we proceed.










635



      if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







636



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




×







637



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










638












639



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










640



        doSetNullValue(pBlock, pExpr, numOfExpr);




×







641



      } else {










642



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




×







643



      }










644



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




×







645



      return code;




×







646



    }










647












648



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




391,270,716✔





649












650



    val.pName = mr.me.name;




391,526,263✔





651



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




391,526,263✔





652












653



    freeReader = true;




391,526,263✔





654



  } else {










655



    pCache->metaFetch += 1;




×







656












657



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




×







658



    if (h == NULL) {




×







659



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




×







660



      freeReader = true;




×







661



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




×







662



      if (code != TSDB_CODE_SUCCESS) {




×







663



        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







664



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




×







665



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










666



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










667



          doSetNullValue(pBlock, pExpr, numOfExpr);




×







668



        } else {










669



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




×







670



                 idStr);










671



        }










672



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




×







673



        return code;




×







674



      }










675












676



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




×







677












678



      code = createTableCacheVal(&mr, &pVal);




×







679



      QUERY_CHECK_CODE(code, lino, _end);




×







680












681



      val = *pVal;




×







682



    } else {










683



      pCache->cacheHit += 1;




×







684



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




×







685



      val = *pValTmp;




×







686












687



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




×







688



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




×







689



    }










690












691



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




×







692



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










693



  }










694












695



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




1,541,682,798✔





696



    const SExprInfo* pExpr1 = &pExpr[j];




1,150,173,834✔





697



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




1,150,072,987✔





698












699



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




1,150,476,134✔





700



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




1,150,436,877✔





701












702



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




1,150,338,859✔





703












704



    // this is to handle the tbname










705



    if (fmIsScanPseudoColumnFunc(functionId)) {




1,150,526,701✔





706



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




130,949,322✔





707



      if (fType == FUNCTION_TYPE_TBNAME) {




130,960,446✔





708



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




130,960,446✔





709



        QUERY_CHECK_CODE(code, lino, _end);




130,928,040✔





710



      } else if (fType == FUNCTION_TYPE_VGID) {




×







711



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




×







712



        QUERY_CHECK_CODE(code, lino, _end);




×







713



      } else if (fType == FUNCTION_TYPE_VGVER) {




×







714



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




×







715



        QUERY_CHECK_CODE(code, lino, _end);




×







716



      }










717



    } else {  // these are tags










718



      STagVal tagVal = {0};




1,019,153,681✔





719



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




1,019,202,220✔





720



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




1,019,503,697✔





721












722



      char* data = NULL;




1,019,563,589✔





723



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




1,019,563,589✔





724



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




1,013,902,002✔





725



      } else {










726



        data = (char*)p;




5,632,530✔





727



      }










728












729



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




1,019,343,097✔





730



      if (isNullVal) {




1,019,526,120✔





731



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




5,154,486✔





732



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




1,014,371,634✔





733



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




1,013,604,349✔





734



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




1,013,850,813✔





735



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




375,538,209✔





736



          if (tmp != NULL) {




375,590,145✔





737



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




375,590,145✔





738



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




375,591,718✔





739



                   pBlock->info.id.uid);










740



            taosMemoryFree(tmp);




375,631,709✔





741



          }










742



          taosMemoryFree(data);




375,635,180✔





743



        }










744



        QUERY_CHECK_CODE(code, lino, _end);




1,013,703,219✔





745



      } else {  // todo opt for json tag










746



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




2,969,112✔





747



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




2,489,446✔





748



          QUERY_CHECK_CODE(code, lino, _end);




2,491,068✔





749



        }










750



      }










751



    }










752



  }










753












754



  // restore the rows










755



  pBlock->info.rows = backupRows;




391,508,964✔





756












757



_end:




391,578,644✔





758












759



  if (NULL != pVal) {




391,423,542✔





760



    insertRet =




×







761



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




×







762



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










763



    if (insertRet != TAOS_LRU_STATUS_OK) {




×







764



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




×







765



    }










766



  }










767












768



  if (freeReader) {




391,423,542✔





769



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




391,420,377✔





770



  }










771



  if (code != TSDB_CODE_SUCCESS) {




391,541,654✔





772



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




×







773



  }










774



  return code;




391,406,898✔





775



}










776












777



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




130,921,099✔





778



                         const char* name) {










779



  int32_t                     code = TSDB_CODE_SUCCESS;




130,921,099✔





780



  int32_t                     lino = 0;




130,921,099✔





781



  struct SScalarFuncExecFuncs fpSet = {0};




130,921,099✔





782



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




130,939,136✔





783



  QUERY_CHECK_CODE(code, lino, _end);




130,950,317✔





784












785



  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;




130,950,317✔





786



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




130,950,317✔





787



  STR_TO_VARSTR(buf, name)




130,925,996✔





788












789



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




130,959,470✔





790












791



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




130,926,683✔





792



  QUERY_CHECK_CODE(code, lino, _end);




130,927,118✔





793












794



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




130,927,118✔





795



  QUERY_CHECK_CODE(code, lino, _end);




130,942,185✔





796












797



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




130,942,185✔





798



  SScalarParam param = {.columnData = pColInfoData};




130,947,533✔





799












800



  if (fpSet.process != NULL) {




130,926,769✔





801



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




130,926,769✔





802



    QUERY_CHECK_CODE(code, lino, _end);




130,940,398✔





803



  } else {










804



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




×







805



  }










806












807



  colDataDestroy(&infoData);




130,940,398✔





808












809



_end:




130,930,775✔





810



  if (code != TSDB_CODE_SUCCESS) {




130,941,723✔





811



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




×







812



  }










813



  return code;




130,941,723✔





814



}










815












816



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




×







817



  int32_t                     code = TSDB_CODE_SUCCESS;




×







818



  int32_t                     lino = 0;




×







819



  struct SScalarFuncExecFuncs fpSet = {0};




×







820



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







821



  QUERY_CHECK_CODE(code, lino, _end);




×







822












823



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




×







824












825



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




×







826



  QUERY_CHECK_CODE(code, lino, _end);




×







827












828



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




×







829



  QUERY_CHECK_CODE(code, lino, _end);




×







830












831



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




×







832



  SScalarParam param = {.columnData = pColInfoData};




×







833












834



  if (fpSet.process != NULL) {




×







835



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




×







836



    QUERY_CHECK_CODE(code, lino, _end);




×







837



  } else {










838



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




×







839



  }










840












841



_end:




×







842



  colDataDestroy(&infoData);




×







843



  if (code != TSDB_CODE_SUCCESS) {




×







844



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




×







845



  }










846



  return code;




×







847



}










848












849



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




×







850



  int32_t                     code = TSDB_CODE_SUCCESS;




×







851



  int32_t                     lino = 0;




×







852



  struct SScalarFuncExecFuncs fpSet = {0};




×







853



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







854



  QUERY_CHECK_CODE(code, lino, _end);




×







855












856



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




×







857












858



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




×







859



  QUERY_CHECK_CODE(code, lino, _end);




×







860












861



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




×







862



  QUERY_CHECK_CODE(code, lino, _end);




×







863












864



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




×







865



  SScalarParam param = {.columnData = pColInfoData};




×







866












867



  if (fpSet.process != NULL) {




×







868



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




×







869



    QUERY_CHECK_CODE(code, lino, _end);




×







870



  } else {










871



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




×







872



  }










873












874



_end:




×







875



  colDataDestroy(&infoData);




×







876



  if (code != TSDB_CODE_SUCCESS) {




×







877



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




×







878



  }










879



  return code;




×







880



}










881












882



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




199,970,143✔





883



  int32_t code = TSDB_CODE_SUCCESS;




199,970,143✔





884



  int32_t lino = 0;




199,970,143✔





885



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




199,970,143✔





886



  QUERY_CHECK_CODE(code, lino, _end);




200,031,859✔





887












888



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




200,031,859✔





889



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




199,978,109✔





890



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




199,974,412✔





891



  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);




199,959,774✔





892












893



  if (!pInfo->needCountEmptyTable) {




200,076,598✔





894



    pInfo->countState = TABLE_COUNT_STATE_END;




179,753,348✔





895



  } else {










896



    pInfo->countState = TABLE_COUNT_STATE_SCAN;




20,240,660✔





897



  }










898












899



_end:




199,853,380✔





900



  if (code != TSDB_CODE_SUCCESS) {




199,853,380✔





901



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




×







902



  }










903



  return code;




199,979,760✔





904



}










905












906



void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {




600,037,951✔





907



  if (pInfo->countState == TABLE_COUNT_STATE_END) {




600,037,951✔





908



    return;




486,968,669✔





909



  }










910



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




113,142,668✔





911



    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;




220,604✔





912



  } else {










913



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




112,928,303✔





914



    if (code != TSDB_CODE_SUCCESS) {




112,953,543✔





915



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




49,765,778✔





916



    }










917



  }










918



}










919












920



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




45,799,223✔





921



                                         const STableKeyInfo* tbInfo) {










922



  blockDataEmpty(pBlock);




45,799,223✔





923



  pBlock->info.rows = 1;




45,799,774✔





924



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




45,800,772✔





925



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




45,800,273✔





926



  pBlock->info.blankFill = true;




45,794,285✔





927












928



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










929



  int32_t col_num = blockDataGetNumOfCols(pBlock);




45,797,778✔





930



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




189,368,664✔





931



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




143,568,443✔





932



    colDataSetNULL(pColInfoData, 0);










933



  }










934












935



  // set tag/tbname










936



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




45,800,221✔





937












938



  return pBlock;




45,795,231✔





939



}










940












941



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




44,004,152✔





942



  STableScanInfo* pTableScanInfo = pOperator->info;




44,004,152✔





943



  SSDataBlock*    pBlock =










944



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




44,006,148✔





945












946



  pOperator->resultInfo.totalRows++;




43,989,681✔





947



  return pBlock;




44,002,655✔





948



}










949












950



/**










951



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










952



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










953



*/










954



static int32_t prepareTableScan(SOperatorInfo* pOperator) {




780,143,444✔





955



  int32_t code = TSDB_CODE_SUCCESS;




780,143,444✔





956



  int32_t lino = 0;




780,143,444✔





957












958



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




780,143,444✔





959



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




780,260,287✔





960



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




780,469,161✔





961



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




29,582,668✔





962



         NOTIFY_TYPE_SCAN_PARAM &&




1,362,315✔





963



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




1,362,315✔





964



    STableScanOperatorParam* pNotify =




1,362,315✔





965



      (STableScanOperatorParam*)pGetParam->value;










966












967



    STableScanInfo* pTableScanInfo = pOperator->info;




1,362,315✔





968



    SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




1,362,315✔





969



    SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




1,362,315✔





970



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




1,362,315✔





971



                                             pNotify->notifyTs);










972



    QUERY_CHECK_CODE(code, lino, _end);




1,362,315✔





973












974



    if (!pGetParam->reUse) {




1,362,315✔





975



      freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




×







976



    } else {










977



      /**










978



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










979



        the parent operator after getting next block.










980



      */










981



      pGetParam->reUse = false;




1,362,315✔





982



    }










983



    /**










984



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










985



    */










986



    pOperator->pOperatorGetParam = NULL;




1,362,315✔





987



  }










988












989



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




780,463,639✔





990



_end:




129,783,656✔





991



  if (code != TSDB_CODE_SUCCESS) {




780,451,870✔





992



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




×







993



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










994



  }










995



  return code;




780,426,825✔





996



}










997












998



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




741,527,903✔





999



  int32_t         code = TSDB_CODE_SUCCESS;




741,527,903✔





1000



  int32_t         lino = 0;




741,527,903✔





1001



  STableScanInfo* pTableScanInfo = pOperator->info;




741,527,903✔





1002



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




741,560,578✔





1003



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




741,549,660✔





1004



  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;




741,621,699✔





1005



  bool            hasNext = false;




741,500,630✔





1006



  int64_t         st = taosGetTimestampUs();




741,527,799✔





1007












1008



  QRY_PARAM_CHECK(ppRes);




741,527,799✔





1009



  pBlock->info.dataLoad = false;




741,572,590✔





1010












1011



  while (true) {




24,674,169✔





1012



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




765,923,334✔





1013



    if (code != TSDB_CODE_SUCCESS) {




765,981,046✔





1014



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




×







1015



      QUERY_CHECK_CODE(code, lino, _end);




696,621✔





1016



    }










1017












1018



    if (!hasNext) {




765,977,904✔





1019



      break;




180,961,181✔





1020



    }










1021












1022



    if (isTaskKilled(pTaskInfo)) {




585,016,723✔





1023



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




52,343✔





1024



      code = pTaskInfo->code;




22,366✔





1025



      QUERY_CHECK_CODE(code, lino, _end);




22,366✔





1026



    }










1027












1028



    if (pOperator->status == OP_EXEC_DONE) {




585,355,586✔





1029



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




59,696✔





1030



      break;




59,696✔





1031



    }










1032












1033



    // process this data block based on the probabilities










1034



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




585,212,049✔





1035



    if (!processThisBlock) {




585,157,425✔





1036



      continue;




1,402,391✔





1037



    }










1038












1039



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




585,157,425✔





1040



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




585,291,356✔





1041



    }










1042












1043



    uint32_t status = 0;




585,307,375✔





1044



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




585,342,429✔





1045



    QUERY_CHECK_CODE(code, lino, _end);




585,101,737✔





1046












1047



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




584,295,847✔





1048



      break;




3,560,423✔





1049



    }










1050












1051



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










1052



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




580,735,424✔





1053



      continue;




24,674,169✔





1054



    }










1055












1056



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




556,137,411✔





1057



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




556,214,747✔





1058












1059



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




556,193,924✔





1060



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




556,259,462✔





1061












1062



    (*ppRes) = pBlock;




556,252,118✔





1063



    return code;




556,125,351✔





1064



  }










1065












1066



_end:




185,425,320✔





1067



  if (code != TSDB_CODE_SUCCESS) {




185,437,743✔





1068



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




844,741✔





1069



    pTaskInfo->code = code;




844,741✔





1070



    T_LONG_JMP(pTaskInfo->env, code);




828,256✔





1071



  }










1072



  return code;




184,593,002✔





1073



}










1074












1075



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




788,931,089✔





1076



  int32_t         code = TSDB_CODE_SUCCESS;




788,931,089✔





1077



  int32_t         lino = 0;




788,931,089✔





1078



  STableScanInfo* pTableScanInfo = pOperator->info;




788,931,089✔





1079



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




788,974,363✔





1080



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




788,892,720✔





1081












1082



  QRY_PARAM_CHECK(pBlock);




788,959,632✔





1083












1084



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










1085



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




788,909,247✔





1086



    return code;




3,412,718✔





1087



  }










1088












1089



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










1090



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




953,925,638✔





1091



    SSDataBlock* p = NULL;




653,887,129✔





1092



    code = doTableScanImplNext(pOperator, &p);




653,796,125✔





1093



    QUERY_CHECK_CODE(code, lino, _end);




652,927,721✔





1094












1095



    if (p != NULL) {




652,927,721✔





1096



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




484,515,712✔





1097



      *pBlock = p;




484,419,339✔





1098



      return code;




484,245,939✔





1099



    }










1100












1101



    pTableScanInfo->scanTimes += 1;




168,412,009✔





1102



    taosHashClear(pTableScanInfo->pIgnoreTables);




168,427,897✔





1103












1104



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




168,443,344✔





1105



      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




90,483✔





1106



      pTableScanInfo->base.scanFlag = MAIN_SCAN;




83,859✔





1107



      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




83,859✔





1108



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




83,859✔





1109












1110



      // do prepare for the next round table scan operation










1111



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




83,859✔





1112



      QUERY_CHECK_CODE(code, lino, _end);




79,909✔





1113



    }










1114



  }










1115












1116



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




299,992,037✔





1117



  if (pTableScanInfo->scanTimes < total) {




299,992,107✔





1118



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




87,617,560✔





1119



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




66,207✔





1120



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




66,207✔





1121



      QUERY_CHECK_CODE(code, lino, _end);




66,207✔





1122



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




66,207✔





1123



    }










1124












1125



    while (pTableScanInfo->scanTimes < total) {




103,752,894✔





1126



      SSDataBlock* p = NULL;




87,626,085✔





1127



      code = doTableScanImplNext(pOperator, &p);




87,608,159✔





1128



      QUERY_CHECK_CODE(code, lino, _end);




87,615,003✔





1129












1130



      if (p != NULL) {




87,615,003✔





1131



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




71,479,398✔





1132



        *pBlock = p;




71,489,634✔





1133



        return code;




71,490,581✔





1134



      }










1135












1136



      pTableScanInfo->scanTimes += 1;




16,135,605✔





1137



      taosHashClear(pTableScanInfo->pIgnoreTables);




16,136,569✔





1138












1139



      if (pTableScanInfo->scanTimes < total) {




16,132,637✔





1140



        setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




×







1141



        pTableScanInfo->base.scanFlag = MAIN_SCAN;




×







1142












1143



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




×







1144



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




×







1145



        QUERY_CHECK_CODE(code, lino, _end);




2,567✔





1146



      }










1147



    }










1148



  }










1149












1150



  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {




228,506,812✔





1151



    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;




63,570,808✔





1152



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




63,568,260✔





1153



      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {




117,324✔





1154



        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;




3,872✔





1155



        STableKeyInfo* pStart =










1156



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




3,872✔





1157












1158



        if (NULL == pStart) {




3,872✔





1159



          return code;




×







1160



        }










1161












1162



        *pBlock = getBlockForEmptyTable(pOperator, pStart);




3,872✔





1163



        return code;




3,872✔





1164



      }










1165



    } else {  // group by tag + no sort










1166



      int32_t numOfTables = 0;




63,444,543✔





1167



      code = tableListGetSize(pTableListInfo, &numOfTables);




63,449,150✔





1168



      QUERY_CHECK_CODE(code, lino, _end);




63,451,381✔





1169












1170



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




63,451,381✔





1171



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










1172



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




61,011,894✔





1173



        if (pIte != NULL) {




61,010,382✔





1174



          size_t        keySize = 0;




44,001,777✔





1175



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




44,001,777✔





1176



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




43,995,789✔





1177



          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);




43,997,286✔





1178



          markGroupProcessed(pTableScanInfo, *pGroupId);




43,999,282✔





1179



          *pBlock = getBlockForEmptyTable(pOperator, &info);




43,999,781✔





1180












1181



          return code;




43,994,292✔





1182



        }










1183



      }










1184



    }










1185



    pTableScanInfo->countState = TABLE_COUNT_STATE_END;




19,562,611✔





1186



  }










1187












1188



_end:




164,944,834✔





1189



  if (code != TSDB_CODE_SUCCESS) {




184,486,636✔





1190



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




×







1191



    pTaskInfo->code = code;




×







1192



  }










1193












1194



  return code;




184,486,636✔





1195



}










1196












1197



static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {




933,666✔





1198



  STableScanInfo*          pInfo = pOperator->info;




933,666✔





1199



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




933,666✔





1200



  int32_t                  code = 0;




933,666✔





1201



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




933,666✔





1202



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




933,666✔





1203



  int32_t                  num = taosArrayGetSize(pParam->pUidList);




933,666✔





1204



  if (num <= 0) {




933,666✔





1205



    qError("empty table scan uid list");




×







1206



    return TSDB_CODE_INVALID_PARA;




×







1207



  }










1208












1209



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




933,666✔





1210



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










1211



         pOperator->status);










1212












1213



  if (pParam->tableSeq) {




933,666✔





1214



    pListInfo->oneTableForEachGroup = true;




694,068✔





1215



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




694,068✔





1216



      taosHashClear(pListInfo->map);




×







1217



      taosArrayClear(pListInfo->pTableList);




×







1218



      pOperator->status = OP_EXEC_DONE;




×







1219



    }










1220



  } else {










1221



    pListInfo->oneTableForEachGroup = false;




239,598✔





1222



    pListInfo->numOfOuputGroups = 1;




239,598✔





1223



  }










1224



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




933,666✔





1225



    // do nothing










1226



  } else {










1227



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




689,628✔





1228



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




689,628✔





1229



  }










1230












1231



  STableKeyInfo info = {.groupId = 0};




933,666✔





1232



  int32_t       tableIdx = 0;




933,666✔





1233



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




8,823,100✔





1234



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




7,889,434✔





1235



    if (!pUid) {




7,890,937✔





1236



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




×







1237



      return terrno;




×







1238



    }










1239












1240



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




7,890,937✔





1241



      if (TSDB_CODE_DUP_KEY == terrno) {




6,618,519✔





1242



        continue;




6,618,519✔





1243



      }










1244



      return terrno;




×







1245



    }










1246












1247



    info.uid = *pUid;




1,275,424✔





1248



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




1,275,424✔





1249



    if (p == NULL) {




1,275,424✔





1250



      return terrno;




×







1251



    }










1252












1253



    tableIdx++;




1,275,424✔





1254



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




1,275,424✔





1255



  }










1256












1257



  return code;




933,666✔





1258



}










1259












1260



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




186,126,038✔





1261



                            STableKeyInfo** pList) {










1262



  const char* idStr = GET_TASKID(pTaskInfo);




186,126,038✔





1263



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




186,162,524✔





1264



  if (code) {




185,847,841✔





1265



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




33,516✔





1266



    return code;




×







1267



  }










1268












1269



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




185,814,325✔





1270



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




×







1271



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







1272



  }










1273












1274



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




346,190,889✔





1275



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




185,986,458✔





1276



  if (code) {




186,068,093✔





1277



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




2,215✔





1278



  }










1279












1280



  return code;




186,111,428✔





1281



}










1282












1283



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




294,915,350✔





1284



  SColIdPair* node1 = (SColIdPair*)elem1;




294,915,350✔





1285



  SColIdPair* node2 = (SColIdPair*)elem2;




294,915,350✔





1286












1287



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




294,915,350✔





1288



    return 0;




107,598✔





1289



  }










1290












1291



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




294,897,186✔





1292



}










1293












1294



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




294,888,124✔





1295



  SColIdSlotIdPair* node1 = (SColIdSlotIdPair*)elem1;




294,888,124✔





1296



  SColIdSlotIdPair* node2 = (SColIdSlotIdPair*)elem2;




294,888,124✔





1297












1298



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




294,888,124✔





1299



    return 0;




107,598✔





1300



  }










1301












1302



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




294,874,343✔





1303



}










1304












1305



static bool isNewScanParam(STableScanOperatorParam* pParam) {




39,648,455✔





1306



  return pParam->isNewParam;




39,648,455✔





1307



}










1308












1309



static int32_t createVTableScanInfoFromBatchParam(SOperatorInfo* pOperator) {




17,464,669✔





1310



  int32_t                  code = 0;




17,464,669✔





1311



  int32_t                  lino = 0;




17,464,669✔





1312



  STableScanInfo*          pInfo = pOperator->info;




17,464,669✔





1313



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




17,449,746✔





1314



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




17,458,871✔





1315



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




17,458,884✔





1316



  SMetaReader              orgTable = {0};




17,465,859✔





1317



  SMetaReader              superTable = {0};




17,480,257✔





1318



  SSchemaWrapper*          schema = NULL;




17,467,866✔





1319



  SArray*                  pColArray = NULL;




17,467,866✔





1320



  SArray*                  pBlockColArray = NULL;




17,467,866✔





1321



  int32_t                  num = 0;




17,467,866✔





1322



  STableKeyInfo*           pList = NULL;




17,464,909✔





1323



  SOrgTbInfo*              pOrgTbInfo;










1324



  bool                     isNewTable;










1325












1326



  cleanupQueryTableDataCond(&pInfo->base.cond);




17,469,938✔





1327












1328



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




17,471,370✔





1329



  if (pGetParam &&




17,471,208✔





1330



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




4,096,928✔





1331



    STableScanOperatorParam* pParam =




4,100,073✔





1332



      (STableScanOperatorParam*)pGetParam->value;










1333



    pInfo->pBatchColMap = pParam->pBatchTbInfo;




4,098,656✔





1334



    pParam->pBatchTbInfo = NULL;




4,106,638✔





1335



    pInfo->cachedTimeWindow = pParam->window;




4,084,980✔





1336



    pInfo->currentBatchIdx = 0;




4,091,387✔





1337



    pInfo->lastBatchIdx = -1;




4,095,738✔





1338



    pInfo->cachedTagList = pParam->pTagList;




4,092,331✔





1339



    pParam->pTagList = NULL;




4,094,545✔





1340



    pInfo->cachedGroupId = pParam->groupid;




4,104,052✔





1341












1342



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




4,094,055✔





1343



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










1344



    taosHashClear(pInfo->pIgnoreTables);




4,094,055✔





1345












1346



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




4,097,576✔





1347



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




3,904,844✔





1348



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




49,231,880✔





1349



        SqlFunctionCtx ctx = pSup->pCtx[i];




45,343,594✔





1350



        ctx.skipDynDataCheck = false;




45,327,548✔





1351



      }










1352



    }










1353



  }










1354












1355



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




17,456,683✔





1356



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




17,484,543✔





1357












1358



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




17,484,543✔





1359



    isNewTable = false;




10,640,754✔





1360



  } else {










1361



    isNewTable = true;




6,841,780✔





1362



    pInfo->lastBatchIdx = pInfo->currentBatchIdx;




6,841,780✔





1363



  }










1364












1365



  if (isNewTable) {




17,479,702✔





1366



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




6,838,948✔





1367



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




6,841,175✔





1368



    pAPI->metaReaderFn.readerReleaseLock(&orgTable);




6,823,150✔





1369



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




6,827,479✔





1370



    QUERY_CHECK_CODE(code, lino, _return);




6,819,588✔





1371



    switch (orgTable.me.type) {




6,819,588✔





1372



      case TSDB_CHILD_TABLE:




277,822✔





1373



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




277,822✔





1374



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




277,822✔





1375



        pAPI->metaReaderFn.readerReleaseLock(&superTable);




277,822✔





1376



        QUERY_CHECK_CODE(code, lino, _return);




277,822✔





1377



        schema = &superTable.me.stbEntry.schemaRow;




277,822✔





1378



        break;




277,822✔





1379



      case TSDB_NORMAL_TABLE:




6,551,180✔





1380



        schema = &orgTable.me.ntbEntry.schemaRow;




6,551,180✔





1381



        break;




6,551,180✔





1382



      default:




×







1383



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




×







1384



        return TSDB_CODE_INVALID_PARA;




×







1385



        break;










1386



    }










1387












1388



    pListInfo->oneTableForEachGroup = true;




6,829,002✔





1389



    taosHashClear(pListInfo->map);




6,829,164✔





1390



    taosArrayClear(pListInfo->pTableList);




6,846,666✔





1391












1392



    uint64_t      pUid = orgTable.me.uid;




6,845,493✔





1393



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




6,845,830✔





1394



    int32_t       tableIdx = 0;




6,845,262✔





1395



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




6,846,167✔





1396



    QUERY_CHECK_CODE(code, lino, _return);




6,843,659✔





1397



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




13,685,914✔





1398



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




6,842,255✔





1399












1400



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




6,842,255✔





1401



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




6,843,646✔





1402



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




6,843,646✔





1403



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




6,839,831✔





1404












1405



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










1406



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




6,839,831✔





1407



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




6,840,501✔





1408












1409



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




26,155,679✔





1410



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




19,315,260✔





1411



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




153,662,972✔





1412



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




153,540,221✔





1413



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




19,321,514✔





1414



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




19,318,924✔





1415



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




19,318,924✔





1416



                 pPair.vtbColId, GET_TASKID(pTaskInfo));










1417



          break;




19,310,929✔





1418



        }










1419



      }










1420



    }










1421












1422



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




33,005,177✔





1423



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




26,157,593✔





1424



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




156,979,721✔





1425



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




156,775,497✔





1426



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




156,791,325✔





1427



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




26,155,327✔





1428



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




26,167,437✔





1429



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




26,167,437✔





1430



                 colIdSlotIdPair.vtbSlotId, GET_TASKID(pTaskInfo));










1431



          break;




26,158,820✔





1432



        }










1433



      }










1434



    }










1435












1436



    taosArraySort(pColArray, compareColIdPair);




6,842,717✔





1437



    taosArraySort(pBlockColArray, compareColIdSlotIdPair);




6,842,242✔





1438



    if (pInfo->pBlockColMap) {




6,843,646✔





1439



      taosArrayDestroy(pInfo->pBlockColMap);




4,855,332✔





1440



      pInfo->pBlockColMap = NULL;




4,845,462✔





1441



    }










1442



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




6,832,927✔





1443



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




6,842,242✔





1444












1445












1446



    taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




6,829,769✔





1447



    taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




6,834,424✔





1448












1449



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




6,839,909✔





1450



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




6,133,548✔





1451



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




76,065,147✔





1452



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




69,947,639✔





1453



        bool           needScan = false;




69,951,767✔





1454



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




140,866,927✔





1455



          SFunctParam pParam = ctx->param[j];




70,900,779✔





1456



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




340,209,526✔





1457



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




285,840,851✔





1458



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




286,628,125✔





1459



              needScan |= true;




17,649,486✔





1460



              break;




17,649,486✔





1461



            }










1462



          }










1463



        }










1464



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




69,964,845✔





1465



        if (!needScan) {




69,996,017✔





1466



          ctx->skipDynDataCheck = true;




52,351,074✔





1467



        } else {










1468



          ctx->skipDynDataCheck = false;




17,644,943✔





1469



        }










1470



      }










1471



    }










1472












1473












1474



  } else {










1475



    pColArray = pInfo->lastColArray;




10,640,754✔





1476



    pBlockColArray = pInfo->lastBlockColArray;




10,640,754✔





1477



  }










1478












1479



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




17,481,337✔





1480



  QUERY_CHECK_CODE(code, lino, _return);




17,484,238✔





1481












1482



  if (pInfo->pResBlock) {




17,484,238✔





1483



    blockDataDestroy(pInfo->pResBlock);




13,374,455✔





1484



    pInfo->pResBlock = NULL;




13,373,619✔





1485



  }










1486












1487



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




17,480,045✔





1488



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










1489



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










1490



         isNewTable, pInfo->base.orgCond.order,










1491



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










1492



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










1493



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










1494












1495



  if (isNewTable) {




17,475,271✔





1496



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




6,835,852✔





1497



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




6,117,949✔





1498



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




6,123,192✔





1499



    } else {










1500



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




724,440✔





1501



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




704,320✔





1502



    }










1503



  } else {










1504



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




10,639,419✔





1505



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




1,408,752✔





1506



    else {










1507



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




9,231,004✔





1508



    }










1509



  }










1510












1511



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




17,468,501✔





1512



  pInfo->currentGroupId = 0;




17,474,742✔





1513



  pInfo->ignoreTag = true;




17,462,701✔





1514












1515



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




17,449,001✔





1516



  QUERY_CHECK_CODE(code, lino, _return);




17,471,670✔





1517












1518



  if (isNewTable) {




17,471,670✔





1519



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




6,830,916✔





1520



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




4,854,159✔





1521



    }










1522



    pInfo->base.dataReader = NULL;




6,807,359✔





1523












1524



    taosRLockLatch(&pTaskInfo->lock);




6,810,202✔





1525



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




6,833,901✔





1526



    taosRUnLockLatch(&pTaskInfo->lock);




6,790,214✔





1527



    QUERY_CHECK_CODE(code, lino, _return);




6,828,140✔





1528












1529



    pInfo->newReader = true;




6,828,140✔





1530



    if (pInfo->lastColArray) {




6,814,749✔





1531



      taosArrayDestroy(pInfo->lastColArray);




2,733,701✔





1532



      pInfo->lastColArray = NULL;




2,732,865✔





1533



    }










1534



    if (pInfo->lastBlockColArray) {




6,817,808✔





1535



      taosArrayDestroy(pInfo->lastBlockColArray);




2,732,865✔





1536



      pInfo->lastBlockColArray = NULL;




2,733,202✔





1537



    }










1538



    pInfo->lastColArray = pColArray;




6,820,789✔





1539



    pInfo->lastBlockColArray = pBlockColArray;




6,812,070✔





1540



  } else {










1541



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




10,640,754✔





1542



    QUERY_CHECK_CODE(code, lino, _return);




10,640,754✔





1543












1544



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




10,640,754✔





1545



    pInfo->newReader = false;




10,640,754✔





1546



    pInfo->scanTimes = 0;




10,640,754✔





1547



  }










1548












1549



  pOperator->status = OP_OPENED;




17,419,829✔





1550












1551



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




17,455,689✔





1552



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




×







1553



  }










1554












1555



  pInfo->currentGroupId = -1;




17,446,933✔





1556



_return:




17,377,240✔





1557



  if (code) {




17,463,779✔





1558



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




×







1559



  }










1560



  pAPI->metaReaderFn.clearReader(&superTable);




17,463,779✔





1561



  pAPI->metaReaderFn.clearReader(&orgTable);




17,437,858✔





1562



  return code;




17,438,011✔





1563



}










1564












1565



static int32_t createVTableScanInfoFromParam(SOperatorInfo* pOperator) {




23,178,308✔





1566



  int32_t                  code = 0;




23,178,308✔





1567



  int32_t                  lino = 0;




23,178,308✔





1568



  STableScanInfo*          pInfo = pOperator->info;




23,178,308✔





1569



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




23,178,308✔





1570



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




23,178,308✔





1571



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




23,178,308✔





1572



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




23,178,308✔





1573



  SMetaReader              orgTable = {0};




23,178,308✔





1574



  SMetaReader              superTable = {0};




23,178,308✔





1575



  SSchemaWrapper*          schema = NULL;




23,178,308✔





1576



  SArray*                  pColArray = NULL;




23,178,308✔





1577



  SArray*                  pBlockColArray = NULL;




23,178,308✔





1578



  int32_t                  num = 0;




23,178,308✔





1579



  STableKeyInfo*           pList = NULL;




23,178,308✔





1580



  SOrgTbInfo*              pOrgTbInfo;










1581












1582



  cleanupQueryTableDataCond(&pInfo->base.cond);




23,178,308✔





1583












1584



  pOrgTbInfo = pParam->pOrgTbInfo;




23,178,308✔





1585












1586



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




23,178,308✔





1587












1588



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




23,178,308✔





1589



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




23,178,308✔





1590



  pAPI->metaReaderFn.readerReleaseLock(&orgTable);




23,178,308✔





1591



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




23,178,308✔





1592



  QUERY_CHECK_CODE(code, lino, _return);




23,178,308✔





1593



  switch (orgTable.me.type) {




23,178,308✔





1594



    case TSDB_CHILD_TABLE:




6,295,212✔





1595



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




6,295,212✔





1596



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




6,295,212✔





1597



      pAPI->metaReaderFn.readerReleaseLock(&superTable);




6,295,212✔





1598



      QUERY_CHECK_CODE(code, lino, _return);




6,295,212✔





1599



      schema = &superTable.me.stbEntry.schemaRow;




6,295,212✔





1600



      break;




6,295,212✔





1601



    case TSDB_NORMAL_TABLE:




16,883,096✔





1602



      schema = &orgTable.me.ntbEntry.schemaRow;




16,883,096✔





1603



      break;




16,883,096✔





1604



    default:




×







1605



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




×







1606



      return TSDB_CODE_INVALID_PARA;




×







1607



      break;










1608



  }










1609












1610



  pListInfo->oneTableForEachGroup = true;




23,178,308✔





1611



  taosHashClear(pListInfo->map);




23,178,308✔





1612



  taosArrayClear(pListInfo->pTableList);




23,178,308✔





1613












1614



  uint64_t      pUid = orgTable.me.uid;




23,178,308✔





1615



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




23,178,308✔





1616



  int32_t       tableIdx = 0;




23,178,308✔





1617



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




23,178,308✔





1618



  QUERY_CHECK_CODE(code, lino, _return);




23,178,308✔





1619



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




46,356,616✔





1620



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




23,178,308✔





1621












1622



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




23,178,308✔





1623



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




23,178,308✔





1624



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




23,178,308✔





1625



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




23,178,308✔





1626












1627



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










1628



  SColIdPair tsPair = {.vtbColId = PRIMARYKEY_TIMESTAMP_COL_ID,




23,178,308✔





1629



                       .orgColId = PRIMARYKEY_TIMESTAMP_COL_ID,










1630



                       .type.type = TSDB_DATA_TYPE_TIMESTAMP,










1631



                       .type.bytes = 8};










1632



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




23,178,308✔





1633












1634



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




92,716,594✔





1635



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




69,538,286✔





1636



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




586,786,098✔





1637



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




586,786,098✔





1638



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




69,538,286✔





1639



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




69,538,286✔





1640



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




69,538,286✔





1641



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




69,538,286✔





1642



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




69,538,286✔





1643



        break;




69,538,286✔





1644



      }










1645



    }










1646



  }










1647












1648



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




115,894,281✔





1649



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




92,716,594✔





1650



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




584,186,468✔





1651



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




584,186,468✔





1652



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




584,186,468✔





1653



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




92,716,594✔





1654



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




621✔





1655



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










1656



          code = TSDB_CODE_VTABLE_COLUMN_TYPE_MISMATCH;




621✔





1657



          goto _return;




621✔





1658



        }










1659



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




92,715,973✔





1660



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




92,715,973✔





1661



        break;




92,715,973✔





1662



      }










1663



    }










1664



  }










1665












1666



  taosArraySort(pColArray, compareColIdPair);




23,177,687✔





1667



  taosArraySort(pBlockColArray, compareColIdSlotIdPair);




23,177,687✔





1668



  if (pInfo->pBlockColMap) {




23,177,687✔





1669



    taosArrayDestroy(pInfo->pBlockColMap);




20,848,031✔





1670



    pInfo->pBlockColMap = NULL;




20,848,031✔





1671



  }










1672



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




23,177,687✔





1673



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




23,177,687✔





1674












1675



  taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




23,177,687✔





1676



  taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




23,177,687✔





1677












1678



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




23,177,687✔





1679



  QUERY_CHECK_CODE(code, lino, _return);




23,177,687✔





1680












1681



  if (pInfo->pResBlock) {




23,177,687✔





1682



    blockDataDestroy(pInfo->pResBlock);




16,472,996✔





1683



    pInfo->pResBlock = NULL;




16,472,996✔





1684



  }










1685












1686



  if (isNewScanParam(pParam)) {




23,177,687✔





1687



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




6,713,747✔





1688



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




6,713,747✔





1689



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




6,713,747✔





1690



    } else {










1691



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




×







1692



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




×







1693



    }










1694



  } else {










1695



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




16,463,940✔





1696



  }










1697



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




23,177,687✔





1698



  pInfo->currentGroupId = 0;




23,177,687✔





1699



  pInfo->ignoreTag = true;




23,177,687✔





1700












1701



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




23,177,687✔





1702



  QUERY_CHECK_CODE(code, lino, _return);




23,177,687✔





1703












1704



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




23,177,687✔





1705



  if (reader) {




23,177,687✔





1706



    if (isNewScanParam(pParam)) {




16,470,768✔





1707



      pAPI->tsdReader.tsdReaderClose(*reader);




6,828✔





1708



      pInfo->base.dataReader = NULL;




6,828✔





1709












1710



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




6,828✔





1711



      QUERY_CHECK_CODE(code, lino, _return);




6,828✔





1712












1713



      taosRLockLatch(&pTaskInfo->lock);




6,828✔





1714



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




6,828✔





1715



      taosRUnLockLatch(&pTaskInfo->lock);




6,828✔





1716



      QUERY_CHECK_CODE(code, lino, _return);




6,828✔





1717












1718



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




6,828✔





1719



      QUERY_CHECK_CODE(code, lino, _return);




6,828✔





1720



      pInfo->newReader = true;




6,828✔





1721



    } else {










1722



      pInfo->base.dataReader = *reader;




16,463,940✔





1723



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




16,463,940✔





1724



      QUERY_CHECK_CODE(code, lino, _return);




16,463,940✔





1725












1726



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




16,463,940✔





1727



      pInfo->newReader = false;




16,463,940✔





1728



      pInfo->scanTimes = 0;




16,463,940✔





1729



    }










1730



  } else {










1731



    pInfo->base.dataReader = NULL;




6,706,919✔





1732












1733



    taosRLockLatch(&pTaskInfo->lock);




6,706,919✔





1734



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




6,706,919✔





1735



    taosRUnLockLatch(&pTaskInfo->lock);




6,706,919✔





1736



    QUERY_CHECK_CODE(code, lino, _return);




6,706,919✔





1737












1738



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




6,706,919✔





1739



    QUERY_CHECK_CODE(code, lino, _return);




6,706,919✔





1740



    pInfo->newReader = true;




6,706,919✔





1741



  }










1742



  pOperator->status = OP_OPENED;




23,177,687✔





1743












1744



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




23,177,687✔





1745



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




×







1746



  }










1747












1748



  pInfo->currentGroupId = -1;




23,177,687✔





1749



_return:




23,178,308✔





1750



  if (code) {




23,178,308✔





1751



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




621✔





1752



  }










1753



  taosArrayDestroy(pColArray);




23,178,308✔





1754



  taosArrayDestroy(pBlockColArray);




23,178,308✔





1755



  pAPI->metaReaderFn.clearReader(&superTable);




23,178,308✔





1756



  pAPI->metaReaderFn.clearReader(&orgTable);




23,178,308✔





1757



  return code;




23,178,308✔





1758



}










1759












1760



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




182,385,903✔





1761



  int32_t         code = TSDB_CODE_SUCCESS;




182,385,903✔





1762



  int32_t         lino = 0;




182,385,903✔





1763



  STableScanInfo* pInfo = pOperator->info;




182,385,903✔





1764



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




182,390,279✔





1765



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




182,367,708✔





1766



  int32_t         numOfTables = 0;




182,392,701✔





1767












1768



  QRY_PARAM_CHECK(pResult);




182,338,217✔





1769












1770



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




182,330,331✔





1771



  QUERY_CHECK_CODE(code, lino, _end);




182,356,223✔





1772












1773



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




182,356,223✔





1774



    setOperatorCompleted(pOperator);




168,495,885✔





1775



    if (pOperator->dynamicTask) {




168,502,019✔





1776



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




932,926✔





1777



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




932,518✔





1778



    }










1779



    return code;




168,500,421✔





1780



  }










1781












1782



  // reset value for the next group data output










1783



  pOperator->status = OP_OPENED;




13,796,702✔





1784



  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);




13,874,140✔





1785












1786



  int32_t        num = 0;




13,871,698✔





1787



  STableKeyInfo* pList = NULL;




13,873,869✔





1788



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




13,846,777✔





1789



  QUERY_CHECK_CODE(code, lino, _end);




13,889,647✔





1790












1791



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




13,889,647✔





1792



  QUERY_CHECK_CODE(code, lino, _end);




13,885,536✔





1793












1794



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




13,885,536✔





1795



  QUERY_CHECK_CODE(code, lino, _end);




13,864,833✔





1796



  pInfo->scanTimes = 0;




13,864,833✔





1797












1798



  code = doGroupedTableScan(pOperator, pResult);




13,869,436✔





1799



  QUERY_CHECK_CODE(code, lino, _end);




13,914,120✔





1800












1801



  if (*pResult != NULL) {




13,914,120✔





1802



    if (pOperator->dynamicTask) {




11,266,497✔





1803



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




11,014,689✔





1804



    }










1805



    return code;




11,266,672✔





1806



  }










1807












1808



_end:




2,647,286✔





1809



  if (code != TSDB_CODE_SUCCESS) {




2,650,537✔





1810



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




×







1811



    pTaskInfo->code = code;




×







1812



  }










1813



  return code;




2,649,863✔





1814



}










1815












1816



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




736,586,500✔





1817



  int32_t         code = TSDB_CODE_SUCCESS;




736,586,500✔





1818



  int32_t         lino = 0;




736,586,500✔





1819



  STableScanInfo* pInfo = pOperator->info;




736,586,500✔





1820



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




736,589,212✔





1821



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




736,534,462✔





1822



  int32_t         num = 0;




736,472,923✔





1823



  STableKeyInfo*  pList = NULL;




736,405,078✔





1824



  SSDataBlock*    pResult = NULL;




736,568,685✔





1825



  const char*     idStr = GET_TASKID(pTaskInfo);




736,625,381✔





1826












1827



  QRY_PARAM_CHECK(pResBlock);




736,527,610✔





1828












1829



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




736,525,582✔





1830



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




172,618,971✔





1831



      setOperatorCompleted(pOperator);




×







1832



      return code;




×







1833



    }










1834












1835



    taosRLockLatch(&pTaskInfo->lock);




172,575,558✔





1836



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




172,622,520✔





1837



    taosRUnLockLatch(&pTaskInfo->lock);




172,589,199✔





1838



    QUERY_CHECK_CODE(code, lino, _end);




172,735,197✔





1839












1840



    if (pInfo->filesetDelimited) {




172,732,982✔





1841



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




240,720✔





1842



    }










1843












1844



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




172,737,462✔





1845



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




×







1846



    }










1847



  }










1848












1849



  code = doGroupedTableScan(pOperator, &pResult);




736,513,774✔





1850



  QUERY_CHECK_CODE(code, lino, _end);




735,367,325✔





1851












1852



  if (pResult != NULL) {




735,367,325✔





1853



    if (pOperator->dynamicTask) {




566,936,316✔





1854



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




1,990,017✔





1855



    }










1856












1857



    *pResBlock = pResult;




566,921,834✔





1858



    return code;




566,671,217✔





1859



  }










1860












1861



  while (true) {










1862



    code = startNextGroupScan(pOperator, &pResult);




168,509,982✔





1863



    QUERY_CHECK_CODE(code, lino, _end);




168,857,393✔





1864












1865



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




168,857,393✔





1866



      *pResBlock = pResult;




168,762,408✔





1867



      return code;




168,760,494✔





1868



    }










1869



  }










1870












1871



_end:




2,215✔





1872



  if (code != TSDB_CODE_SUCCESS) {




2,215✔





1873



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




2,215✔





1874



    pTaskInfo->code = code;




2,215✔





1875



  }










1876












1877



  return code;




2,215✔





1878



}










1879












1880



static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {




23,177,687✔





1881



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




23,177,687✔





1882



}










1883












1884



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




933,666✔





1885



  int32_t                  code = TSDB_CODE_SUCCESS;




933,666✔





1886



  int32_t                  lino = 0;




933,666✔





1887



  STableScanInfo*          pInfo = pOperator->info;




933,666✔





1888



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




933,666✔





1889



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




933,666✔





1890



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




933,666✔





1891












1892



  code = createTableListInfoFromParam(pOperator);




933,666✔





1893



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




933,666✔





1894



  pOperator->pOperatorGetParam = NULL;




933,666✔





1895



  QUERY_CHECK_CODE(code, lino, _end);




933,666✔





1896












1897



  if (pOperator->status == OP_EXEC_DONE) {




933,666✔





1898



    pInfo->currentGroupId = -1;




22,704✔





1899



    pOperator->status = OP_OPENED;




22,704✔





1900



    SSDataBlock* result = NULL;




22,704✔





1901












1902



    while (true) {










1903



      code = startNextGroupScan(pOperator, &result);




22,704✔





1904



      QUERY_CHECK_CODE(code, lino, _end);




22,704✔





1905












1906



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




22,704✔





1907



        (*ppRes) = result;




22,704✔





1908



        return code;




22,704✔





1909



      }










1910



    }










1911



  }










1912



_end:




910,962✔





1913



  if (code) {




910,962✔





1914



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




×







1915



  }










1916



  return code;




910,962✔





1917



}










1918












1919



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




23,178,308✔





1920



  int32_t                  code = TSDB_CODE_SUCCESS;




23,178,308✔





1921



  int32_t                  lino = 0;




23,178,308✔





1922



  STableScanInfo*          pInfo = pOperator->info;




23,178,308✔





1923



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




23,178,308✔





1924



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




23,178,308✔





1925



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




23,178,308✔





1926












1927



  QRY_PARAM_CHECK(ppRes);




23,178,308✔





1928



  qTrace("%s call", __FUNCTION__);




23,178,308✔





1929












1930



  code = createVTableScanInfoFromParam(pOperator);




23,178,308✔





1931



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




23,178,308✔





1932



  pOperator->pOperatorGetParam = NULL;




23,178,308✔





1933












1934



  QUERY_CHECK_CODE(code, lino, _end);




23,178,308✔





1935












1936



  SSDataBlock* result = NULL;




23,177,687✔





1937



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




23,177,687✔





1938



    (*ppRes) = result;




18,492✔





1939



    return code;




18,492✔





1940



  }










1941












1942



  if (pInfo->newReader) {




23,159,195✔





1943



    code = startNextGroupScan(pOperator, &result);




6,713,747✔





1944



    QUERY_CHECK_CODE(code, lino, _end);




6,713,747✔





1945



  } else {










1946



    code = doGroupedTableScan(pOperator, &result);




16,445,448✔





1947



    QUERY_CHECK_CODE(code, lino, _end);




16,445,448✔





1948



  }










1949












1950



  if (result) {




23,159,195✔





1951



    SSDataBlock* res = NULL;




16,472,852✔





1952



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




16,472,852✔





1953



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




16,472,852✔





1954



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




16,472,852✔





1955



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




16,472,852✔





1956



    QUERY_CHECK_CODE(code, lino, _end);




16,472,852✔





1957












1958



    pInfo->pResBlock = res;




16,472,852✔





1959



    blockDataDestroy(result);




16,472,852✔





1960



    (*ppRes) = res;




16,472,852✔





1961



  } else {










1962



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




6,686,343✔





1963



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




6,686,343✔





1964












1965



    blockDataDestroy(pInfo->pResBlock);




6,686,343✔





1966



    pInfo->pResBlock = NULL;




6,686,343✔





1967












1968



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




6,686,343✔





1969



    if (reader) {




6,686,343✔





1970



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




6,686,343✔





1971



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




6,686,343✔





1972



        pInfo->base.dataReader = NULL;




6,686,343✔





1973



      }










1974



      if (pAPI->tsdReader.tsdReaderClose) {




6,686,343✔





1975



        pAPI->tsdReader.tsdReaderClose(*reader);




6,686,343✔





1976



      }










1977



    }










1978












1979



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




6,686,343✔





1980



    QUERY_CHECK_CODE(code, lino, _end);




6,686,343✔





1981



  }










1982



_end:




23,159,816✔





1983



  if (code) {




23,159,816✔





1984



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




621✔





1985



  }










1986



  return code;




23,159,816✔





1987



}










1988












1989



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




3,046,862✔





1990



  int32_t                  code = TSDB_CODE_SUCCESS;




3,046,862✔





1991



  int32_t                  lino = 0;




3,046,862✔





1992



  STableScanInfo*          pInfo = pOperator->info;




3,046,862✔





1993



  int32_t                  index = 0;




3,046,862✔





1994



  char*                    tagVal = NULL;




3,046,862✔





1995












1996



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




21,337,468✔





1997



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




18,290,269✔





1998



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




18,290,269✔





1999












2000



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




18,290,606✔





2001



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




18,290,606✔





2002












2003



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




2,147,483,647✔





2004



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




2,147,483,647✔





2005



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




2,147,483,647✔





2006



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




2,147,483,647✔





2007












2008



        varDataSetLen(tagVal, pTagVal->nData);




2,147,483,647✔





2009



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




2,147,483,647✔





2010



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




2,147,483,647✔





2011



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2012



        taosMemoryFreeClear(tagVal);




2,147,483,647✔





2013



      } else {










2014



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




2,147,483,647✔





2015



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2016



      }










2017



    }










2018



    index++;




18,290,606✔





2019



  }










2020



  return code;




3,046,862✔





2021



_end:




×







2022



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




×







2023



  taosMemoryFreeClear(tagVal);




×







2024



  return code;




×







2025



}










2026












2027



static void clearVstbBatchDynamicTableScanInfo(STableScanInfo* pInfo) {




4,110,606✔





2028



  if (pInfo->pBatchColMap) {




4,110,606✔





2029



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




10,954,576✔





2030



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




6,843,633✔





2031



      taosArrayDestroy(pOrgTbInfo->colMap);




6,844,644✔





2032



    }










2033



    taosArrayDestroy(pInfo->pBatchColMap);




4,110,943✔





2034



    pInfo->pBatchColMap = NULL;




4,110,606✔





2035



  }










2036



  if (pInfo->cachedTagList) {




4,112,291✔





2037



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




12,871,219✔





2038



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




10,966,160✔





2039



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




10,966,834✔





2040



        taosMemoryFreeClear(pTagVal->pData);




4,810,579✔





2041



      }










2042



    }










2043



    taosArrayDestroy(pInfo->cachedTagList);




1,903,374✔





2044



    pInfo->cachedTagList = NULL;




1,902,700✔





2045



  }










2046



  if (pInfo->lastColArray) {




4,109,595✔





2047



    taosArrayDestroy(pInfo->lastColArray);




4,111,280✔





2048



    pInfo->lastColArray = NULL;




4,111,280✔





2049



  }










2050



  if (pInfo->lastBlockColArray) {




4,110,943✔





2051



    taosArrayDestroy(pInfo->lastBlockColArray);




4,112,291✔





2052



    pInfo->lastBlockColArray = NULL;




4,110,606✔





2053



  }










2054












2055



  blockDataDestroy(pInfo->pResBlock);




4,110,606✔





2056



  pInfo->pResBlock = NULL;




4,111,280✔





2057



}




4,111,954✔





2058












2059



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




14,742,843✔





2060



  int32_t                  code = TSDB_CODE_SUCCESS;




14,742,843✔





2061



  int32_t                  lino = 0;




14,742,843✔





2062



  STableScanInfo*          pInfo = pOperator->info;




14,742,843✔





2063



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




14,743,573✔





2064



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




14,735,204✔





2065



  SSDataBlock*             result = NULL;




14,739,896✔





2066












2067



  QRY_PARAM_CHECK(ppRes);




14,738,708✔





2068



  qTrace("%s call", __FUNCTION__);




14,744,223✔





2069












2070



  while (!result) {




28,120,156✔





2071



    code = createVTableScanInfoFromBatchParam(pOperator);




17,478,728✔





2072



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




17,437,059✔





2073



    pOperator->pOperatorGetParam = NULL;




17,429,337✔





2074



    QUERY_CHECK_CODE(code, lino, _end);




17,449,191✔





2075












2076



    if (pInfo->newReader) {




17,449,191✔





2077



      code = startNextGroupScan(pOperator, &result);




6,800,803✔





2078



      QUERY_CHECK_CODE(code, lino, _end);




6,843,983✔





2079



    } else {










2080



      code = doGroupedTableScan(pOperator, &result);




10,656,817✔





2081



      QUERY_CHECK_CODE(code, lino, _end);




10,640,754✔





2082



    }










2083



    if (!result) {




17,484,737✔





2084



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




6,843,471✔





2085



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










2086



      pInfo->currentBatchIdx++;




6,843,471✔





2087



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




6,844,145✔





2088



        // all batch scan finished










2089



        break;




4,110,606✔





2090



      }










2091



    }










2092



  }










2093












2094



  if (result) {




14,752,034✔





2095



    SSDataBlock* res = NULL;




10,640,754✔





2096



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




10,640,417✔





2097



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




10,638,745✔





2098



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




10,640,080✔





2099












2100



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




10,639,082✔





2101



    QUERY_CHECK_CODE(code, lino, _end);




10,640,255✔





2102












2103



    if (pInfo->cachedTagList) {




10,640,255✔





2104



      code = setTagValFromTagList(pOperator, res);




3,046,862✔





2105



      QUERY_CHECK_CODE(code, lino, _end);




3,046,862✔





2106



    }










2107












2108



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




10,640,255✔





2109



    pInfo->pResBlock = res;




10,640,255✔





2110



    blockDataDestroy(result);




10,639,743✔





2111



    (*ppRes) = res;




10,640,080✔





2112












2113



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




10,640,080✔





2114



  } else {










2115



    clearVstbBatchDynamicTableScanInfo(pInfo);




4,111,280✔





2116



    setOperatorCompleted(pOperator);




4,110,606✔





2117



  }










2118












2119



_end:




14,752,546✔





2120



  return code;




14,752,883✔





2121



}










2122












2123



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




38,860,770✔





2124



  int32_t                  code = TSDB_CODE_SUCCESS;




38,860,770✔





2125



  int32_t                  lino = 0;




38,860,770✔





2126



  STableScanInfo*          pInfo = pOperator->info;




38,860,770✔





2127



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




38,861,269✔





2128



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




38,861,431✔





2129












2130



  QRY_PARAM_CHECK(ppRes);




38,859,379✔





2131



  qTrace("%s call", __FUNCTION__);




38,857,951✔





2132












2133



  pOperator->dynamicTask = true;




38,857,951✔





2134












2135



  switch (type) {




38,860,608✔





2136



    case DYN_TYPE_VSTB_WIN_SCAN:




933,666✔





2137



    case DYN_TYPE_STB_JOIN: {










2138



      code = doStbJoinDynamicTableScanNext(pOperator, ppRes);




933,666✔





2139



      QUERY_CHECK_CODE(code, lino, _end);




933,666✔





2140



      break;




933,666✔





2141



    }










2142



    case DYN_TYPE_VSTB_SINGLE_SCAN: {




23,178,308✔





2143



      code = doVstbSingleDynamicTableScanNext(pOperator, ppRes);




23,178,308✔





2144



      QUERY_CHECK_CODE(code, lino, _end);




23,178,308✔





2145



      break;




23,177,687✔





2146



    }










2147



    case DYN_TYPE_VSTB_BATCH_SCAN:




14,748,634✔





2148



      code = doVstbBatchDynamicTableScanNext(pOperator, ppRes);




14,748,634✔





2149



      QUERY_CHECK_CODE(code, lino, _end);




14,751,872✔





2150



      break;




14,751,872✔





2151



    default:




×







2152



      code = TSDB_CODE_INVALID_PARA;




×







2153



      QUERY_CHECK_CODE(code, lino, _end);




×







2154



      break;




×







2155



  }










2156












2157



_end:




38,863,846✔





2158



  return code;




38,863,846✔





2159



}










2160












2161



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




780,218,165✔





2162



  int32_t         code = TSDB_CODE_SUCCESS;




780,218,165✔





2163



  int32_t         lino = 0;




780,218,165✔





2164



  STableScanInfo* pInfo = pOperator->info;




780,218,165✔





2165



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




780,312,432✔





2166



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




780,282,525✔





2167



  QRY_PARAM_CHECK(ppRes);




780,309,612✔





2168



  qTrace("%s call", __FUNCTION__);




780,328,071✔





2169












2170



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




780,328,071✔





2171



  QUERY_CHECK_CODE(code, lino, _end);




780,460,372✔





2172












2173



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




780,460,372✔





2174



  if (pGetParam || pInfo->pBatchColMap) {




780,469,500✔





2175



    ETableScanDynType type = pGetParam ?




38,856,082✔





2176



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




38,860,770✔





2177



      DYN_TYPE_VSTB_BATCH_SCAN;










2178












2179



    code = doDynamicTableScanNext(pOperator, type, ppRes);




38,856,082✔





2180



    QUERY_CHECK_CODE(code, lino, _end);




38,862,835✔





2181












2182



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




38,862,214✔





2183



      return code;




37,953,436✔





2184



    }










2185



  }










2186












2187



  // scan table one by one sequentially










2188



  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {




742,453,528✔





2189



    int32_t       numOfTables = 0;




5,920,612✔





2190



    STableKeyInfo tInfo = {0};




5,920,612✔





2191



    pInfo->countState = TABLE_COUNT_STATE_END;




5,920,612✔





2192












2193



    while (1) {




5,512,866✔





2194



      SSDataBlock* result = NULL;




11,433,478✔





2195



      code = doGroupedTableScan(pOperator, &result);




11,436,245✔





2196



      QUERY_CHECK_CODE(code, lino, _end);




11,421,712✔





2197












2198



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




11,421,712✔





2199



        (*ppRes) = result;




5,860,429✔





2200



        return code;




5,870,331✔





2201



      }










2202












2203



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










2204



      pInfo->currentTable++;




5,564,076✔





2205












2206



      taosRLockLatch(&pTaskInfo->lock);




5,553,853✔





2207



      numOfTables = 0;




5,565,317✔





2208



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




5,565,317✔





2209



      if (code != TSDB_CODE_SUCCESS) {




5,554,161✔





2210



        taosRUnLockLatch(&pTaskInfo->lock);




×







2211



        TSDB_CHECK_CODE(code, lino, _end);




×







2212



      }










2213












2214



      if (pInfo->currentTable >= numOfTables) {




5,554,161✔





2215



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




47,491✔





2216



        taosRUnLockLatch(&pTaskInfo->lock);




47,491✔





2217



        (*ppRes) = NULL;




47,491✔





2218



        return code;




47,491✔





2219



      }










2220












2221



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




5,499,279✔





2222



      if (!tmp) {




5,513,804✔





2223



        taosRUnLockLatch(&pTaskInfo->lock);




×







2224



        (*ppRes) = NULL;




×







2225



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




×







2226



      }










2227












2228



      tInfo = *tmp;




5,513,804✔





2229



      taosRUnLockLatch(&pTaskInfo->lock);




5,502,065✔





2230












2231



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




5,517,513✔





2232



      QUERY_CHECK_CODE(code, lino, _end);




5,506,089✔





2233



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




5,506,089✔





2234



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










2235












2236



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




5,519,693✔





2237



      QUERY_CHECK_CODE(code, lino, _end);




5,506,967✔





2238



      pInfo->scanTimes = 0;




5,506,967✔





2239



    }










2240



  } else {  // scan table group by group sequentially










2241



    code = groupSeqTableScan(pOperator, ppRes);




736,466,512✔





2242



    QUERY_CHECK_CODE(code, lino, _end);




735,474,405✔





2243



  }










2244












2245



_end:




735,472,190✔





2246



  if (code != TSDB_CODE_SUCCESS) {




735,460,494✔





2247



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




2,836✔





2248



    pTaskInfo->code = code;




2,836✔





2249



    T_LONG_JMP(pTaskInfo->env, code);




2,836✔





2250



  }










2251












2252



  return code;




735,457,658✔





2253



}










2254












2255



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




11,155,335✔





2256



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




11,155,335✔





2257



  if (!pRecorder) {




11,182,351✔





2258



    return terrno;




×







2259



  }










2260



  STableScanInfo* pTableScanInfo = pOptr->info;




11,182,351✔





2261



  *pRecorder = pTableScanInfo->base.readRecorder;




11,182,841✔





2262



  *pOptrExplain = pRecorder;




11,182,841✔





2263



  *len = sizeof(SFileBlockLoadRecorder);




11,181,861✔





2264



  return 0;




11,182,841✔





2265



}










2266












2267



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




211,581,766✔





2268



  cleanupQueryTableDataCond(&pBase->cond);




211,581,766✔





2269



  cleanupQueryTableDataCond(&pBase->orgCond);




211,581,598✔





2270












2271



  if (pAPI->tsdReaderClose) {




211,601,195✔





2272



    pAPI->tsdReaderClose(pBase->dataReader);




211,604,723✔





2273



  }










2274



  pBase->dataReader = NULL;




211,566,380✔





2275












2276



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




211,578,674✔





2277



    taosArrayDestroy(pBase->matchInfo.pList);




211,582,625✔





2278



  }










2279












2280



  tableListDestroy(pBase->pTableListInfo);




211,540,136✔





2281



  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);




211,634,050✔





2282



  cleanupExprSupp(&pBase->pseudoSup);




211,549,323✔





2283



}




211,626,127✔





2284












2285



static void cleanReaderForVTable(STableScanInfo* pInfo){




5,186,510✔





2286



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




5,186,510✔





2287



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




5,186,939✔





2288



    while (pIter != NULL) {




5,207,261✔





2289



      void **reader = pIter;




20,576✔





2290



      if (*reader) {




20,576✔





2291



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




20,576✔





2292



          pInfo->base.dataReader = NULL;




18,348✔





2293



        }










2294



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




20,576✔





2295



      }










2296



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




20,576✔





2297



    }










2298



  }










2299



}




5,187,753✔





2300












2301



static void destroyTableScanOperatorInfo(void* param) {




185,244,832✔





2302



  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;




185,244,832✔





2303



  blockDataDestroy(pTableScanInfo->pResBlock);




185,244,832✔





2304



  blockDataDestroy(pTableScanInfo->pOrgBlock);




185,261,774✔





2305



  taosHashCleanup(pTableScanInfo->pIgnoreTables);




185,279,011✔





2306



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




185,231,420✔





2307



    cleanReaderForVTable(pTableScanInfo);




5,186,940✔





2308



    taosHashCleanup(pTableScanInfo->readerCache);




5,187,184✔





2309



  }










2310



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




185,236,609✔





2311



  taosArrayDestroy(pTableScanInfo->pBlockColMap);




185,227,438✔





2312



  taosMemoryFreeClear(param);




185,263,462✔





2313



}




185,219,742✔





2314












2315



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




185,030,376✔





2316



  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {




185,030,376✔





2317



    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);




8,432,555✔





2318



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




20,948,646✔





2319



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




12,522,172✔





2320



      if (pCol) {




12,521,327✔





2321



        pCol->info.noData = true;




12,521,927✔





2322



      }










2323



    }










2324



  }










2325



}




185,024,295✔





2326












2327



static int32_t resetTableScanOperatorState(SOperatorInfo* pOper) {




226,476✔





2328



  int32_t         code = TSDB_CODE_SUCCESS;




226,476✔





2329



  STableScanInfo*   pInfo = pOper->info;




226,476✔





2330



  pOper->status = OP_NOT_OPENED;




226,476✔





2331












2332



  pInfo->scanTimes = 0;




226,476✔





2333



  pInfo->currentGroupId = -1;




226,476✔





2334



  pInfo->tableEndIndex = -1;




226,253✔





2335



  pInfo->tableStartIndex = 0;




226,253✔





2336



  pInfo->currentTable = 0;




226,253✔





2337



  pInfo->scanMode = 0;




226,253✔





2338



  pInfo->countState = 0;




226,476✔





2339



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




226,476✔





2340












2341



  if (!pInfo->virtualStableScan) {




226,476✔





2342



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










2343



  //   cleanReaderForVTable(pInfo);










2344



  //   taosHashClear(pInfo->readerCache);










2345



  //   pInfo->readerCache = false;










2346



  // } else {










2347



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




85,379✔





2348



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




85,379✔





2349



    }










2350



    pInfo->base.dataReader = NULL;




85,379✔





2351



  }










2352



  tableListDestroy(pInfo->base.pTableListInfo);




226,476✔





2353



  pInfo->base.pTableListInfo = tableListCreate();




226,476✔





2354



  if (!pInfo->base.pTableListInfo) {




226,476✔





2355



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




×







2356



    return terrno;




×







2357



  }










2358



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




226,476✔





2359












2360



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




226,476✔





2361



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




226,476✔





2362



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




167,908✔





2363



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










2364



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




167,908✔





2365



    if (code) {




84,379✔





2366



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




×







2367



      return code;




×







2368



    }










2369



  }










2370












2371



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




226,476✔





2372



  cleanupQueryTableDataCond(&pInfo->base.cond);




226,476✔





2373



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




226,476✔





2374



  if (code) {




226,311✔





2375



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




×







2376



    return code;




×







2377



  }










2378



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




226,311✔





2379



    cleanupQueryTableDataCond(&pInfo->base.orgCond);




141,097✔





2380



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




141,097✔





2381



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




141,097✔





2382



  } 










2383












2384



  pOper->resultInfo.totalRows = 0;




226,476✔





2385



  blockDataEmpty(pInfo->pResBlock);




226,476✔





2386



  blockDataEmpty(pInfo->pOrgBlock);




226,476✔





2387



  taosHashClear(pInfo->pIgnoreTables);




226,476✔





2388



  taosArrayDestroy(pInfo->pBlockColMap);




226,476✔





2389



  pInfo->pBlockColMap = NULL;




226,476✔





2390



  return code;




226,476✔





2391



}










2392












2393



int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




185,209,135✔





2394



                                    STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










2395



                                    SOperatorInfo** pOptrInfo) {










2396



  QRY_PARAM_CHECK(pOptrInfo);




185,209,135✔





2397












2398



  int32_t         code = TSDB_CODE_SUCCESS;




185,219,664✔





2399



  int32_t         lino = 0;




185,219,664✔





2400



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




185,219,664✔





2401



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




185,166,473✔





2402



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




185,151,217✔





2403



    code = terrno;




×







2404



    goto _error;




×







2405



  }










2406












2407



  pOperator->pPhyNode = pTableScanNode;




185,161,075✔





2408



  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;




185,163,629✔





2409



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




185,155,197✔





2410












2411



  int32_t numOfCols = 0;




185,195,394✔





2412



  code =










2413



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




185,205,550✔





2414



  QUERY_CHECK_CODE(code, lino, _error);




185,169,197✔





2415












2416



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




185,169,197✔





2417



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




185,059,102✔





2418



  QUERY_CHECK_CODE(code, lino, _error);




184,892,880✔





2419












2420



  if (pScanNode->pScanPseudoCols != NULL) {




184,892,880✔





2421



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




52,921,122✔





2422



    pSup->pExprInfo = NULL;




52,982,092✔





2423



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




52,990,125✔





2424



    QUERY_CHECK_CODE(code, lino, _error);




52,949,926✔





2425












2426



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




52,949,926✔





2427



                                      &pTaskInfo->storageAPI.functionStore);










2428



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




52,989,550✔





2429



  }










2430












2431



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




184,928,467✔





2432



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




184,785,867✔





2433












2434



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




184,953,049✔





2435



  pInfo->base.readHandle = *readHandle;




184,693,454✔





2436



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




184,877,860✔





2437












2438



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




184,790,843✔





2439



  pInfo->sample.seed = taosGetTimestampSec();




184,923,298✔





2440












2441



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




184,944,382✔





2442



  initResultSizeInfo(&pOperator->resultInfo, 4096);




185,008,485✔





2443



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




184,680,181✔





2444



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




185,191,511✔





2445



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




184,757,914✔





2446












2447



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




184,712,895✔





2448



  QUERY_CHECK_CODE(code, lino, _error);




184,713,241✔





2449












2450



  pInfo->virtualStableScan = pScanNode->virtualStableScan;




184,713,241✔





2451



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




184,748,212✔





2452



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




5,186,765✔





2453



    pInfo->pResBlock = NULL;




5,183,357✔





2454



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




5,186,534✔





2455



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




5,185,803✔





2456



  }










2457












2458



  if (pInfo->virtualStableScan) {




184,750,221✔





2459



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




5,182,590✔





2460



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




5,188,681✔





2461



  }










2462












2463



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




184,989,730✔





2464



                            pTaskInfo->pStreamRuntimeInfo);




184,970,145✔





2465



  QUERY_CHECK_CODE(code, lino, _error);




184,754,046✔





2466












2467



  pInfo->currentGroupId = -1;




184,731,432✔





2468












2469



  pInfo->tableEndIndex = -1;




184,964,995✔





2470



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




184,911,971✔





2471



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




184,795,543✔





2472












2473



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




184,983,232✔





2474



                  pTaskInfo);










2475



  pOperator->exprSupp.numOfExprs = numOfCols;




184,718,881✔





2476












2477



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




184,906,937✔





2478



  pInfo->ignoreTag = false;




184,963,400✔





2479












2480



  pInfo->lastBatchIdx = -1;




184,758,566✔





2481



  pInfo->currentBatchIdx = 0;




184,673,703✔





2482



  pInfo->base.pTableListInfo = pTableListInfo;




184,982,174✔





2483



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




184,835,445✔





2484



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




×







2485



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




×







2486



      code = terrno;




×







2487



      QUERY_CHECK_CODE(code, lino, _error);




×







2488



    }










2489












2490



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




×







2491



  }










2492












2493



  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




184,835,445✔





2494












2495



  pOperator->fpSet = createOperatorFpSet(prepareTableScan, doTableScanNext,




184,705,664✔





2496



                                         NULL, destroyTableScanOperatorInfo,










2497



                                         optrDefaultBufFn,










2498



                                         getTableScannerExecInfo,










2499



                                         optrDefaultGetNextExtFn, NULL);










2500












2501



  setOperatorResetStateFn(pOperator, resetTableScanOperatorState); 




184,723,009✔





2502



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










2503



  pOperator->cost.openCost = 0;




184,646,622✔





2504



  *pOptrInfo = pOperator;




184,623,503✔





2505



  return TSDB_CODE_SUCCESS;




184,545,194✔





2506












2507



_error:




22,614✔





2508



  if (pInfo != NULL) {




22,614✔





2509



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




22,614✔





2510



    destroyTableScanOperatorInfo(pInfo);




22,614✔





2511



  }










2512












2513



  if (pOperator != NULL) {




22,614✔





2514



    pOperator->info = NULL;




22,614✔





2515



    destroyOperator(pOperator);




22,614✔





2516



  }










2517



  pTaskInfo->code = code;




22,614✔





2518



  return code;




22,614✔





2519



}










2520












2521



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




×







2522



  QRY_PARAM_CHECK(pOptrInfo);




×







2523












2524



  int32_t         code = 0;




×







2525



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




×







2526



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




×







2527



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




×







2528



    code = terrno;




×







2529



    goto _end;




×







2530



  }










2531












2532



  pInfo->base.dataReader = pReadHandle;




×







2533



  //  pInfo->prevGroupId       = -1;










2534












2535



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




×







2536



                  pInfo, pTaskInfo);










2537



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




×







2538



                                         optrDefaultGetNextExtFn, NULL);










2539



  *pOptrInfo = pOperator;




×







2540



  return code;




×







2541












2542



_end:




×







2543



  if (pInfo != NULL) {




×







2544



    taosMemoryFree(pInfo);




×







2545



  }










2546












2547



  if (pOperator != NULL) {




×







2548



    taosMemoryFree(pOperator);




×







2549



  }










2550












2551



  pTaskInfo->code = code;




×







2552



  return code;




×







2553



}










2554












2555



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




13,917✔





2556



  int32_t code = TSDB_CODE_SUCCESS;




13,917✔





2557



  int32_t lino = 0;




13,917✔





2558



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




13,917✔





2559



    return code;




1,645✔





2560



  }










2561



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




12,272✔





2562



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




12,272✔





2563



  bool hasUnqualified = false;




12,272✔





2564












2565



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




12,272✔





2566



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




12,272✔





2567












2568



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




12,272✔





2569



         VALUE_GET_TRIVIAL_DATUM(&offset->primaryKey));










2570



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




12,272✔





2571



                        TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);










2572












2573



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




12,272✔





2574



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




12,272✔





2575



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




44,218,858✔





2576



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




44,206,586✔





2577



    void*    data = colDataGetData(pColPk, i);




44,206,586✔





2578



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




44,208,962✔





2579



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




2,376✔





2580



        QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY, lino, _end);




×







2581



      }










2582



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




2,376✔





2583



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




2,376✔





2584



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




2,376✔





2585



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




2,376✔





2586



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




2,376✔





2587



      taosMemoryFree(tmq);




2,376✔





2588



    } else {










2589



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




44,204,210✔





2590



    }










2591












2592



    if (!p[i]) {




44,206,586✔





2593



      hasUnqualified = true;




15,762,002✔





2594



    }










2595



  }










2596












2597



  if (hasUnqualified) {




12,272✔





2598



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




4,145✔





2599



    QUERY_CHECK_CODE(code, lino, _end);




4,145✔





2600



  }










2601












2602



_end:




12,272✔





2603



  taosMemoryFree(p);




12,272✔





2604



  if (code != TSDB_CODE_SUCCESS) {




12,272✔





2605



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




×







2606



  }










2607



  return code;




12,272✔





2608



}










2609












2610



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




1,397,739,481✔





2611



  int32_t p1 = *(int32_t*)param1;




1,397,739,481✔





2612



  int32_t p2 = *(int32_t*)param2;




1,397,811,428✔





2613












2614



  if (p1 == p2) {




1,397,822,714✔





2615



    return 0;




×







2616



  } else {










2617



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




1,397,822,714✔





2618



  }










2619



}










2620












2621



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




99,608,060✔





2622



  int32_t         code = TSDB_CODE_SUCCESS;




99,608,060✔





2623



  int32_t         lino = 0;




99,608,060✔





2624



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




99,608,060✔





2625



  SOperatorInfo*  pOperator = pInfo->pStreamScanOp;




99,608,060✔





2626



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




99,608,060✔





2627



  const char*     id = GET_TASKID(pTaskInfo);




99,607,717✔





2628



  SArray* pColList = NULL;




99,608,060✔





2629












2630



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




99,608,060✔





2631



  QUERY_CHECK_CODE(code, lino, _end);




99,604,626✔





2632












2633



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




99,604,626✔





2634



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




99,603,940✔





2635



  pBlockInfo->type = STREAM_NORMAL;




99,603,597✔





2636



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




99,604,969✔





2637












2638



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




99,604,969✔





2639



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




99,604,969✔





2640












2641



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




99,606,688✔





2642



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




99,607,031✔





2643












2644



  // todo extract method










2645



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




531,765,607✔





2646



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




432,168,467✔





2647



    if (!pColMatchInfo->needOutput) {




432,173,775✔





2648



      continue;




638✔





2649



    }










2650












2651



    bool colExists = false;




432,176,290✔





2652



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




1,352,775,804✔





2653



      SColumnInfoData* pResCol = NULL;




1,352,054,218✔





2654



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




1,351,899,485✔





2655



      QUERY_CHECK_CODE(code, lino, _end);




1,352,099,116✔





2656












2657



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




1,352,099,116✔





2658



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




432,237,327✔





2659



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




432,237,767✔





2660



        QUERY_CHECK_CODE(code, lino, _end);




432,082,876✔





2661












2662



        colExists = true;




432,082,876✔





2663



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




432,082,876✔





2664



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




432,176,508✔





2665



        break;




432,176,508✔





2666



      }










2667



    }










2668












2669



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










2670



    if (!colExists) {




432,157,938✔





2671



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




×







2672



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




×







2673



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




×







2674



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




×







2675



    }










2676



  }










2677












2678



  // currently only the tbname pseudo column










2679



  if (pInfo->numOfPseudoExpr > 0) {




99,603,647✔





2680



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




126,677,084✔





2681



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




63,338,974✔





2682



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










2683



    if (code) {




63,338,627✔





2684



      QUERY_CHECK_CODE(code, lino, _end);




×







2685



    }










2686












2687



    // reset the error code.










2688



    terrno = 0;




63,338,627✔





2689












2690



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




258,683,797✔





2691



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




195,338,988✔





2692



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




195,345,509✔





2693



    }










2694



  }










2695












2696



  taosArraySort(pColList, colIdComparFn);




99,588,897✔





2697












2698



  int32_t i = 0, j = 0;




99,606,060✔





2699



  while (i < taosArrayGetSize(pColList)) {




727,007,373✔





2700



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




627,391,401✔





2701



    if (slot1 > j) {




627,401,313✔





2702



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




×







2703



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




×







2704



      j += 1;




×







2705



    } else {










2706



      i += 1;




627,401,313✔





2707



      j += 1;




627,401,313✔





2708



    }










2709



  }










2710












2711



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




99,601,201✔





2712



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




638✔





2713



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




638✔





2714



    j += 1;




638✔





2715



  }










2716












2717



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




99,602,647✔





2718



  QUERY_CHECK_CODE(code, lino, _end);




99,601,081✔





2719












2720



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




99,601,081✔





2721



  QUERY_CHECK_CODE(code, lino, _end);




99,600,717✔





2722












2723



_end:




99,600,717✔





2724



  taosArrayDestroy(pColList);




98,892,112✔





2725



  if (code != TSDB_CODE_SUCCESS) {




99,601,361✔





2726



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




×







2727



  }










2728



  return code;




99,592,586✔





2729



}










2730












2731



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




6,611,881✔





2732



  int32_t code = TSDB_CODE_SUCCESS;




6,611,881✔





2733



  int32_t lino = 0;




6,611,881✔





2734



  SValue  val = {0};




6,611,881✔





2735



  if (hasPrimaryKey) {




6,613,411✔





2736



    code = doBlockDataPrimaryKeyFilter(pBlock, offset);




13,917✔





2737



    if (code != TSDB_CODE_SUCCESS) {




13,917✔





2738



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




×







2739



      return code;




×







2740



    }










2741



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




13,917✔





2742












2743



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




13,917✔





2744



      return code;




3,848✔





2745



    }










2746



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




10,069✔





2747



    val.type = pColPk->info.type;




10,069✔





2748



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




10,069✔





2749



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




634✔





2750



        return TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY;




×







2751



      }










2752



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




634✔





2753



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




634✔





2754



      val.nData = varDataLen(tmp);




634✔





2755



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




634✔





2756



    } else {










2757



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




9,435✔





2758



    }










2759



  }










2760



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




6,609,563✔





2761












2762



_end:




6,604,923✔





2763



  if (code != TSDB_CODE_SUCCESS) {




6,605,233✔





2764



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




×







2765



  }










2766



  return code;




6,605,523✔





2767



}










2768












2769



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




123,873,071✔





2770



  int32_t        code = TSDB_CODE_SUCCESS;




123,873,071✔





2771



  int32_t        lino = 0;




123,873,071✔





2772



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




123,873,071✔





2773



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




123,877,362✔





2774












2775



  SStreamScanInfo* pInfo = pOperator->info;




123,883,582✔





2776



  const char*      id = GET_TASKID(pTaskInfo);




123,879,253✔





2777












2778



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




123,879,672✔





2779












2780



  if (isTaskKilled(pTaskInfo)) {




123,883,040✔





2781



    (*ppRes) = NULL;




×







2782



    return pTaskInfo->code;




×







2783



  }










2784












2785



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




123,881,425✔





2786



    while (1) {




3,848✔





2787



      SSDataBlock* pResult = NULL;




5,920,612✔





2788



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




5,920,612✔





2789



      QUERY_CHECK_CODE(code, lino, _end);




5,916,582✔





2790












2791



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




5,916,582✔





2792



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




5,869,711✔





2793



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




5,872,811✔





2794



        QUERY_CHECK_CODE(code, lino, _end);




5,866,301✔





2795



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




5,866,301✔





2796



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




5,873,121✔





2797



          (*ppRes) = pResult;




5,869,273✔





2798



          return code;




5,869,273✔





2799



        }










2800



      } else {










2801



        break;










2802



      }










2803



    }










2804












2805



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




47,491✔





2806



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




47,491✔





2807












2808



    pTSInfo->base.dataReader = NULL;




47,491✔





2809



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




47,491✔





2810



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




47,491✔





2811



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




47,491✔





2812



      (*ppRes) = NULL;




12,537✔





2813



      return code;




12,537✔





2814



    }










2815












2816



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




34,954✔





2817



  }










2818












2819



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




117,998,929✔





2820



    while (1) {




752,570✔





2821



      bool hasResult =










2822



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




118,751,156✔





2823












2824



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




118,718,554✔





2825



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




118,736,539✔





2826












2827



      // curVersion move to next










2828



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




118,742,402✔





2829












2830



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










2831



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




118,737,657✔





2832












2833



      if (hasResult) {




118,742,837✔





2834



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




99,596,311✔





2835



               pTaskInfo->streamInfo.currentOffset.version);










2836



        blockDataCleanup(pInfo->pRes);




99,607,661✔





2837



        code = setBlockIntoRes(pInfo, pRes);




99,603,944✔





2838



        QUERY_CHECK_CODE(code, lino, _end);




99,594,396✔





2839



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




99,594,396✔





2840



               pTaskInfo->streamInfo.currentOffset.version);










2841



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




99,605,414✔





2842



          (*ppRes) = pInfo->pRes;




98,854,116✔





2843



          return code;




98,850,686✔





2844



        }










2845



      } else {










2846



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




19,146,526✔





2847



        (*ppRes) = NULL;




19,147,193✔





2848



        return code;




19,146,526✔





2849



      }










2850



    }










2851



  } else {










2852



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




×







2853



    (*ppRes) = NULL;




×







2854



    return code;




×







2855



  }










2856












2857



_end:




×







2858



  if (code != TSDB_CODE_SUCCESS) {




×







2859



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




×







2860



    pTaskInfo->code = code;




×







2861



    T_LONG_JMP(pTaskInfo->env, code);




×







2862



  }










2863



  (*ppRes) = NULL;




×







2864



  return code;




×







2865



}










2866












2867



static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {




×







2868



  SSDataBlock* pRes = NULL;




×







2869



  int32_t      code = doQueueScanNext(pOperator, &pRes);




×







2870



  return pRes;




×







2871



}










2872












2873



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




321,816✔





2874



  int32_t code = TSDB_CODE_SUCCESS;




321,816✔





2875



  int32_t lino = 0;




321,816✔





2876



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




321,816✔





2877



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




322,109✔





2878












2879



  // Transfer the Array of STableKeyInfo into uid list.










2880



  int32_t size = 0;




322,109✔





2881



  code = tableListGetSize(pTableListInfo, &size);




322,109✔





2882



  QUERY_CHECK_CODE(code, lino, _end);




322,105✔





2883



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




9,469,350✔





2884



    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);




9,146,612✔





2885



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




9,140,473✔





2886



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




9,140,473✔





2887



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




9,147,245✔





2888



  }










2889












2890



  (*ppArrayRes) = tableIdList;




322,738✔





2891












2892



_end:




323,020✔





2893



  if (code != TSDB_CODE_SUCCESS) {




323,020✔





2894



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




×







2895



  }










2896



  return code;




323,020✔





2897



}










2898












2899



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




1,502,023✔





2900



  int32_t        code = TSDB_CODE_SUCCESS;




1,502,023✔





2901



  int32_t        lino = 0;




1,502,023✔





2902



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,502,023✔





2903



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,502,023✔





2904












2905



  SStreamRawScanInfo* pInfo = pOperator->info;




1,502,023✔





2906



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




1,502,023✔





2907



  pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL;




1,502,023✔





2908












2909



  qDebug("tmqsnap doRawScan called");




1,501,723✔





2910



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




1,501,723✔





2911



    bool hasNext = false;




1,497,269✔





2912



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




1,497,269✔





2913



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




1,496,433✔





2914



      if (code != TSDB_CODE_SUCCESS) {




1,495,233✔





2915



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




×







2916



        QUERY_CHECK_CODE(code, lino, _end);




×







2917



      }










2918



    }










2919












2920



    if (pInfo->dataReader && hasNext) {




1,496,069✔





2921



      if (isTaskKilled(pTaskInfo)) {




743,070✔





2922



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




×







2923



        return code;




×







2924



      }










2925












2926



      SSDataBlock* pBlock = NULL;




743,370✔





2927



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




743,370✔





2928



      QUERY_CHECK_CODE(code, lino, _end);




742,170✔





2929












2930



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




742,170✔





2931



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




743,370✔





2932



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




742,770✔





2933



        QUERY_CHECK_CODE(code, lino, _end);




742,770✔





2934



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




742,770✔





2935



        (*ppRes) = pBlock;




743,670✔





2936



        return code;




743,370✔





2937



      }










2938



    }










2939












2940



    SMetaTableInfo mtInfo = {0};




752,699✔





2941



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




753,899✔





2942



    QUERY_CHECK_CODE(code, lino, _end);




753,599✔





2943



    if (code != 0) {




753,599✔





2944



      destroyMetaTableInfo(&mtInfo);










2945



      QUERY_CHECK_CODE(code, lino, _end);




×







2946



    }










2947



    STqOffsetVal offset = {0};




753,599✔





2948



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




752,699✔





2949



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




10,567✔





2950



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




10,567✔





2951



    } else {










2952



      SValue val = {0};




742,732✔





2953



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




742,732✔





2954



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




743,032✔





2955



    }










2956



    destroyMetaTableInfo(&mtInfo);










2957



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




753,899✔





2958



    QUERY_CHECK_CODE(code, lino, _end);




753,899✔





2959



    (*ppRes) = NULL;




753,899✔





2960



    return code;




753,899✔





2961



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




4,754✔





2962



    SSnapContext* sContext = pInfo->sContext;




4,754✔





2963



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




39,576✔





2964



      void*   data = NULL;




39,576✔





2965



      int32_t dataLen = 0;




39,576✔





2966



      int16_t type = 0;




39,576✔





2967



      int64_t uid = 0;




39,576✔





2968



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




39,576✔





2969



        qError("tmqsnap getTableInfoFromSnapshot error");




×







2970



        taosMemoryFreeClear(data);




×







2971



        break;




×







2972



      }










2973












2974



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




39,314✔





2975



        STqOffsetVal offset = {0};




4,754✔





2976



        SValue       val = {0};




4,754✔





2977



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




×







2978



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




4,754✔





2979



        QUERY_CHECK_CODE(code, lino, _end);




4,754✔





2980



        break;




4,754✔





2981



      } else {










2982



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




34,822✔





2983



        SMqMetaRsp tmpMetaRsp = {0};




34,822✔





2984



        tmpMetaRsp.resMsgType = type;




34,822✔





2985



        tmpMetaRsp.metaRspLen = dataLen;




34,822✔





2986



        tmpMetaRsp.metaRsp = data;




34,822✔





2987



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




34,822✔





2988



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




4,230✔





2989



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




4,230✔





2990












2991



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




4,230✔





2992



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




4,230✔





2993



        }










2994



        int32_t  tempRes = TSDB_CODE_SUCCESS;




34,822✔





2995



        uint32_t len = 0;




34,822✔





2996



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




34,822✔





2997



        if (TSDB_CODE_SUCCESS != tempRes) {




34,822✔





2998



          qError("tmqsnap tEncodeMqMetaRsp error");




×







2999



          taosMemoryFreeClear(data);




×







3000



          break;




×







3001



        }










3002












3003



        int32_t tLen = sizeof(SMqRspHead) + len;




34,822✔





3004



        void*   tBuf = taosMemoryCalloc(1, tLen);




34,822✔





3005



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




34,822✔





3006












3007



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




34,822✔





3008



        SEncoder encoder = {0};




34,822✔





3009



        tEncoderInit(&encoder, metaBuff, len);




34,822✔





3010



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




34,822✔





3011



        if (tempLen < 0) {




34,822✔





3012



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3013



          tEncoderClear(&encoder);




×







3014



          taosMemoryFreeClear(tBuf);




×







3015



          taosMemoryFreeClear(data);




×







3016



          break;




×







3017



        }










3018



        taosMemoryFreeClear(data);




34,822✔





3019



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




34,822✔





3020



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




34,822✔





3021












3022



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




34,822✔





3023



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




34,822✔





3024



      }










3025



    }










3026












3027



    (*ppRes) = NULL;




4,754✔





3028



    return code;




4,754✔





3029



  }










3030












3031



_end:




×







3032



  if (code != TSDB_CODE_SUCCESS) {




×







3033



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




×







3034



    pTaskInfo->code = code;




×







3035



    T_LONG_JMP(pTaskInfo->env, code);




×







3036



  }










3037












3038



  (*ppRes) = NULL;




×







3039



  return code;




×







3040



}










3041












3042



static void destroyTmqRawScanOperatorInfo(void* param) {




119,278✔





3043



  SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;




119,278✔





3044



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




119,278✔





3045



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




118,939✔





3046



  tableListDestroy(pRawScan->pTableListInfo);




119,278✔





3047



  taosMemoryFree(pRawScan);




119,278✔





3048



}




119,278✔





3049












3050



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










3051



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










3052



// and schemas are decided when scanning










3053



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




118,942✔





3054



  // create operator










3055



  // create tb reader










3056



  // create meta reader










3057



  // create tq reader










3058












3059



  QRY_PARAM_CHECK(pOptrInfo);




118,942✔





3060



  int32_t code = TSDB_CODE_SUCCESS;




119,278✔





3061



  int32_t lino = 0;




119,278✔





3062












3063



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




119,278✔





3064



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




118,942✔





3065



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




119,278✔





3066



    code = terrno;




×







3067



    lino = __LINE__;




×







3068



    goto _end;




×







3069



  }










3070












3071



  pInfo->pTableListInfo = tableListCreate();




119,278✔





3072



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




119,278✔





3073



  pInfo->vnode = pHandle->vnode;




119,278✔





3074



  pInfo->pAPI = &pTaskInfo->storageAPI;




119,278✔





3075












3076



  pInfo->sContext = pHandle->sContext;




119,278✔





3077



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




119,278✔





3078



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




119,278✔





3079



                  pTaskInfo);










3080












3081



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




119,278✔





3082



                                         NULL, optrDefaultGetNextExtFn, NULL);










3083



  *pOptrInfo = pOperator;




119,278✔





3084



  return code;




119,278✔





3085












3086



_end:




×







3087



  if (code != TSDB_CODE_SUCCESS) {




×







3088



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




×







3089



  }










3090



  taosMemoryFree(pInfo);




×







3091



  taosMemoryFree(pOperator);




×







3092



  pTaskInfo->code = code;




×







3093



  return code;




×







3094



}










3095












3096



void destroyTmqScanOperatorInfo(void* param) {




323,311✔





3097



  if (param == NULL) {




323,311✔





3098



    return;




×







3099



  }










3100












3101



  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;




323,311✔





3102



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




323,311✔





3103



    destroyOperator(pStreamScan->pTableScanOp);




323,311✔





3104



  }










3105












3106



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




323,020✔





3107



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




323,311✔





3108



  }










3109



  if (pStreamScan->pVtableMergeHandles) {




323,311✔





3110



    taosHashCleanup(pStreamScan->pVtableMergeHandles);




×







3111



    pStreamScan->pVtableMergeHandles = NULL;




×







3112



  }










3113



  if (pStreamScan->pVtableMergeBuf) {




323,311✔





3114



    destroyDiskbasedBuf(pStreamScan->pVtableMergeBuf);




×







3115



    pStreamScan->pVtableMergeBuf = NULL;




×







3116



  }










3117



  if (pStreamScan->pVtableReadyHandles) {




323,311✔





3118



    taosArrayDestroy(pStreamScan->pVtableReadyHandles);




×







3119



    pStreamScan->pVtableReadyHandles = NULL;




×







3120



  }










3121



  if (pStreamScan->pTableListInfo) {




323,311✔





3122



    tableListDestroy(pStreamScan->pTableListInfo);




×







3123



    pStreamScan->pTableListInfo = NULL;




×







3124



  }










3125



  if (pStreamScan->matchInfo.pList) {




323,311✔





3126



    taosArrayDestroy(pStreamScan->matchInfo.pList);




323,311✔





3127



  }










3128



  if (pStreamScan->pPseudoExpr) {




323,311✔





3129



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




185,814✔





3130



    taosMemoryFree(pStreamScan->pPseudoExpr);




185,814✔





3131



  }










3132












3133



  cleanupExprSupp(&pStreamScan->tbnameCalSup);




323,311✔





3134



  cleanupExprSupp(&pStreamScan->tagCalSup);




323,311✔





3135












3136



  blockDataDestroy(pStreamScan->pRes);




323,311✔





3137



  blockDataDestroy(pStreamScan->pUpdateRes);




323,311✔





3138



  blockDataDestroy(pStreamScan->pDeleteDataRes);




323,311✔





3139



  blockDataDestroy(pStreamScan->pUpdateDataRes);




323,311✔





3140



  blockDataDestroy(pStreamScan->pCreateTbRes);




323,311✔





3141



  taosArrayDestroy(pStreamScan->pBlockLists);




323,311✔





3142



  blockDataDestroy(pStreamScan->pCheckpointRes);




323,311✔





3143












3144



  taosMemoryFree(pStreamScan);




322,997✔





3145



}










3146












3147



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




×







3148



  int32_t code = TSDB_CODE_SUCCESS;




×







3149



  int32_t lino = 0;




×







3150



  pBlock->info.rowSize += bytes;




×







3151



  SColumnInfoData infoData = {0};




×







3152



  infoData.info.type = type;




×







3153



  infoData.info.bytes = bytes;




×







3154



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




×







3155



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




×







3156












3157



_end:




×







3158



  if (code != TSDB_CODE_SUCCESS) {




×







3159



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




×







3160



  }










3161



  return code;




×







3162



}










3163












3164



 int32_t createTmqScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,




322,472✔





3165



                                                  SNode* pTagCond, STableListInfo* pTableListInfo,










3166



                                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3167



  QRY_PARAM_CHECK(pOptrInfo);




322,472✔





3168












3169



  int32_t          code = TSDB_CODE_SUCCESS;




323,311✔





3170



  int32_t          lino = 0;




323,311✔





3171



  SArray*          pColIds = NULL;




323,311✔





3172



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




323,311✔





3173



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




323,311✔





3174



  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;




323,311✔





3175



  const char*      idstr = pTaskInfo->id.str;




323,311✔





3176












3177



  if (pInfo == NULL || pOperator == NULL) {




323,311✔





3178



    code = terrno;




×







3179



    goto _error;




×







3180



  }










3181












3182



  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;




323,311✔





3183



  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;




323,311✔





3184












3185



  pInfo->pTagCond = pTagCond;




323,311✔





3186



  pInfo->pGroupTags = pTableScanNode->pGroupTags;




323,311✔





3187












3188



  int32_t numOfCols = 0;




323,311✔





3189



  code = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




323,311✔





3190



  if (code != TSDB_CODE_SUCCESS) {




323,311✔





3191



    goto _error;




×







3192



  }










3193












3194



  SDataType pkType = {0};




323,311✔





3195



  pInfo->primaryKeyIndex = -1;




323,311✔





3196



  pInfo->basic.primaryPkIndex = -1;




323,311✔





3197



  int32_t numOfOutput = taosArrayGetSize(pInfo->matchInfo.pList);




323,311✔





3198



  pColIds = taosArrayInit(numOfOutput, sizeof(int16_t));




322,982✔





3199



  QUERY_CHECK_NULL(pColIds, code, lino, _error, terrno);




323,311✔





3200












3201



  for (int32_t i = 0; i < numOfOutput; ++i) {




2,027,425✔





3202



    SColMatchItem* id = taosArrayGet(pInfo->matchInfo.pList, i);




1,703,862✔





3203



    QUERY_CHECK_NULL(id, code, lino, _error, terrno);




1,703,533✔





3204












3205



    int16_t colId = id->colId;




1,703,533✔





3206



    void*   tmp = taosArrayPush(pColIds, &colId);




1,704,695✔





3207



    QUERY_CHECK_NULL(tmp, code, lino, _error, terrno);




1,704,695✔





3208












3209



    if (id->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




1,704,695✔





3210



      pInfo->primaryTsIndex = id->dstSlotId;




323,311✔





3211



    }










3212



    if (id->isPk) {




1,704,695✔





3213



      pInfo->primaryKeyIndex = id->dstSlotId;




1,523✔





3214



      pInfo->basic.primaryPkIndex = id->dstSlotId;




1,523✔





3215



      pkType = id->dataType;




1,523✔





3216



    }










3217



  }










3218












3219



  pInfo->pPartTbnameSup = NULL;




323,563✔





3220



  if (pTableScanNode->pSubtable != NULL) {




323,311✔





3221



    SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo));




×







3222



    if (pSubTableExpr == NULL) {




×







3223



      code = terrno;




×







3224



      goto _error;




×







3225



    }










3226












3227



    pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;




×







3228



    code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);




×







3229



    QUERY_CHECK_CODE(code, lino, _error);




×







3230












3231



    if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) {




×







3232



      goto _error;




×







3233



    }










3234



  }










3235












3236



  if (pTableScanNode->pTags != NULL) {




323,311✔





3237



    int32_t    numOfTags;




×







3238



    SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags);




×







3239



    if (pTagExpr == NULL) {




×







3240



      goto _error;




×







3241



    }










3242



    code = initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore);




×







3243



    if (code != 0) {




×







3244



      goto _error;




×







3245



    }










3246



  }










3247












3248



  pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData));




323,311✔





3249



  TSDB_CHECK_NULL(pInfo->pBlockLists, code, lino, _error, terrno);




323,039✔





3250












3251



  if (pHandle->vnode) {




322,982✔





3252



    SOperatorInfo* pTableScanOp = NULL;




323,311✔





3253



    code = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo, &pTableScanOp);




323,039✔





3254



    if (pTableScanOp == NULL || code != 0) {




323,311✔





3255



      qError("createTableScanOperatorInfo error, code:%d", pTaskInfo->code);




1,115✔





3256



      goto _error;




×







3257



    }










3258












3259



    STableScanInfo* pTSInfo = (STableScanInfo*)pTableScanOp->info;




322,196✔





3260



    if (pHandle->version > 0) {




323,039✔





3261



      pTSInfo->base.cond.endVersion = pHandle->version;




323,039✔





3262



    }










3263












3264



    STableKeyInfo* pList = NULL;




322,729✔





3265



    int32_t        num = 0;




323,311✔





3266



    code = tableListGetGroupList(pTableListInfo, 0, &pList, &num);




323,039✔





3267



    QUERY_CHECK_CODE(code, lino, _error);




323,039✔





3268












3269



    if (pHandle->initTableReader) {




323,039✔





3270



      pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;




323,039✔





3271



      pTSInfo->base.dataReader = NULL;




322,777✔





3272



    }










3273












3274



    if (pHandle->initTqReader) {




322,767✔





3275



      pInfo->tqReader = pAPI->tqReaderFn.tqReaderOpen(pHandle->vnode);




323,039✔





3276



      QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, terrno);




323,004✔





3277



    } else {










3278



      pInfo->tqReader = pHandle->tqReader;




×







3279



      QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




×







3280



    }










3281












3282



    pInfo->pUpdateInfo = NULL;




323,039✔





3283



    pInfo->pTableScanOp = pTableScanOp;




322,418✔





3284



    if (pInfo->pTableScanOp->pTaskInfo->streamInfo.pState) {




322,418✔





3285



      pAPI->stateStore.streamStateSetNumber(pInfo->pTableScanOp->pTaskInfo->streamInfo.pState, -1,




×







3286



                                            pInfo->primaryTsIndex);










3287



    }










3288












3289



    pInfo->readHandle = *pHandle;




323,039✔





3290



    pTaskInfo->streamInfo.snapshotVer = pHandle->version;




322,997✔





3291



    pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup);




322,997✔





3292



    QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, terrno);




323,020✔





3293



    pInfo->hasPart = false;




322,767✔





3294












3295



    code = blockDataEnsureCapacity(pInfo->pCreateTbRes, 8);




323,039✔





3296



    QUERY_CHECK_CODE(code, lino, _error);




323,311✔





3297












3298



    // set the extract column id to streamHandle










3299



    code = pAPI->tqReaderFn.tqReaderSetColIdList(pInfo->tqReader, pColIds, idstr);




323,311✔





3300



    QUERY_CHECK_CODE(code, lino, _error);




322,748✔





3301












3302



    SArray* tableIdList = NULL;




322,748✔





3303



    code = extractTableIdList(((STableScanInfo*)(pInfo->pTableScanOp->info))->base.pTableListInfo, &tableIdList);




322,748✔





3304



    QUERY_CHECK_CODE(code, lino, _error);




322,720✔





3305



    code = pAPI->tqReaderFn.tqReaderSetQueryTableList(pInfo->tqReader, tableIdList, idstr);




322,720✔





3306



    QUERY_CHECK_CODE(code, lino, _error);




323,311✔





3307



    taosArrayDestroy(tableIdList);




323,311✔





3308



    memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond));




323,311✔





3309



  } else {










3310



    taosArrayDestroy(pColIds);




×







3311



    tableListDestroy(pTableListInfo);




×







3312



  }










3313












3314



  // clear the local variable to avoid repeatly free










3315



  pColIds = NULL;




323,311✔





3316












3317



  // create the pseduo columns info










3318



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




323,311✔





3319



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pInfo->pPseudoExpr, &pInfo->numOfPseudoExpr);




185,814✔





3320



    QUERY_CHECK_CODE(code, lino, _error);




185,814✔





3321



  }










3322












3323



  code = filterInitFromNode((SNode*)pScanPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0, NULL);




323,311✔





3324



  QUERY_CHECK_CODE(code, lino, _error);




323,311✔





3325












3326



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




323,311✔





3327



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




323,311✔





3328



  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateRes);




323,311✔





3329



  QUERY_CHECK_CODE(code, lino, _error);




323,311✔





3330












3331



  pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;




323,311✔





3332



  pInfo->windowSup = (SWindowSupporter){.pStreamAggSup = NULL, .gap = -1, .parentType = QUERY_NODE_PHYSICAL_PLAN};




323,311✔





3333



  pInfo->groupId = 0;




322,997✔





3334



  pInfo->igCheckGroupId = false;




322,997✔





3335



  pInfo->pStreamScanOp = pOperator;




322,657✔





3336



  pInfo->deleteDataIndex = 0;




323,311✔





3337



  code = createSpecialDataBlock(STREAM_DELETE_DATA, &pInfo->pDeleteDataRes);




322,657✔





3338



  QUERY_CHECK_CODE(code, lino, _error);




323,311✔





3339












3340



  pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX};




323,311✔





3341



  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateDataRes);




323,311✔





3342



  QUERY_CHECK_CODE(code, lino, _error);




323,311✔





3343












3344



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




323,311✔





3345



  pInfo->partitionSup.needCalc = false;




323,311✔





3346



  pInfo->igCheckUpdate = pTableScanNode->igCheckUpdate;




323,311✔





3347



  pInfo->igExpired = pTableScanNode->igExpired;




323,311✔





3348



  pInfo->twAggSup.maxTs = INT64_MIN;




323,311✔





3349



  pInfo->pState = pTaskInfo->streamInfo.pState;




323,311✔





3350



  pInfo->stateStore = pTaskInfo->storageAPI.stateStore;




323,311✔





3351



  pInfo->readerFn = pTaskInfo->storageAPI.tqReaderFn;




323,311✔





3352



  pInfo->pFillSup = NULL;




323,311✔





3353



  pInfo->useGetResultRange = false;




323,311✔





3354



  pInfo->pRangeScanRes = NULL;




323,311✔





3355












3356



  code = createSpecialDataBlock(STREAM_CHECKPOINT, &pInfo->pCheckpointRes);




323,311✔





3357



  QUERY_CHECK_CODE(code, lino, _error);




323,311✔





3358












3359



  setOperatorInfo(pOperator, STREAM_SCAN_OP_NAME, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, false, OP_NOT_OPENED, pInfo,




323,311✔





3360



                  pTaskInfo);










3361



  pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);




323,311✔





3362












3363



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doQueueScanNext, NULL, destroyTmqScanOperatorInfo, optrDefaultBufFn,




323,311✔





3364



                                         NULL, optrDefaultGetNextExtFn, NULL);










3365












3366



  *pOptrInfo = pOperator;




323,311✔





3367



  return code;




323,311✔





3368












3369



_error:




×







3370



  if (pColIds != NULL) {




×







3371



    taosArrayDestroy(pColIds);




×







3372



  }










3373












3374



  if (pInfo != NULL && pInfo->pTableScanOp != NULL) {




×







3375



    STableScanInfo* p = (STableScanInfo*)pInfo->pTableScanOp->info;




×







3376



    if (p != NULL) {




×







3377



      p->base.pTableListInfo = NULL;




×







3378



    }










3379



    destroyTmqScanOperatorInfo(pInfo);




×







3380



  }










3381












3382



  if (pOperator != NULL) {




×







3383



    pOperator->info = NULL;




×







3384



    destroyOperator(pOperator);




×







3385



  }










3386



  pTaskInfo->code = code;




×







3387



  return code;




×







3388



}










3389












3390



static int32_t doTagScanOneTable(SOperatorInfo* pOperator, SSDataBlock* pRes, SMetaReader* mr, SStorageAPI* pAPI) {




9,761,313✔





3391



  int32_t        code = TSDB_CODE_SUCCESS;




9,761,313✔





3392



  int32_t        lino = 0;




9,761,313✔





3393



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,761,313✔





3394



  STagScanInfo*  pInfo = pOperator->info;




9,761,825✔





3395



  SExprInfo*     pExprInfo = &pOperator->exprSupp.pExprInfo[0];




9,762,823✔





3396



  int32_t        count = pRes->info.rows;




9,763,322✔





3397












3398



  STableKeyInfo* item = tableListGetInfo(pInfo->pTableListInfo, pInfo->curPos);




9,761,650✔





3399



  if (!item) {




9,758,157✔





3400



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3401



           GET_TASKID(pTaskInfo));










3402



    tDecoderClear(&(*mr).coder);




×







3403



    goto _end;




×







3404



  }










3405












3406



  code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid);




9,758,157✔





3407



  tDecoderClear(&(*mr).coder);




9,764,320✔





3408



  if (code != TSDB_CODE_SUCCESS) {




9,764,316✔





3409



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3410



           GET_TASKID(pTaskInfo));










3411



    goto _end;




×







3412



  }










3413












3414



  char str[512];




9,249,943✔





3415



  for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




42,379,821✔





3416



    SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




32,618,844✔





3417












3418



    // refactor later










3419



    if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) {




32,619,343✔





3420



      STR_TO_VARSTR(str, (*mr).me.name);




3,794,495✔





3421



      code = colDataSetVal(pDst, (count), str, false);




3,794,495✔





3422



      QUERY_CHECK_CODE(code, lino, _end);




3,794,154✔





3423



    } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) {




28,826,520✔





3424



      code = colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false);




5,332,484✔





3425



      QUERY_CHECK_CODE(code, lino, _end);




5,331,985✔





3426



    } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) {




23,495,034✔





3427



      code = colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false);




15,119✔





3428



      QUERY_CHECK_CODE(code, lino, _end);




15,119✔





3429



    } else {  // it is a tag value










3430



      STagVal val = {0};




23,481,749✔





3431



      val.cid = pExprInfo[j].base.pParam[0].pCol->colId;




23,481,250✔





3432



      const char* p = pAPI->metaFn.extractTagVal((*mr).me.ctbEntry.pTags, pDst->info.type, &val);




23,480,576✔





3433












3434



      char* data = NULL;




23,482,410✔





3435



      if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {




23,482,410✔





3436



        data = tTagValToData((const STagVal*)p, false);




23,481,051✔





3437



      } else {










3438



        data = (char*)p;




1,359✔





3439



      }










3440












3441



      code = colDataSetVal(pDst, (count), data,




23,480,913✔





3442



                           (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));




23,481,412✔





3443



      QUERY_CHECK_CODE(code, lino, _end);




23,480,239✔





3444












3445



      if ((pDst->info.type != TSDB_DATA_TYPE_JSON) && (p != NULL) && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) &&




23,480,239✔





3446



          (data != NULL)) {










3447



        taosMemoryFree(data);




8,328,657✔





3448



      }










3449



    }










3450



  }










3451












3452



_end:




9,768,649✔





3453



  if (code != TSDB_CODE_SUCCESS) {




9,762,320✔





3454



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3455



    pTaskInfo->code = code;




×







3456



  } else {










3457



    pRes->info.rows++;




9,762,320✔





3458



  }










3459












3460



  return code;




9,763,817✔





3461



}










3462












3463



static void tagScanFreeUidTag(void* p) {




7,479,505✔





3464



  STUidTagInfo* pInfo = p;




7,479,505✔





3465



  if (pInfo->pTagVal != NULL) {




7,479,505✔





3466



    taosMemoryFree(pInfo->pTagVal);




7,480,843✔





3467



  }










3468



}




7,474,766✔





3469












3470



static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) {




1,636,703✔





3471



  SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData));




1,636,703✔





3472



  if (pColumnData == NULL) {




1,637,689✔





3473



    return terrno;




×







3474



  }










3475












3476



  pColumnData->info.type = pType->type;




1,637,689✔





3477



  pColumnData->info.bytes = pType->bytes;




1,636,705✔





3478



  pColumnData->info.scale = pType->scale;




1,637,198✔





3479



  pColumnData->info.precision = pType->precision;




1,636,722✔





3480












3481



  int32_t code = colInfoDataEnsureCapacity(pColumnData, numOfRows, true);




1,637,689✔





3482



  if (code != TSDB_CODE_SUCCESS) {




1,634,382✔





3483



    terrno = code;




×







3484



    taosMemoryFree(pColumnData);




×







3485



    return terrno;




×







3486



  }










3487












3488



  pParam->columnData = pColumnData;




1,634,382✔





3489



  pParam->colAlloced = true;




1,636,703✔





3490



  return TSDB_CODE_SUCCESS;




1,636,210✔





3491



}










3492












3493



static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {




10,141,223✔





3494



  int32_t                code = TSDB_CODE_SUCCESS;




10,141,223✔





3495



  int32_t                lino = 0;




10,141,223✔





3496



  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;




10,141,223✔





3497



  SColumnNode*           pSColumnNode = NULL;




10,141,223✔





3498



  if (QUERY_NODE_COLUMN == nodeType((*pNode))) {




10,142,698✔





3499



    pSColumnNode = *(SColumnNode**)pNode;




2,856,983✔





3500



  } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {




7,293,659✔





3501



    SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);




500✔





3502



    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {




500✔





3503



      pSColumnNode = NULL;




×







3504



      pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);




×







3505



      if (NULL == pSColumnNode) {




×







3506



        return DEAL_RES_ERROR;




×







3507



      }










3508



      pSColumnNode->colId = -1;




×







3509



      pSColumnNode->colType = COLUMN_TYPE_TBNAME;




×







3510



      pSColumnNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




×







3511



      pSColumnNode->node.resType.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;




×







3512



      nodesDestroyNode(*pNode);




×







3513



      *pNode = (SNode*)pSColumnNode;




×







3514



    } else {










3515



      return DEAL_RES_CONTINUE;




500✔





3516



    }










3517



  } else {










3518



    return DEAL_RES_CONTINUE;




7,287,887✔





3519



  }










3520












3521



  void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));




2,855,152✔





3522



  if (!data) {




2,852,063✔





3523



    code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));




1,637,162✔





3524



    if (code == TSDB_CODE_DUP_KEY) {




1,640,093✔





3525



      code = TSDB_CODE_SUCCESS;




×







3526



    }










3527



    QUERY_CHECK_CODE(code, lino, _end);




1,640,093✔





3528



    pSColumnNode->slotId = pCtx->index++;




1,640,093✔





3529



    SColumnInfo cInfo = {.colId = pSColumnNode->colId,




1,640,588✔





3530



                         .type = pSColumnNode->node.resType.type,




1,638,128✔





3531



                         .bytes = pSColumnNode->node.resType.bytes};




1,637,161✔





3532



    void*       tmp = taosArrayPush(pCtx->cInfoList, &cInfo);




1,638,619✔





3533



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,639,602✔





3534



  } else {










3535



    SColumnNode* col = *(SColumnNode**)data;




1,214,901✔





3536



    pSColumnNode->slotId = col->slotId;




1,214,901✔





3537



  }










3538












3539



_end:




2,853,522✔





3540



  if (code != TSDB_CODE_SUCCESS) {




2,854,011✔





3541



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




490✔





3542



    return DEAL_RES_ERROR;




×







3543



  }










3544



  return DEAL_RES_CONTINUE;




2,853,523✔





3545



}










3546












3547



static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode,




1,638,180✔





3548



                                      SStorageAPI* pAPI, STagScanInfo* pInfo, void* pStreamRuntimeInfo) {










3549



  int32_t code = TSDB_CODE_SUCCESS;




1,638,180✔





3550



  int32_t lino = 0;




1,638,180✔





3551



  int32_t numOfTables = taosArrayGetSize(aUidTags);




1,638,180✔





3552



  SArray* pBlockList = NULL;




1,638,180✔





3553












3554



  SSDataBlock* pResBlock = createTagValBlockForFilter(pInfo->filterCtx.cInfoList, numOfTables, aUidTags, pVnode, pAPI);




1,638,180✔





3555



  QUERY_CHECK_NULL(pResBlock, code, lino, _end, terrno);




1,636,212✔





3556












3557



  pBlockList = taosArrayInit(1, POINTER_BYTES);




1,636,212✔





3558



  QUERY_CHECK_NULL(pBlockList, code, lino, _end, terrno);




1,636,703✔





3559












3560



  void* tmp = taosArrayPush(pBlockList, &pResBlock);




1,637,834✔





3561



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,637,834✔





3562












3563



  SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)};




1,637,834✔





3564












3565



  SScalarParam output = {0};




1,637,687✔





3566



  code = tagScanCreateResultData(&type, numOfTables, &output);




1,636,212✔





3567



  QUERY_CHECK_CODE(code, lino, _end);




1,634,872✔





3568












3569



  gTaskScalarExtra.pStreamInfo = (void*)pStreamRuntimeInfo;




1,634,872✔





3570



  gTaskScalarExtra.pStreamRange = NULL;




1,634,872✔





3571



  code = scalarCalculate(pTagCond, pBlockList, &output, &gTaskScalarExtra);




1,634,526✔





3572



  QUERY_CHECK_CODE(code, lino, _end);




1,631,317✔





3573












3574



  bool* result = (bool*)output.columnData->pData;




1,631,317✔





3575



  for (int32_t i = 0; i < numOfTables; ++i) {




4,085,966✔





3576



    if (result[i]) {




2,453,396✔





3577



      void* tmp = taosArrayPush(aFilterIdxs, &i);




2,300,446✔





3578



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




2,300,446✔





3579



    }










3580



  }










3581












3582



  colDataDestroy(output.columnData);




1,635,365✔





3583



  taosMemoryFreeClear(output.columnData);




1,631,948✔





3584












3585



_end:




1,627,039✔





3586



  blockDataDestroy(pResBlock);




1,626,407✔





3587



  taosArrayDestroy(pBlockList);




1,628,277✔





3588



  if (code != TSDB_CODE_SUCCESS) {




1,625,718✔





3589



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3590



  }










3591



  return code;




1,625,718✔





3592



}










3593












3594



static int32_t tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo,




28,910,208✔





3595



                                         SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex,










3596



                                         const SStorageAPI* pAPI, void* pVnode) {










3597



  int32_t code = TSDB_CODE_SUCCESS;




28,910,208✔





3598



  int32_t lino = 0;




28,910,208✔





3599



  if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) {




28,910,208✔





3600



    if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) {  // tbname




13,783,609✔





3601



      char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×







3602



      STR_TO_VARSTR(str, "ctbidx");




×







3603












3604



      code = colDataSetVal(pColInfo, rowIndex, str, false);




×







3605



      QUERY_CHECK_CODE(code, lino, _end);




×







3606



    } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) {




13,772,247✔





3607



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false);




6,887,309✔





3608



      QUERY_CHECK_CODE(code, lino, _end);




6,890,996✔





3609



    } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) {




6,891,636✔





3610



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false);




6,888,045✔





3611



      QUERY_CHECK_CODE(code, lino, _end);




6,891,166✔





3612



    }










3613



  } else {










3614



    STagVal tagVal = {0};




15,128,841✔





3615



    tagVal.cid = pExprInfo->base.pParam[0].pCol->colId;




15,130,696✔





3616



    if (pUidTagInfo->pTagVal == NULL) {




15,130,850✔





3617



      colDataSetNULL(pColInfo, rowIndex);




×







3618



    } else {










3619



      const char* p = pAPI->metaFn.extractTagVal(pUidTagInfo->pTagVal, pColInfo->info.type, &tagVal);




15,122,862✔





3620












3621



      if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {




15,127,664✔





3622



        colDataSetNULL(pColInfo, rowIndex);




9,322✔





3623



      } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {




15,118,006✔





3624



        code = colDataSetVal(pColInfo, rowIndex, p, false);




×







3625



        QUERY_CHECK_CODE(code, lino, _end);




×







3626



      } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {




18,764,151✔





3627



        if (IS_STR_DATA_BLOB(pColInfo->info.type)) {




3,638,427✔





3628



          QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_TAG, lino, _end);




×







3629



        }










3630



        char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);




3,648,541✔





3631



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




3,648,787✔





3632












3633



        varDataSetLen(tmp, tagVal.nData);




3,648,787✔





3634



        memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);




3,646,518✔





3635



        code = colDataSetVal(pColInfo, rowIndex, tmp, false);




3,653,752✔





3636



        taosMemoryFree(tmp);




3,652,575✔





3637



        QUERY_CHECK_CODE(code, lino, _end);




3,651,925✔





3638



      } else {










3639



        code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false);




11,462,210✔





3640



        QUERY_CHECK_CODE(code, lino, _end);




11,464,924✔





3641



      }










3642



    }










3643



  }










3644












3645



_end:




28,908,560✔





3646



  if (code != TSDB_CODE_SUCCESS) {




28,908,560✔





3647



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3648



  }










3649



  return code;




28,901,372✔





3650



}










3651












3652



static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags,




4,796,683✔





3653



                                      SArray* aFilterIdxs, bool ignoreFilterIdx, SStorageAPI* pAPI) {










3654



  int32_t       code = TSDB_CODE_SUCCESS;




4,796,683✔





3655



  int32_t       lino = 0;




4,796,683✔





3656



  STagScanInfo* pInfo = pOperator->info;




4,796,683✔





3657



  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];




4,795,835✔





3658



  if (!ignoreFilterIdx) {




4,793,246✔





3659



    size_t szTables = taosArrayGetSize(aFilterIdxs);




1,629,352✔





3660



    for (int i = 0; i < szTables; ++i) {




3,930,137✔





3661



      int32_t       idx = *(int32_t*)taosArrayGet(aFilterIdxs, i);




2,293,083✔





3662



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);




2,292,465✔





3663



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




2,298,347✔





3664



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




13,095,057✔





3665



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




10,784,266✔





3666



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




10,796,848✔





3667



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




10,796,848✔





3668



        QUERY_CHECK_CODE(code, lino, _end);




10,796,710✔





3669



      }










3670



    }










3671



  } else {










3672



    size_t szTables = taosArrayGetSize(aUidTags);




3,163,894✔





3673



    for (int i = 0; i < szTables; ++i) {




8,196,227✔





3674



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);




5,033,314✔





3675



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




5,033,464✔





3676



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




23,130,221✔





3677



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




18,101,117✔





3678



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




18,105,571✔





3679



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




18,105,571✔





3680



        QUERY_CHECK_CODE(code, lino, _end);




18,097,322✔





3681



      }










3682



    }










3683



  }










3684












3685



_end:




3,162,913✔





3686



  if (code != TSDB_CODE_SUCCESS) {




4,799,967✔





3687



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3688



  }










3689



  return code;




4,800,961✔





3690



}










3691












3692



static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




9,432,072✔





3693



  int32_t        code = TSDB_CODE_SUCCESS;




9,432,072✔





3694



  int32_t        lino = 0;




9,432,072✔





3695



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,432,072✔





3696



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




9,426,114✔





3697












3698



  STagScanInfo* pInfo = pOperator->info;




9,435,726✔





3699



  SSDataBlock*  pRes = pInfo->pRes;




9,437,319✔





3700












3701



  QRY_PARAM_CHECK(ppRes);




9,437,643✔





3702












3703



  if (pOperator->status == OP_EXEC_DONE) {




9,438,280✔





3704



    return TSDB_CODE_SUCCESS;




4,572,337✔





3705



  }










3706



  blockDataCleanup(pRes);




4,861,667✔





3707












3708



  if (pInfo->pCtbCursor == NULL) {




4,868,863✔





3709



    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);




4,871,809✔





3710



    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);




4,873,690✔





3711



  } else {










3712



    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);




×







3713



    QUERY_CHECK_CODE(code, lino, _end);




×







3714



  }










3715












3716



  SArray* aUidTags = pInfo->aUidTags;




4,872,230✔





3717



  SArray* aFilterIdxs = pInfo->aFilterIdxs;




4,872,064✔





3718



  int32_t count = 0;




4,866,640✔





3719



  bool    ctbCursorFinished = false;




4,866,640✔





3720



  while (1) {




99,312✔





3721



    taosArrayClearEx(aUidTags, tagScanFreeUidTag);




4,965,721✔





3722



    taosArrayClear(aFilterIdxs);




4,971,580✔





3723












3724



    int32_t numTables = 0;




4,969,145✔





3725



    while (numTables < pOperator->resultInfo.capacity) {




12,452,901✔





3726



      SMCtbCursor* pCur = pInfo->pCtbCursor;




12,456,628✔





3727



      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);




12,453,629✔





3728



      if (uid == 0) {




12,456,082✔





3729



        ctbCursorFinished = true;




4,973,415✔





3730



        break;




4,973,415✔





3731



      }










3732



      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};




7,482,667✔





3733



      info.pTagVal = taosMemoryMalloc(pCur->vLen);




7,473,917✔





3734



      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);




7,483,453✔





3735












3736



      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);




7,483,453✔





3737



      void* tmp = taosArrayPush(aUidTags, &info);




7,487,752✔





3738



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




7,487,752✔





3739



      ++numTables;




7,487,752✔





3740



    }










3741












3742



    if (numTables == 0) {




4,972,941✔





3743



      break;




171,185✔





3744



    }










3745



    bool ignoreFilterIdx = true;




4,801,756✔





3746



    if (pInfo->pTagCond != NULL) {




4,801,756✔





3747



      ignoreFilterIdx = false;




1,638,180✔





3748



      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo, pTaskInfo->pStreamRuntimeInfo);




1,638,180✔





3749



      QUERY_CHECK_CODE(code, lino, _end);




1,626,336✔





3750



    } else {










3751



      ignoreFilterIdx = true;




3,164,543✔





3752



    }










3753












3754



    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);




4,790,879✔





3755



    QUERY_CHECK_CODE(code, lino, _end);




4,800,393✔





3756












3757



    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);




4,800,393✔





3758












3759



    if (count != 0) {




4,800,112✔





3760



      break;




4,701,031✔





3761



    }










3762



  }










3763












3764



  if (count > 0) {




4,872,216✔





3765



    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);




4,701,031✔





3766



  }










3767



  if (count == 0 || ctbCursorFinished) {




4,872,270✔





3768



    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




4,871,946✔





3769



    pInfo->pCtbCursor = NULL;




4,863,361✔





3770



    setOperatorCompleted(pOperator);




4,865,802✔





3771



  }










3772












3773



  pRes->info.rows = count;




4,863,046✔





3774



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




4,862,572✔





3775



  if (bLimitReached) {




4,865,897✔





3776



    setOperatorCompleted(pOperator);




×







3777



  }










3778












3779



  pOperator->resultInfo.totalRows += pRes->info.rows;




4,866,203✔





3780



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




4,866,876✔





3781












3782



_end:




4,866,027✔





3783



  if (code != TSDB_CODE_SUCCESS) {




4,866,027✔





3784



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3785



    pTaskInfo->code = code;




×







3786



    T_LONG_JMP(pTaskInfo->env, code);




×







3787



  }










3788












3789



  return code;




4,866,027✔





3790



}










3791












3792



static int32_t createTagScanTableListInfoFromParam(SOperatorInfo* pOperator) {




3,403,315✔





3793



  STagScanInfo*          pInfo = pOperator->info;




3,403,315✔





3794



  SExecTaskInfo*         pTaskInfo = pOperator->pTaskInfo;




3,403,315✔





3795



  int32_t                code = 0;




3,403,315✔





3796



  STableListInfo*        pListInfo = pInfo->pTableListInfo;




3,403,315✔





3797



  STagScanOperatorParam* pParam = (STagScanOperatorParam*)pOperator->pOperatorGetParam->value;




3,403,315✔





3798



  tb_uid_t               pUid = pParam->vcUid;




3,403,315✔





3799












3800



  // qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",










3801



  //        pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList),










3802



  //        pOperator->status);










3803












3804



  STableKeyInfo info = {.groupId = 0};




3,403,315✔





3805












3806



  int32_t tableIdx = 0;




3,403,315✔





3807



  taosHashClear(pListInfo->map);




3,403,315✔





3808



  taosArrayClear(pListInfo->pTableList);




3,403,315✔





3809












3810



  if (taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {




3,403,315✔





3811



    if (TSDB_CODE_DUP_KEY == terrno) {




×







3812



    } else {










3813



      return terrno;




×







3814



    }










3815



  }










3816












3817



  info.uid = pUid;




3,403,315✔





3818



  void* p = taosArrayPush(pListInfo->pTableList, &info);




3,403,315✔





3819



  if (p == NULL) {




3,403,315✔





3820



    return terrno;




×







3821



  }










3822












3823



  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));




3,403,315✔





3824












3825



  return code;




3,403,315✔





3826



}










3827












3828



static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




7,598,126✔





3829



  int32_t       code = TSDB_CODE_SUCCESS;




7,598,126✔





3830



  int32_t       lino = 0;




7,598,126✔





3831



  STagScanInfo* pInfo = pOperator->info;




7,598,126✔





3832



  if (pOperator->pOperatorGetParam) {




7,597,627✔





3833



    pOperator->resultInfo.totalRows = 0;




3,403,315✔





3834



    pOperator->dynamicTask = true;




3,403,315✔





3835



    pInfo->curPos = 0;




3,403,315✔





3836



    code = createTagScanTableListInfoFromParam(pOperator);




3,403,315✔





3837



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




3,403,315✔





3838



    pOperator->pOperatorGetParam = NULL;




3,403,315✔





3839



    QUERY_CHECK_CODE(code, lino, _end);




3,403,315✔





3840












3841



    if (pOperator->status == OP_EXEC_DONE) {




3,403,315✔





3842



      pOperator->status = OP_OPENED;




1,838,352✔





3843



    }










3844



  }










3845












3846



  if (pOperator->status == OP_EXEC_DONE) {




7,596,467✔





3847



    (*ppRes) = NULL;




2,049,366✔





3848



    return code;




2,049,029✔





3849



  }










3850












3851



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




5,545,604✔





3852



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




5,549,596✔





3853












3854



  SExprInfo*   pExprInfo = &pOperator->exprSupp.pExprInfo[0];




5,548,760✔





3855



  SSDataBlock* pRes = pInfo->pRes;




5,546,764✔





3856



  blockDataCleanup(pRes);




5,546,764✔





3857












3858



  int32_t size = 0;




5,549,097✔





3859



  code = tableListGetSize(pInfo->pTableListInfo, &size);




5,549,097✔





3860



  QUERY_CHECK_CODE(code, lino, _end);




5,546,427✔





3861












3862



  if (size == 0) {




5,546,427✔





3863



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




18,911✔





3864



    (*ppRes) = NULL;




18,911✔





3865



    return code;




18,911✔





3866



  }










3867












3868



  SMetaReader mr = {0};




5,527,516✔





3869



  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




5,530,186✔





3870



  pRes->info.rows = 0;




5,529,687✔





3871












3872



  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {




15,290,173✔





3873



    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);




9,762,648✔





3874



    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD &&




9,763,817✔





3875



        code != TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED) {










3876



      // ignore other error










3877



      code = TSDB_CODE_SUCCESS;




9,762,815✔





3878



    }










3879



    QUERY_CHECK_CODE(code, lino, _end);




9,763,817✔





3880












3881



    if (++pInfo->curPos >= size) {




9,763,817✔





3882



      setOperatorCompleted(pOperator);




5,530,685✔





3883



    }










3884



  }










3885












3886



  pAPI->metaReaderFn.clearReader(&mr);




5,530,365✔





3887



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




5,530,685✔





3888



  if (bLimitReached) {




5,530,685✔





3889



    setOperatorCompleted(pOperator);




×







3890



  }










3891












3892



  // qDebug("QInfo:0x%" PRIx64 ", create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);










3893



  if (pOperator->status == OP_EXEC_DONE) {




5,530,685✔





3894



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




5,530,685✔





3895



  }










3896












3897



  pOperator->resultInfo.totalRows += pRes->info.rows;




5,530,348✔





3898












3899



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




5,530,685✔





3900



_end:




5,530,685✔





3901



  if (code != TSDB_CODE_SUCCESS) {




5,530,685✔





3902



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3903



    pTaskInfo->code = code;




×







3904



    T_LONG_JMP(pTaskInfo->env, code);




×







3905



  }










3906



  return code;




5,530,685✔





3907



}










3908












3909



static void destroyTagScanOperatorInfo(void* param) {




9,083,456✔





3910



  STagScanInfo* pInfo = (STagScanInfo*)param;




9,083,456✔





3911



  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {




9,083,456✔





3912



    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




×







3913



  }










3914



  taosHashCleanup(pInfo->filterCtx.colHash);




9,089,473✔





3915



  taosArrayDestroy(pInfo->filterCtx.cInfoList);




9,072,664✔





3916



  taosArrayDestroy(pInfo->aFilterIdxs);




9,067,491✔





3917



  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);




9,066,499✔





3918












3919



  blockDataDestroy(pInfo->pRes);




9,085,572✔





3920



  taosArrayDestroy(pInfo->matchInfo.pList);




9,079,148✔





3921



  tableListDestroy(pInfo->pTableListInfo);




9,070,627✔





3922












3923



  pInfo->pRes = NULL;




9,088,503✔





3924



  pInfo->pTableListInfo = NULL;




9,088,859✔





3925



  taosMemoryFreeClear(param);




9,088,122✔





3926



}




9,085,557✔





3927












3928



static int32_t resetTagScanOperatorState(SOperatorInfo* pOper) {




4,860✔





3929



  int32_t         code = TSDB_CODE_SUCCESS;




4,860✔





3930



  STagScanInfo*   pInfo = pOper->info;




4,860✔





3931












3932



  pOper->status = OP_NOT_OPENED;




4,860✔





3933



  STagScanPhysiNode* pTagScanNode = (STagScanPhysiNode*)pOper->pPhyNode;




4,860✔





3934



  if (pTagScanNode->onlyMetaCtbIdx) {




4,860✔





3935



      SExecTaskInfo* pTaskInfo = pOper->pTaskInfo;




2,000✔





3936



      SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




2,000✔





3937



      pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




2,000✔





3938



      pInfo->pCtbCursor = NULL;




2,000✔





3939



  } else {










3940



      pInfo->curPos = 0;




2,860✔





3941



  }










3942












3943



  return code;




4,860✔





3944



}










3945












3946



int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,




9,076,962✔





3947



                                  STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond,










3948



                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3949



  QRY_PARAM_CHECK(pOptrInfo);




9,076,962✔





3950












3951



  int32_t         code = TSDB_CODE_SUCCESS;




9,081,899✔





3952



  int32_t         lino = 0;




9,081,899✔





3953



  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;




9,081,899✔





3954



  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));




9,081,899✔





3955



  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




9,068,565✔





3956



  if (pInfo == NULL || pOperator == NULL) {




9,061,502✔





3957



    code = terrno;




×







3958



    goto _error;




×







3959



  }










3960



  pOperator->pPhyNode = pTagScanNode;




9,061,808✔





3961



  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;




9,061,793✔





3962












3963



  int32_t    numOfExprs = 0;




9,068,867✔





3964



  SExprInfo* pExprInfo = NULL;




9,068,171✔





3965












3966



  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);




9,071,800✔





3967



  QUERY_CHECK_CODE(code, lino, _error);




9,089,313✔





3968












3969



  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);




9,089,313✔





3970



  QUERY_CHECK_CODE(code, lino, _error);




9,057,442✔





3971












3972



  int32_t num = 0;




9,057,442✔





3973



  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




9,062,550✔





3974



  QUERY_CHECK_CODE(code, lino, _error);




9,083,566✔





3975












3976



  pInfo->pTagCond = pTagCond;




9,083,566✔





3977



  pInfo->pTagIndexCond = pTagIndexCond;




9,086,028✔





3978



  pInfo->suid = pPhyNode->suid;




9,082,908✔





3979



  pInfo->pStorageAPI = &pTaskInfo->storageAPI;




9,077,796✔





3980












3981



  pInfo->pTableListInfo = pTableListInfo;




9,060,260✔





3982



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




9,084,730✔





3983



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




9,089,989✔





3984












3985



  pInfo->readHandle = *pReadHandle;




9,063,097✔





3986



  pInfo->curPos = 0;




9,081,788✔





3987












3988



  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);




9,055,652✔





3989



  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,




9,055,727✔





3990



                  pTaskInfo);










3991



  initResultSizeInfo(&pOperator->resultInfo, 4096);




9,049,041✔





3992



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




9,046,453✔





3993



  QUERY_CHECK_CODE(code, lino, _error);




9,088,298✔





3994












3995



  if (pTagScanNode->onlyMetaCtbIdx) {




9,088,298✔





3996



    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));




4,989,839✔





3997



    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);




4,993,944✔





3998












3999



    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));




4,992,468✔





4000



    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);




4,994,323✔





4001












4002



    pInfo->filterCtx.colHash =




4,991,932✔





4003



        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);




4,994,323✔





4004



    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);




4,992,425✔





4005












4006



    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));




4,991,441✔





4007



    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);




4,992,924✔





4008












4009



    if (pInfo->pTagCond != NULL) {




4,992,088✔





4010



      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);




1,641,079✔





4011



    }










4012



  }










4013



  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;




9,089,770✔





4014



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,




9,091,666✔





4015



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










4016



  setOperatorResetStateFn(pOperator, resetTagScanOperatorState);     




9,082,364✔





4017



  










4018



  *pOptrInfo = pOperator;




9,081,173✔





4019



  return code;




9,083,258✔





4020












4021



_error:




×







4022



  if (pInfo) {




×







4023



    pInfo->pTableListInfo = NULL;




×







4024



  }










4025












4026



  if (pInfo != NULL) destroyTagScanOperatorInfo(pInfo);




×







4027



  if (pOperator != NULL) {




×







4028



    pOperator->info = NULL;




×







4029



    destroyOperator(pOperator);




×







4030



  }










4031



  return code;




×







4032



}










4033












4034



// table merge scan operator










4035












4036



static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {




235,184,964✔





4037



  int32_t                 left = *(int32_t*)pLeft;




235,184,964✔





4038



  int32_t                 right = *(int32_t*)pRight;




235,186,744✔





4039



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




235,187,812✔





4040












4041



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




235,187,812✔





4042



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




235,187,100✔





4043












4044



  if (leftIdx == -1) {




235,184,252✔





4045



    return 1;




201,636,092✔





4046



  } else if (rightIdx == -1) {




33,548,160✔





4047



    return -1;




332,160✔





4048



  }










4049












4050



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




33,216,000✔





4051



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




33,216,000✔





4052



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




33,216,000✔





4053



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




33,216,000✔





4054



    ret = -1 * ret;




×







4055



  }










4056



  return ret;




33,216,000✔





4057



}










4058












4059



static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) {




×







4060



  int32_t                 left = *(int32_t*)pLeft;




×







4061



  int32_t                 right = *(int32_t*)pRight;




×







4062



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




×







4063












4064



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




×







4065



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




×







4066












4067



  if (leftIdx == -1) {




×







4068



    return 1;




×







4069



  } else if (rightIdx == -1) {




×







4070



    return -1;




×







4071



  }










4072












4073



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




×







4074



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




×







4075



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




×







4076



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




×







4077



    ret = -1 * ret;




×







4078



  }










4079



  if (ret == 0 && pInfo->pPkOrderInfo) {




×







4080



    ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx,




×







4081



                               pInfo->pPkOrderInfo);




×







4082



  }










4083



  return ret;




×







4084



}










4085












4086



int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {




2,973,640✔





4087



  int32_t code = TSDB_CODE_SUCCESS;




2,973,640✔





4088



  int32_t lino = 0;




2,973,640✔





4089



  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));




2,973,640✔





4090



  dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));




2,973,640✔





4091



  QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);




2,965,988✔





4092



  for (int i = 0; i < src->numOfCols; i++) {




10,163,930✔





4093



    dst->colList[i] = src->colList[i];




7,205,288✔





4094



  }










4095












4096



_end:




2,965,988✔





4097



  if (code != TSDB_CODE_SUCCESS) {




2,965,988✔





4098



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4099



  }










4100



  return code;




2,963,932✔





4101



}










4102












4103



static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,




4,476,958✔





4104



                                                bool* pSubTableHasBlock) {










4105



  int32_t code = 0;




4,476,958✔





4106












4107



  STableMergeScanInfo*    pInfo = pOperator->info;




4,476,958✔





4108



  SReadHandle*            pHandle = &pInfo->base.readHandle;




4,477,344✔





4109



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




4,478,036✔





4110



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




4,473,448✔





4111



  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;




4,477,334✔





4112












4113



  blockDataCleanup(pInput->pReaderBlock);




4,480,122✔





4114



  if (!pInput->bInMemReader) {




4,474,220✔





4115



    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,




4,476,508✔





4116



                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




2,240,864✔





4117



    if (code != 0) {




2,238,788✔





4118



      return code;




×







4119



    }










4120



  }










4121












4122



  pInfo->base.dataReader = pInput->pReader;




4,473,874✔





4123












4124



  while (true) {




8,544✔





4125



    bool hasNext = false;




4,482,704✔





4126



    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);




4,482,704✔





4127



    if (code != 0) {




4,486,956✔





4128



      pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4129



      pInfo->base.dataReader = NULL;




×







4130



      return code;




×







4131



    }










4132












4133



    if (!hasNext || isTaskKilled(pTaskInfo)) {




4,486,956✔





4134



      if (isTaskKilled(pTaskInfo)) {




2,989,320✔





4135



        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4136



        pInfo->base.dataReader = NULL;




×







4137



        return code;




×







4138



      }










4139












4140



      *pSubTableHasBlock = false;




2,991,050✔





4141



      break;




2,989,320✔





4142



    }










4143












4144



    if (pInput->tblCond.order == TSDB_ORDER_ASC) {




1,497,636✔





4145



      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;




1,471,648✔





4146



    } else {










4147



      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;




25,988✔





4148



    }










4149












4150



    uint32_t status = 0;




1,497,636✔





4151



    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);




1,497,636✔





4152



    if (code != 0) {




1,497,636✔





4153



      pInfo->base.dataReader = NULL;




×







4154



      return code;




×







4155



    }










4156












4157



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




1,497,636✔





4158



      *pSubTableHasBlock = false;




×







4159



      break;




×







4160



    }










4161



    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {




1,497,636✔





4162



      continue;




8,544✔





4163



    }










4164












4165



    *pSubTableHasBlock = true;




1,489,092✔





4166



    break;




1,488,746✔





4167



  }










4168












4169



  if (*pSubTableHasBlock) {




4,480,834✔





4170



    pInput->pReaderBlock->info.id.groupId =




2,978,184✔





4171



        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);




2,977,492✔





4172



    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;




1,489,092✔





4173



  }










4174



  if (!pInput->bInMemReader || !*pSubTableHasBlock) {




4,480,834✔





4175



    pAPI->tsdReader.tsdReaderClose(pInput->pReader);




3,363,366✔





4176



    pInput->pReader = NULL;




3,361,952✔





4177



  }










4178












4179



  pInfo->base.dataReader = NULL;




4,478,382✔





4180



  return TSDB_CODE_SUCCESS;




4,478,046✔





4181



}










4182












4183



static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {




1,839,384✔





4184



  pInfo->bGroupProcessed = false;




1,839,384✔





4185












4186



  int32_t numOfTables = 0;




1,846,028✔





4187



  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




1,825,840✔





4188



  if (code != TSDB_CODE_SUCCESS) {




1,812,176✔





4189



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4190



    return code;




×







4191



  }










4192












4193



  int32_t i = pInfo->tableStartIndex + 1;




1,812,176✔





4194



  for (; i < numOfTables; ++i) {




2,935,982✔





4195



    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




1,175,048✔





4196



    if (!tableKeyInfo) {




1,173,980✔





4197



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4198



      return terrno;




×







4199



    }










4200



    if (tableKeyInfo->groupId != pInfo->groupId) {




1,173,980✔





4201



      break;




55,404✔





4202



    }










4203



  }










4204



  pInfo->tableEndIndex = i - 1;




1,816,338✔





4205



  return TSDB_CODE_SUCCESS;




1,861,568✔





4206



}










4207












4208



static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {




1,868,212✔





4209



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,858,550✔





4210



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,991,386✔





4211



    if (pInput->rowIdx == -1) {




2,986,868✔





4212



      continue;




1,501,602✔





4213



    }










4214












4215



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,488,736✔





4216



      pInput->rowIdx = 0;




1,488,380✔





4217



      pInput->pageIdx = -1;




1,489,092✔





4218



    }










4219












4220



    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,488,380✔





4221



    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




1,488,746✔





4222



    if (!col) {




1,487,668✔





4223



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4224



      return terrno;




×







4225



    }










4226



    pInput->aTs = (int64_t*)col->pData;




1,487,668✔





4227



  }










4228












4229



  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;




1,869,596✔





4230



  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);




1,869,932✔





4231



}










4232












4233



static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {




1,850,802✔





4234



  int32_t code = setGroupStartEndIndex(pInfo);




1,850,802✔





4235



  if (code != TSDB_CODE_SUCCESS) {




1,854,202✔





4236



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4237



    return code;




×







4238



  }










4239



  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));




1,854,202✔





4240



  if (pSubTblsInfo == NULL) {




1,843,416✔





4241



    return terrno;




×







4242



  }










4243



  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);




1,843,416✔





4244



  if (!pSubTblsInfo->pTsOrderInfo) {




1,851,820✔





4245



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4246



    return terrno;




×







4247



  }










4248



  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {




1,848,656✔





4249



    pSubTblsInfo->pPkOrderInfo = taosArrayGet(pInfo->pSortInfo, 1);




×







4250



    if (!pSubTblsInfo->pPkOrderInfo) {




×







4251



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4252



      return terrno;




×







4253



    }










4254



  } else {










4255



    pSubTblsInfo->pPkOrderInfo = NULL;




1,827,154✔





4256



  }










4257



  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




1,859,848✔





4258



  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));




1,821,222✔





4259



  if (pSubTblsInfo->aInputs == NULL) {




1,819,888✔





4260



    taosMemoryFree(pSubTblsInfo);




×







4261



    return terrno;




×







4262



  }










4263



  int32_t bufPageSize = pInfo->bufPageSize;




1,824,406✔





4264



  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;




1,847,352✔





4265



  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);




1,850,526✔





4266



  if (code != TSDB_CODE_SUCCESS) {




1,828,222✔





4267



    taosMemoryFree(pSubTblsInfo->aInputs);




×







4268



    taosMemoryFree(pSubTblsInfo);




×







4269



    return code;




×







4270



  }










4271



  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;




1,828,222✔





4272



  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;




1,855,666✔





4273












4274



  pInfo->pSubTablesMergeInfo = pSubTblsInfo;




1,848,310✔





4275



  return TSDB_CODE_SUCCESS;




1,836,606✔





4276



}










4277












4278



static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {




1,847,312✔





4279



  int32_t        code = TSDB_CODE_SUCCESS;




1,847,312✔





4280



  int32_t        lino = 0;




1,847,312✔





4281



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,847,312✔





4282



  SReadHandle*   pHandle = &pInfo->base.readHandle;




1,849,092✔





4283



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,852,868✔





4284












4285



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




1,862,310✔





4286












4287



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,821,634✔





4288



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,980,610✔





4289



    pInput->type = SUB_TABLE_MEM_BLOCK;




2,966,008✔





4290












4291



    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);




2,976,458✔





4292



    QUERY_CHECK_CODE(code, lino, _end);




2,951,782✔





4293












4294



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);




2,951,782✔





4295



    QUERY_CHECK_CODE(code, lino, _end);




2,991,050✔





4296












4297



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);




2,991,050✔





4298



    QUERY_CHECK_CODE(code, lino, _end);




2,992,780✔





4299












4300



    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);




2,992,780✔





4301



    pInput->pKeyInfo = keyInfo;




2,991,396✔





4302












4303



    if (isTaskKilled(pTaskInfo)) {




2,987,540✔





4304



      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);




×







4305



    }










4306












4307



    if (i + 1 < pSubTblsInfo->numInMemReaders) {




2,979,532✔





4308



      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,




2,241,780✔





4309



                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




1,122,136✔





4310



      QUERY_CHECK_CODE(code, lino, _end);




1,121,068✔





4311



      pInput->bInMemReader = true;




1,121,068✔





4312



    } else {










4313



      pInput->pReader = NULL;




1,867,510✔





4314



      pInput->bInMemReader = false;




1,866,818✔





4315



    }










4316



    bool hasNext = true;




2,988,934✔





4317



    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);




2,989,260✔





4318



    QUERY_CHECK_CODE(code, lino, _end);




2,991,040✔





4319



    if (!hasNext) {




2,991,040✔





4320



      pInput->rowIdx = -1;




1,501,948✔





4321



      ++pSubTblsInfo->numSubTablesCompleted;




1,501,256✔





4322



      continue;




1,502,304✔





4323



    } else {










4324



      pInput->rowIdx = 0;




1,489,092✔





4325



      pInput->pageIdx = -1;




1,489,092✔





4326



    }










4327



  }










4328












4329



_end:




1,869,942✔





4330



  if (code != TSDB_CODE_SUCCESS) {




1,868,894✔





4331



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4332



  }










4333



  return code;




1,865,098✔





4334



}










4335












4336



static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




1,489,092✔





4337



  int32_t              code = TSDB_CODE_SUCCESS;




1,489,092✔





4338



  int32_t              lino = 0;




1,489,092✔





4339



  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;




1,489,092✔





4340



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




1,489,092✔





4341



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




1,489,092✔





4342



  bool                 hasNext = true;




1,489,092✔





4343



  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);




1,489,092✔





4344



  QUERY_CHECK_CODE(code, lino, _end);




1,489,092✔





4345












4346



  if (!hasNext) {




1,489,092✔





4347



    pInput->rowIdx = -1;




1,489,092✔





4348



    ++pSubTblsInfo->numSubTablesCompleted;




1,489,092✔





4349



  } else {










4350



    pInput->rowIdx = 0;




×







4351



  }










4352












4353



_end:




1,489,092✔





4354



  if (code != TSDB_CODE_SUCCESS) {




1,489,092✔





4355



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4356



    pTaskInfo->code = code;




×







4357



    T_LONG_JMP(pTaskInfo->env, code);




×







4358



  }










4359



}




1,489,092✔





4360












4361



static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




271,051,862✔





4362



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




271,051,862✔





4363



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




271,052,208✔





4364












4365



  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




271,052,148✔





4366



  if (pInput->rowIdx < pInputBlock->info.rows - 1) {




271,102,356✔





4367



    ++pInput->rowIdx;




269,610,872✔





4368



  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {




1,489,092✔





4369



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,489,092✔





4370



      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);




1,489,092✔





4371



    }










4372



    if (pInput->rowIdx != -1) {




1,489,092✔





4373



      SColumnInfoData* col = taosArrayGet(pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




×







4374



      if (!col) {




×







4375



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4376



        return terrno;




×







4377



      }










4378



      pInput->pInputBlock = pInputBlock;




×







4379



      pInput->aTs = (int64_t*)col->pData;




×







4380



    }










4381



  }










4382












4383



  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));




271,098,214✔





4384



}










4385












4386



static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {




270,916,476✔





4387



  int32_t            code = TSDB_CODE_SUCCESS;




270,916,476✔





4388



  int32_t            lino = 0;




270,916,476✔





4389



  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




270,916,476✔





4390



  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




270,981,182✔





4391












4392



  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {




1,124,625,632✔





4393



    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);




852,810,274✔





4394



    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);




852,845,730✔





4395












4396



    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);




852,845,730✔





4397



    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);




851,837,014✔





4398



    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);




851,837,014✔





4399












4400



    if (isNull) {




852,406,694✔





4401



      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);




103,417,348✔





4402



      QUERY_CHECK_CODE(code, lino, _end);




103,424,188✔





4403



    } else {










4404



      if (pSrcColInfo->pData != NULL) {




748,989,346✔





4405



        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);




749,282,898✔





4406



        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);




750,420,078✔





4407



        QUERY_CHECK_CODE(code, lino, _end);




750,273,048✔





4408



      }










4409



    }










4410



  }










4411



  pBlock->info.dataLoad = 1;




271,052,248✔





4412



  pBlock->info.scanFlag = pInputBlock->info.scanFlag;




271,058,822✔





4413



  pBlock->info.rows += 1;




271,059,188✔





4414












4415



_end:




271,058,140✔





4416



  if (code != TSDB_CODE_SUCCESS) {




271,058,140✔





4417



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4418



  }










4419



  return code;




271,052,910✔





4420



}










4421












4422



static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,




3,025,490✔





4423



                                       SSDataBlock** pResBlock) {










4424



  int32_t                 code = TSDB_CODE_SUCCESS;




3,025,490✔





4425



  int32_t                 lino = 0;




3,025,490✔





4426



  STableMergeScanInfo*    pInfo = pOperator->info;




3,025,490✔





4427



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




3,026,172✔





4428



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




3,025,134✔





4429



  bool                    finished = false;




3,025,490✔





4430












4431



  QRY_PARAM_CHECK(pResBlock);




3,025,490✔





4432












4433



  blockDataCleanup(pBlock);




3,019,924✔





4434












4435



  while (true) {




×







4436



    while (true) {










4437



      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {




273,955,866✔





4438



        finished = true;




3,026,182✔





4439



        break;




3,026,182✔





4440



      }










4441












4442



      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);




270,924,178✔





4443



      QUERY_CHECK_CODE(code, lino, _end);




271,053,246✔





4444












4445



      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);




271,053,246✔





4446



      QUERY_CHECK_CODE(code, lino, _end);




270,933,600✔





4447












4448



      if (pBlock->info.rows >= capacity) {




270,933,600✔





4449



        break;




×







4450



      }










4451



    }










4452












4453



    if (isTaskKilled(pTaskInfo)) {




3,026,182✔





4454



      return pTaskInfo->code;




×







4455



    }










4456












4457



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);




3,025,490✔





4458



    if (finished || limitReached || pBlock->info.rows > 0) {




3,025,490✔





4459



      break;










4460



    }










4461



  }










4462












4463



  if (pBlock->info.rows > 0) {




3,025,490✔





4464



    *pResBlock = pBlock;




1,156,932✔





4465



  }










4466












4467



_end:




1,868,212✔





4468



  if (code != TSDB_CODE_SUCCESS) {




3,025,144✔





4469



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4470



    pTaskInfo->code = code;




×







4471



  }










4472



  return code;




3,025,490✔





4473



}










4474












4475



static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {




1,850,456✔





4476



  int32_t              code = TSDB_CODE_SUCCESS;




1,850,456✔





4477



  int32_t              lino = 0;




1,850,456✔





4478



  STableMergeScanInfo* pInfo = pOperator->info;




1,850,456✔





4479












4480



  code = initSubTablesMergeInfo(pInfo);




1,857,456✔





4481



  QUERY_CHECK_CODE(code, lino, _end);




1,830,338✔





4482












4483



  code = initSubTableInputs(pOperator, pInfo);




1,830,338✔





4484



  QUERY_CHECK_CODE(code, lino, _end);




1,867,174✔





4485












4486



  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);




1,867,174✔





4487



  QUERY_CHECK_CODE(code, lino, _end);




1,866,472✔





4488












4489



_end:




1,866,472✔





4490



  if (code != TSDB_CODE_SUCCESS) {




1,866,472✔





4491



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4492



  }










4493



  return code;




1,867,500✔





4494



}










4495












4496



static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {




30,661,241✔





4497



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




30,661,241✔





4498



  if (pSubTblsInfo != NULL) {




30,672,229✔





4499



    tMergeTreeDestroy(&pSubTblsInfo->pTree);




1,868,212✔





4500












4501



    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,858,570✔





4502



      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




2,992,088✔





4503



      taosMemoryFree(pInput->tblCond.colList);




2,987,244✔





4504



      blockDataDestroy(pInput->pReaderBlock);




2,989,320✔





4505



      blockDataDestroy(pInput->pPageBlock);




2,991,396✔





4506



      taosArrayDestroy(pInput->aBlockPages);




2,990,348✔





4507



      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);




2,991,386✔





4508



      pInput->pReader = NULL;




2,990,704✔





4509



    }










4510












4511



    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);




1,869,250✔





4512



    taosMemoryFree(pSubTblsInfo->aInputs);




1,865,088✔





4513












4514



    taosMemoryFree(pSubTblsInfo);




1,864,742✔





4515



    pInfo->pSubTablesMergeInfo = NULL;




1,866,828✔





4516












4517



    // taosMemoryTrim(0);










4518



  }










4519



}




30,670,499✔





4520












4521



int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




3,000,340✔





4522



  QRY_PARAM_CHECK(ppRes);




3,000,340✔





4523












4524



  int32_t lino = 0;




3,002,762✔





4525



  int32_t tableListSize = 0;




3,002,762✔





4526



  int64_t st = taosGetTimestampUs();




2,988,506✔





4527












4528



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




2,988,506✔





4529



  STableMergeScanInfo* pInfo = pOperator->info;




2,998,916✔





4530












4531



  if (pOperator->status == OP_EXEC_DONE) {




3,009,060✔





4532



    return TSDB_CODE_SUCCESS;




×







4533



  }










4534












4535



  int32_t code = pOperator->fpSet._openFn(pOperator);




2,970,790✔





4536



  QUERY_CHECK_CODE(code, lino, _end);




2,996,514✔





4537












4538



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




2,996,514✔





4539



  QUERY_CHECK_CODE(code, lino, _end);




2,999,658✔





4540












4541



  if (!pInfo->hasGroupId) {




2,999,658✔





4542



    pInfo->hasGroupId = true;




1,841,322✔





4543












4544



    if (tableListSize == 0) {




1,828,826✔





4545



      setOperatorCompleted(pOperator);




46,992✔





4546



      (*ppRes) = NULL;




46,992✔





4547



      return code;




46,992✔





4548



    }










4549












4550



    pInfo->tableStartIndex = 0;




1,781,834✔





4551



    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,766,866✔





4552



    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




1,773,114✔





4553



    pInfo->groupId = pTmpGpId->groupId;




1,773,114✔





4554



    code = startSubTablesTableMergeScan(pOperator);




1,797,514✔





4555



    QUERY_CHECK_CODE(code, lino, _end);




1,811,750✔





4556



  }










4557












4558



  SSDataBlock* pBlock = NULL;




2,971,124✔





4559



  while (pInfo->tableStartIndex < tableListSize) {




3,025,134✔





4560



    if (isTaskKilled(pTaskInfo)) {




3,025,144✔





4561



      break;




×







4562



    }










4563












4564



    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);




3,024,106✔





4565



    QUERY_CHECK_CODE(code, lino, _end);




3,025,836✔





4566












4567



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




3,025,836✔





4568



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




×







4569



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




×







4570












4571



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




×







4572



    }










4573












4574



    if (pBlock != NULL) {




3,025,490✔





4575



      pBlock->info.id.groupId = pInfo->groupId;




1,156,932✔





4576



      pOperator->resultInfo.totalRows += pBlock->info.rows;




1,156,932✔





4577



      pInfo->bGroupProcessed = true;




1,156,932✔





4578



      break;




1,156,932✔





4579



    } else {










4580



      // Data of this group are all dumped, let's try the next group










4581



      stopSubTablesTableMergeScan(pInfo);




1,868,558✔





4582



      if (pInfo->tableEndIndex >= tableListSize - 1) {




1,866,818✔





4583



        setOperatorCompleted(pOperator);




1,810,712✔





4584



        break;




1,809,674✔





4585



      }










4586












4587



      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




55,760✔





4588



      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




55,760✔





4589



      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




55,760✔





4590












4591



      pInfo->groupId = pTmpGpId->groupId;




55,760✔





4592



      code = startSubTablesTableMergeScan(pOperator);




55,760✔





4593



      QUERY_CHECK_CODE(code, lino, _end);




55,760✔





4594



      resetLimitInfoForNextGroup(&pInfo->limitInfo);




55,760✔





4595



    }










4596



  }










4597












4598



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




2,967,298✔





4599












4600



_end:




2,965,568✔





4601



  if (code != TSDB_CODE_SUCCESS) {




2,966,606✔





4602



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4603



    pTaskInfo->code = code;




×







4604



    T_LONG_JMP(pTaskInfo->env, code);




×







4605



  } else {










4606



    (*ppRes) = pBlock;




2,966,606✔





4607



  }










4608












4609



  return code;




2,966,260✔





4610



}










4611












4612



static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {




3,464,306✔





4613



  int32_t              code = TSDB_CODE_SUCCESS;




3,464,306✔





4614



  int32_t              lino = 0;




3,464,306✔





4615



  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;




3,464,306✔





4616



  STableMergeScanInfo* pInfo = pOperator->info;




3,464,306✔





4617



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,469,103✔





4618












4619



  if (pInfo->mSkipTables == NULL) {




3,469,103✔





4620



    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,




292,545✔





4621



                                      taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);










4622



    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);




292,545✔





4623



  }










4624



  int bSkip = 1;




3,469,103✔





4625



  if (pInfo->mSkipTables != NULL) {




3,469,103✔





4626



    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));




3,469,103✔





4627



    if (code == TSDB_CODE_DUP_KEY) {




3,469,103✔





4628



      code = TSDB_CODE_SUCCESS;




×







4629



    }










4630



    QUERY_CHECK_CODE(code, lino, _end);




3,469,103✔





4631



  }










4632












4633



_end:




3,469,103✔





4634



  if (code != TSDB_CODE_SUCCESS) {




3,469,103✔





4635



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4636



    pTaskInfo->code = code;




×







4637



    T_LONG_JMP(pTaskInfo->env, code);




×







4638



  }










4639



}




3,469,103✔





4640












4641



static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {




169,025,242✔





4642



  STableMergeScanInfo* pInfo = pOperator->info;




169,025,242✔





4643



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




169,047,554✔





4644



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




169,018,792✔





4645



  SSDataBlock*         pBlock = pInfo->pReaderBlock;




169,033,445✔





4646



  int32_t              code = 0;




169,017,966✔





4647



  bool                 hasNext = false;




169,017,966✔





4648



  STsdbReader*         reader = pInfo->base.dataReader;




169,007,530✔





4649












4650



  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);




169,003,664✔





4651



  if (code != 0) {




168,976,416✔





4652



    pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4653



    qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo));




×







4654



    pTaskInfo->code = code;




×







4655



    return code;




×







4656



  }










4657












4658



  if (!hasNext || isTaskKilled(pTaskInfo)) {




168,976,416✔





4659



    if (isTaskKilled(pTaskInfo)) {




29,594,168✔





4660



      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));




591✔





4661



      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




591✔





4662



    }










4663



    *pFinished = true;




29,596,464✔





4664



    return code;




29,594,167✔





4665



  }










4666












4667



  uint32_t status = 0;




139,409,031✔





4668



  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);




139,414,453✔





4669












4670



  if (code != TSDB_CODE_SUCCESS) {




139,415,971✔





4671



    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));




49,338✔





4672



    pTaskInfo->code = code;




45,471✔





4673



    return code;




45,471✔





4674



  }










4675












4676



  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




139,366,633✔





4677



    *pFinished = true;




×







4678



    return code;




×







4679



  }










4680












4681



  // current block is filter out according to filter condition, continue load the next block










4682



  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {




139,366,633✔





4683



    *pSkipped = true;




7,111,623✔





4684



    return code;




7,144,987✔





4685



  }










4686












4687



  return code;




132,235,314✔





4688



}










4689












4690



static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {




173,843,744✔





4691



  STableMergeScanSortSourceParam* source = param;




173,843,744✔





4692












4693



  SOperatorInfo*       pOperator = source->pOperator;




173,843,744✔





4694



  STableMergeScanInfo* pInfo = pOperator->info;




173,846,489✔





4695



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




173,843,616✔





4696



  SSDataBlock*         pBlock = NULL;




173,818,869✔





4697



  int64_t              st = taosGetTimestampUs();




173,839,401✔





4698



  int32_t              code = TSDB_CODE_SUCCESS;




173,839,401✔





4699












4700



  while (true) {










4701



    if (pInfo->rtnNextDurationBlocks) {




191,474,956✔





4702



      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",




22,448,461✔





4703



             GET_TASKID(pTaskInfo), pInfo->nextDurationBlocksIdx, pInfo->numNextDurationBlocks);










4704












4705



      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {




22,452,371✔





4706



        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];




10,487,918✔





4707



        ++pInfo->nextDurationBlocksIdx;




10,487,918✔





4708



      } else {










4709



        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




22,451,625✔





4710



          blockDataDestroy(pInfo->nextDurationBlocks[i]);




10,486,886✔





4711



          pInfo->nextDurationBlocks[i] = NULL;




10,486,528✔





4712



        }










4713












4714



        pInfo->rtnNextDurationBlocks = false;




11,964,739✔





4715



        pInfo->nextDurationBlocksIdx = 0;




11,964,739✔





4716



        pInfo->numNextDurationBlocks = 0;




11,964,381✔





4717



        continue;




11,964,739✔





4718



      }










4719



    } else {










4720



      bool bFinished = false;




169,031,430✔





4721



      bool bSkipped = false;




169,023,492✔





4722












4723



      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);




169,051,181✔





4724



      if (code != 0) {




169,002,016✔





4725



        return code;




45,471✔





4726



      }










4727












4728



      pBlock = pInfo->pReaderBlock;




168,956,545✔





4729



      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",




168,971,895✔





4730



             GET_TASKID(pTaskInfo), bFinished, bSkipped, pInfo->bNextDurationBlockEvent, pInfo->bNewFilesetEvent);










4731



      if (bFinished) {




168,998,791✔





4732



        pInfo->bNewFilesetEvent = false;




29,603,312✔





4733



        break;




29,591,010✔





4734



      }










4735












4736



      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {




139,395,479✔





4737



        if (!bSkipped) {




11,969,305✔





4738



          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);




10,487,350✔





4739



          if (code) {




10,487,521✔





4740



            *ppBlock = NULL;




×







4741



            return code;




×







4742



          }










4743












4744



          ++pInfo->numNextDurationBlocks;




10,487,521✔





4745



          if (pInfo->numNextDurationBlocks > 2) {




10,487,350✔





4746



            qError("%s table merge scan prefetch %d next duration blocks. end early.", GET_TASKID(pTaskInfo),




×







4747



                   pInfo->numNextDurationBlocks);










4748



            pInfo->bNewFilesetEvent = false;




×







4749



            break;




×







4750



          }










4751



        }










4752












4753



        if (pInfo->bNewFilesetEvent) {




11,969,305✔





4754



          pInfo->rtnNextDurationBlocks = true;




11,965,203✔





4755



          *ppBlock = NULL;




11,965,203✔





4756



          return code;




11,963,288✔





4757



        }










4758












4759



        if (pInfo->bNextDurationBlockEvent) {




×







4760



          pInfo->bNextDurationBlockEvent = false;




×







4761



          continue;




31,059✔





4762



        }










4763



      }










4764



      if (bSkipped) continue;




127,429,322✔





4765



    }










4766












4767



    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);




132,249,442✔





4768












4769



    pOperator->resultInfo.totalRows += pBlock->info.rows;




132,257,139✔





4770



    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;




132,255,758✔





4771



    *ppBlock = pBlock;




132,257,968✔





4772












4773



    return code;




132,258,630✔





4774



  }










4775












4776



  *ppBlock = NULL;




29,596,433✔





4777



  return code;




29,604,321✔





4778



}










4779












4780



int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {




26,309,703✔





4781



  int32_t code = TSDB_CODE_SUCCESS;




26,309,703✔





4782



  int32_t lino = 0;




26,309,703✔





4783



  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));




26,309,703✔





4784



  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);




26,253,981✔





4785



  SBlockOrderInfo biTs = {0};




26,263,974✔





4786



  SBlockOrderInfo biPk = {0};




26,262,255✔





4787












4788



  int32_t tsTargetSlotId = 0;




26,246,835✔





4789



  int32_t pkTargetSlotId = -1;




26,246,835✔





4790



  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {




106,819,020✔





4791



    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);




80,692,104✔





4792



    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);




80,704,487✔





4793



    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




80,697,815✔





4794



      tsTargetSlotId = colInfo->dstSlotId;




26,306,447✔





4795



      biTs.order = order;




26,314,202✔





4796



      biTs.slotId = tsTargetSlotId;




26,314,202✔





4797



      biTs.nullFirst = (order == TSDB_ORDER_ASC);




26,314,202✔





4798



      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);




26,314,202✔





4799



    }










4800



    // TODO: order by just ts










4801



    if (colInfo->isPk) {




80,660,843✔





4802



      pkTargetSlotId = colInfo->dstSlotId;




2,655,182✔





4803



      biPk.order = order;




2,655,182✔





4804



      biPk.slotId = pkTargetSlotId;




2,655,182✔





4805



      biPk.nullFirst = (order == TSDB_ORDER_ASC);




2,655,182✔





4806



      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);




2,655,182✔





4807



    }










4808



  }










4809












4810



  void* tmp = taosArrayPush(pSortInfo, &biTs);




26,318,929✔





4811



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




26,318,929✔





4812



  if (pkTargetSlotId != -1) {




26,318,929✔





4813



    tmp = taosArrayPush(pSortInfo, &biPk);




2,655,155✔





4814



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




2,655,155✔





4815



  }










4816












4817



  (*ppSortArray) = pSortInfo;




26,319,548✔





4818












4819



_end:




26,284,000✔





4820



  if (code != TSDB_CODE_SUCCESS) {




26,284,008✔





4821



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4822



  }










4823



  return code;




26,278,059✔





4824



}










4825












4826



void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {




39,711,068✔





4827



  STableMergeScanInfo* pTmsInfo = param;




39,711,068✔





4828



  if (type == TSD_READER_NOTIFY_DURATION_START) {




39,711,068✔





4829



    pTmsInfo->bNewFilesetEvent = true;




39,725,332✔





4830



  } else if (type == TSD_READER_NOTIFY_NEXT_DURATION_BLOCK) {




×







4831



    pTmsInfo->bNextDurationBlockEvent = true;




×







4832



  }










4833



  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);




39,716,241✔





4834












4835



  return;




39,740,660✔





4836



}










4837












4838



int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




41,752,665✔





4839



  STableMergeScanInfo* pInfo = pOperator->info;




41,752,665✔





4840



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




41,786,738✔





4841












4842



  int32_t code = TSDB_CODE_SUCCESS;




41,765,682✔





4843



  int32_t lino = 0;




41,765,682✔





4844



  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




41,765,682✔





4845












4846



  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));




41,718,419✔





4847



  pInfo->bNewFilesetEvent = false;




41,768,668✔





4848



  pInfo->bNextDurationBlockEvent = false;




41,806,378✔





4849












4850



  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;




41,800,628✔





4851



  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;




41,799,608✔





4852












4853



  pInfo->pSortHandle = NULL;




41,786,656✔





4854



  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,




81,847,519✔





4855



                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);




41,760,720✔





4856



  if (code) {




41,734,287✔





4857



    return code;




×







4858



  }










4859












4860



  if (pInfo->bSortRowId && numOfTable != 1) {




41,734,287✔





4861



    int32_t memSize = 512 * 1024 * 1024;




3,836,158✔





4862



    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);




3,836,158✔





4863



    QUERY_CHECK_CODE(code, lino, _end);




3,838,882✔





4864



  }










4865












4866



  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);




41,747,157✔





4867



  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);




41,743,754✔





4868



  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);




41,715,045✔





4869












4870



  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);




41,688,973✔





4871



  QUERY_CHECK_CODE(code, lino, _end);




41,749,683✔





4872












4873



  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));




41,749,683✔





4874



  QUERY_CHECK_NULL(param, code, lino, _end, terrno);




41,712,014✔





4875



  param->pOperator = pOperator;




41,712,014✔





4876












4877



  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));




41,748,594✔





4878



  if (ps == NULL) {




41,706,701✔





4879



    taosMemoryFree(param);




×







4880



    QUERY_CHECK_NULL(ps, code, lino, _end, terrno);




×







4881



  }










4882












4883



  ps->param = param;




41,706,701✔





4884



  ps->onlyRef = false;




41,750,261✔





4885



  code = tsortAddSource(pInfo->pSortHandle, ps);




41,779,884✔





4886



  QUERY_CHECK_CODE(code, lino, _end);




41,765,790✔





4887












4888



  if (numOfTable == 1) {




41,765,790✔





4889



    tsortSetSingleTableMerge(pInfo->pSortHandle);




28,815,333✔





4890



  } else {










4891



    code = tsortOpen(pInfo->pSortHandle);




12,950,457✔





4892



    QUERY_CHECK_CODE(code, lino, _end);




12,987,736✔





4893



  }










4894












4895



_end:




12,964,702✔





4896



  if (code != TSDB_CODE_SUCCESS) {




41,800,306✔





4897



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




23,034✔





4898



  }










4899



  return code;




41,804,764✔





4900



}










4901












4902



void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




41,786,425✔





4903



  STableMergeScanInfo* pInfo = pOperator->info;




41,786,425✔





4904



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




41,783,490✔





4905



  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));




41,782,481✔





4906












4907



  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);




41,782,348✔





4908



  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;




41,777,011✔





4909



  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;




41,775,039✔





4910



  pInfo->sortExecInfo.loops += sortExecInfo.loops;




41,776,942✔





4911



  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;




41,780,416✔





4912



  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;




41,778,444✔





4913












4914



  tsortDestroySortHandle(pInfo->pSortHandle);




41,784,383✔





4915



  pInfo->pSortHandle = NULL;




41,779,123✔





4916



}




41,779,458✔





4917












4918



void startGroupTableMergeScan(SOperatorInfo* pOperator) {




29,802,221✔





4919



  int32_t              code = TSDB_CODE_SUCCESS;




29,802,221✔





4920



  int32_t              lino = 0;




29,802,221✔





4921



  STableMergeScanInfo* pInfo = pOperator->info;




29,802,221✔





4922



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




29,801,058✔





4923



  SReadHandle*         pHandle = &pInfo->base.readHandle;




29,777,267✔





4924



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




29,738,618✔





4925



  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




29,800,157✔





4926












4927



  {










4928



    int32_t numOfTables = 0;




29,807,727✔





4929



    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




29,764,142✔





4930



    QUERY_CHECK_CODE(code, lino, _end);




29,793,687✔





4931












4932



    int32_t i = pInfo->tableStartIndex + 1;




29,793,687✔





4933



    for (; i < numOfTables; ++i) {




135,047,355✔





4934



      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




111,398,135✔





4935



      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);




111,396,509✔





4936



      if (tableKeyInfo->groupId != pInfo->groupId) {




111,396,590✔





4937



        break;




6,141,974✔





4938



      }










4939



    }










4940



    pInfo->tableEndIndex = i - 1;




29,791,194✔





4941



  }










4942



  pInfo->bGroupProcessed = false;




29,827,073✔





4943



  int32_t tableStartIdx = pInfo->tableStartIndex;




29,827,555✔





4944



  int32_t tableEndIdx = pInfo->tableEndIndex;




29,815,437✔





4945












4946



  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;




29,833,985✔





4947



  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);




29,833,985✔





4948



  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,




57,890,208✔





4949



                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);




29,827,036✔





4950



  QUERY_CHECK_CODE(code, lino, _end);




29,812,060✔





4951



  if (pInfo->filesetDelimited) {




29,812,060✔





4952



    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);




29,821,296✔





4953



  }










4954



  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);




29,821,608✔





4955












4956



  code = startDurationForGroupTableMergeScan(pOperator);




29,753,968✔





4957



  QUERY_CHECK_CODE(code, lino, _end);




29,813,525✔





4958












4959



_end:




29,790,491✔





4960



  if (code != TSDB_CODE_SUCCESS) {




29,814,993✔





4961



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




23,034✔





4962



    pTaskInfo->code = code;




23,034✔





4963



    T_LONG_JMP(pTaskInfo->env, code);




23,034✔





4964



  }










4965



}




29,791,959✔





4966












4967



void stopGroupTableMergeScan(SOperatorInfo* pOperator) {




29,820,883✔





4968



  STableMergeScanInfo* pInfo = pOperator->info;




29,820,883✔





4969



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




29,822,901✔





4970



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




29,818,957✔





4971












4972



  stopDurationForGroupTableMergeScan(pOperator);




29,819,585✔





4973












4974



  if (pInfo->base.dataReader != NULL) {




29,813,308✔





4975



    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);




29,815,348✔





4976



    pInfo->base.dataReader = NULL;




29,791,363✔





4977



  }










4978



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




29,795,806✔





4979



    if (pInfo->nextDurationBlocks[i]) {




1,032✔





4980



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




1,032✔





4981



      pInfo->nextDurationBlocks[i] = NULL;




1,032✔





4982



    }










4983



    pInfo->numNextDurationBlocks = 0;




1,032✔





4984



    pInfo->nextDurationBlocksIdx = 0;




1,032✔





4985



  }










4986



  resetLimitInfoForNextGroup(&pInfo->limitInfo);




29,801,348✔





4987



  taosHashCleanup(pInfo->mSkipTables);




29,765,458✔





4988



  pInfo->mSkipTables = NULL;




29,777,848✔





4989



  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




29,784,222✔





4990



}




29,810,853✔





4991












4992



// all data produced by this function only belongs to one group










4993



// slimit/soffset does not need to be concerned here, since this function only deal with data within one group.










4994



SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,




81,869,601✔





4995



                                              SOperatorInfo* pOperator) {










4996



  STableMergeScanInfo* pInfo = pOperator->info;




81,869,601✔





4997



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




81,882,928✔





4998



  STupleHandle*        pTupleHandle = NULL;




81,872,003✔





4999












5000



  blockDataCleanup(pResBlock);




81,887,034✔





5001












5002



  while (1) {




×







5003



    while (1) {




2,147,483,647✔





5004



      pTupleHandle = NULL;




2,147,483,647✔





5005



      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);




2,147,483,647✔





5006



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5007



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




7,069,594✔





5008



        T_LONG_JMP(pOperator->pTaskInfo->env, code);




7,069,594✔





5009



      }










5010



      if (pTupleHandle == NULL) {




2,147,483,647✔





5011



        break;




69,125,114✔





5012



      }










5013












5014



      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);




2,147,483,647✔





5015



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5016



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







5017



        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5018



      }










5019












5020



      if (pResBlock->info.rows >= capacity) {




2,147,483,647✔





5021



        break;




12,752,224✔





5022



      }










5023



    }










5024












5025



    if (tsortIsClosed(pHandle)) {




81,877,338✔





5026



      terrno = TSDB_CODE_TSC_QUERY_CANCELLED;




×







5027



      T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5028



    }










5029












5030



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);




81,881,635✔





5031



    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,




81,880,151✔





5032



           pInfo->limitInfo.numOfOutputRows);










5033



    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {




81,882,356✔





5034



      break;










5035



    }










5036



  }










5037



  return (pResBlock->info.rows > 0) ? pResBlock : NULL;




81,882,356✔





5038



}










5039












5040



int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




67,022,087✔





5041



  if (pOperator->status == OP_EXEC_DONE) {




67,022,087✔





5042



    (*ppRes) = NULL;




41,553✔





5043



    return TSDB_CODE_SUCCESS;




41,553✔





5044



  }










5045












5046



  int32_t              code = TSDB_CODE_SUCCESS;




66,960,586✔





5047



  int32_t              lino = 0;




66,960,586✔





5048



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




66,960,586✔





5049



  STableMergeScanInfo* pInfo = pOperator->info;




66,990,134✔





5050












5051



  code = pOperator->fpSet._openFn(pOperator);




66,969,313✔





5052



  QUERY_CHECK_CODE(code, lino, _end);




66,902,344✔





5053












5054



  int64_t st = taosGetTimestampUs();




66,988,008✔





5055












5056



  int32_t tableListSize = 0;




66,988,008✔





5057



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




66,974,036✔





5058



  QUERY_CHECK_CODE(code, lino, _end);




66,966,791✔





5059












5060



  if (!pInfo->hasGroupId) {




66,966,791✔





5061



    pInfo->hasGroupId = true;




26,874,899✔





5062












5063



    if (tableListSize == 0) {




26,818,746✔





5064



      setOperatorCompleted(pOperator);




3,216,135✔





5065



      (*ppRes) = NULL;




3,215,977✔





5066



      return code;




3,216,347✔





5067



    }










5068



    pInfo->tableStartIndex = 0;




23,602,611✔





5069



    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




23,670,426✔





5070



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




23,626,838✔





5071



    pInfo->groupId = tmp->groupId;




23,626,838✔





5072



    startGroupTableMergeScan(pOperator);




23,662,908✔





5073



  }










5074












5075



  SSDataBlock* pBlock = NULL;




63,755,387✔





5076



  while (pInfo->tableStartIndex < tableListSize) {




81,860,437✔





5077



    if (isTaskKilled(pTaskInfo)) {




81,876,840✔





5078



      goto _end;




672✔





5079



    }










5080












5081



    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,




81,880,355✔





5082



                                              pOperator);










5083



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




81,882,141✔





5084



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,795,071✔





5085



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




1,795,071✔





5086



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




1,795,071✔





5087



    }










5088



    if (pBlock != NULL) {




81,878,150✔





5089



      pBlock->info.id.groupId = pInfo->groupId;




40,093,281✔





5090



      pOperator->resultInfo.totalRows += pBlock->info.rows;




40,093,780✔





5091



      pInfo->bGroupProcessed = true;




40,094,296✔





5092



      break;




40,093,582✔





5093



    } else {










5094



      if (pInfo->bNewFilesetEvent) {




41,784,869✔





5095



        stopDurationForGroupTableMergeScan(pOperator);




11,965,771✔





5096



        code = startDurationForGroupTableMergeScan(pOperator);




11,965,771✔





5097



        QUERY_CHECK_CODE(code, lino, _end);




11,962,501✔





5098



      } else {










5099



        // Data of this group are all dumped, let's try the next group










5100



        stopGroupTableMergeScan(pOperator);




29,818,605✔





5101



        if (pInfo->tableEndIndex >= tableListSize - 1) {




29,813,713✔





5102



          setOperatorCompleted(pOperator);




23,670,366✔





5103



          break;




23,673,067✔





5104



        }










5105












5106



        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




6,141,974✔





5107



        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




6,141,974✔





5108



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




6,141,974✔





5109



        pInfo->groupId = tmp->groupId;




6,141,974✔





5110



        startGroupTableMergeScan(pOperator);




6,141,974✔





5111



        resetLimitInfoForNextGroup(&pInfo->limitInfo);




6,141,577✔





5112



      }










5113



    }










5114



  }










5115












5116



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




63,769,453✔





5117












5118



_end:




63,765,243✔





5119



  if (code != TSDB_CODE_SUCCESS) {




63,764,234✔





5120



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5121



    pTaskInfo->code = code;




×







5122



    T_LONG_JMP(pTaskInfo->env, code);




×







5123



  } else {










5124



    (*ppRes) = pBlock;




63,764,234✔





5125



  }










5126












5127



  return code;




63,759,873✔





5128



}










5129












5130



static SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {




×







5131



  SSDataBlock* pRes = NULL;




×







5132



  int32_t      code = doTableMergeScanNext(pOperator, &pRes);




×







5133



  return pRes;




×







5134



}










5135












5136



void destroyTableMergeScanOperatorInfo(void* param) {




26,351,625✔





5137



  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;




26,351,625✔





5138












5139



  // start one reader variable










5140



  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {




26,351,625✔





5141



    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);




26,356,061✔





5142



    pTableScanInfo->base.dataReader = NULL;




26,344,772✔





5143



  }










5144












5145



  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {




26,344,510✔





5146



    if (pTableScanInfo->nextDurationBlocks[i] != NULL) {




×







5147



      blockDataDestroy(pTableScanInfo->nextDurationBlocks[i]);




×







5148



      pTableScanInfo->nextDurationBlocks[i] = NULL;




×







5149



    }










5150



  }










5151












5152



  tsortDestroySortHandle(pTableScanInfo->pSortHandle);




26,347,661✔





5153



  pTableScanInfo->pSortHandle = NULL;




26,342,757✔





5154



  taosHashCleanup(pTableScanInfo->mSkipTables);




26,353,545✔





5155



  pTableScanInfo->mSkipTables = NULL;




26,335,126✔





5156



  blockDataDestroy(pTableScanInfo->pSortInputBlock);




26,337,206✔





5157



  pTableScanInfo->pSortInputBlock = NULL;




26,347,420✔





5158



  // end one reader variable










5159












5160



  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);




26,347,420✔





5161












5162



  blockDataDestroy(pTableScanInfo->pResBlock);




26,350,595✔





5163



  pTableScanInfo->pResBlock = NULL;




26,356,521✔





5164












5165



  // remove it from the task->result list










5166



  blockDataDestroy(pTableScanInfo->pReaderBlock);




26,356,521✔





5167



  pTableScanInfo->pReaderBlock = NULL;




26,351,725✔





5168



  taosArrayDestroy(pTableScanInfo->pSortInfo);




26,357,155✔





5169












5170



  stopSubTablesTableMergeScan(pTableScanInfo);




26,349,338✔





5171












5172



  taosMemoryFreeClear(param);




26,340,738✔





5173



}




26,343,916✔





5174












5175



int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {




2,870,197✔





5176



  if (pOptr == NULL) {




2,870,197✔





5177



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));




×







5178



    return TSDB_CODE_INVALID_PARA;




×







5179



  }










5180



  // TODO: merge these two info into one struct










5181



  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));




2,870,197✔





5182



  if (!execInfo) {




2,871,139✔





5183



    return terrno;




×







5184



  }










5185



  STableMergeScanInfo* pInfo = pOptr->info;




2,871,139✔





5186



  execInfo->blockRecorder = pInfo->base.readRecorder;




2,871,139✔





5187



  execInfo->sortExecInfo = pInfo->sortExecInfo;




2,871,139✔





5188












5189



  *pOptrExplain = execInfo;




2,871,139✔





5190



  *len = sizeof(STableMergeScanExecInfo);




2,871,139✔





5191












5192



  return TSDB_CODE_SUCCESS;




2,870,769✔





5193



}










5194












5195



static int32_t resetTableMergeScanOperatorState(SOperatorInfo* pOper) {




2,444,530✔





5196



  int32_t         code = TSDB_CODE_SUCCESS;




2,444,530✔





5197



  STableMergeScanInfo*   pInfo = pOper->info;




2,444,530✔





5198



  pOper->status = OP_NOT_OPENED;




2,444,530✔





5199












5200



  pInfo->tableEndIndex = 0;




2,444,530✔





5201



  pInfo->tableStartIndex = 0;




2,444,530✔





5202



  pInfo->hasGroupId = false;




2,444,530✔





5203



  if (pInfo->base.readerAPI.tsdReaderClose) {




2,444,530✔





5204



    pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);




2,444,530✔





5205



  }










5206



  pInfo->base.dataReader = NULL;




2,444,530✔





5207



  pInfo->base.scanFlag = MAIN_SCAN;




2,444,530✔





5208












5209



  pInfo->base.limitInfo = (SLimitInfo){0};




2,444,530✔





5210



  pInfo->base.limitInfo.limit.limit = -1;




2,444,530✔





5211



  pInfo->base.limitInfo.slimit.limit = -1;




2,444,530✔





5212












5213



  tableListDestroy(pInfo->base.pTableListInfo);




2,444,530✔





5214



  pInfo->base.pTableListInfo = tableListCreate();




2,444,530✔





5215



  if (!pInfo->base.pTableListInfo) {




2,444,530✔





5216



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







5217



    return terrno;




×







5218



  }










5219



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




2,444,530✔





5220












5221



  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;




2,444,530✔





5222



  code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,




4,889,060✔





5223



                                  &pInfo->base.readHandle, pInfo->base.pTableListInfo, 










5224



                                  pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);




4,889,060✔





5225



  if (code) {




2,444,530✔





5226



    qError("%s failed to createScanTableListInfo, code:%s", __func__, tstrerror(code));




×







5227



    return code;




×







5228



  }










5229












5230



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




2,444,530✔





5231



  cleanupQueryTableDataCond(&pInfo->base.cond);




2,444,530✔





5232



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, false);




2,444,530✔





5233



  if (code) {




2,444,361✔





5234



    qError("%s failed to initQueryTableDataCond, code:%s", __func__, tstrerror(code));




×







5235



    return code;




×







5236



  }










5237












5238



  tsortDestroySortHandle(pInfo->pSortHandle);




2,444,361✔





5239



  pInfo->pSortHandle = NULL;




2,444,361✔





5240












5241



  taosHashCleanup(pInfo->mSkipTables);




2,444,530✔





5242



  pInfo->mSkipTables = NULL;




2,444,361✔





5243



  pOper->resultInfo.totalRows = 0;




2,444,192✔





5244



  










5245



  pInfo->bGroupProcessed = false;




2,444,361✔





5246



  pInfo->bNewFilesetEvent = false;




2,444,280✔





5247



  pInfo->bNextDurationBlockEvent = false;




2,444,192✔





5248



  pInfo->rtnNextDurationBlocks = false;




2,444,361✔





5249



  pInfo->nextDurationBlocksIdx = 0;




2,444,280✔





5250



  pInfo->bSortRowId = false;




2,444,111✔





5251












5252



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




2,444,361✔





5253



    if (pInfo->nextDurationBlocks[i] != NULL) {




×







5254



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




×







5255



      pInfo->nextDurationBlocks[i] = NULL;




×







5256



    }










5257



  }










5258



  pInfo->numNextDurationBlocks = 0;




2,444,111✔





5259












5260



  stopSubTablesTableMergeScan(pInfo);




2,444,530✔





5261



  return code;




2,444,111✔





5262



}










5263












5264



int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




26,271,374✔





5265



                                         STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










5266



                                         SOperatorInfo** pOptrInfo) {










5267



  QRY_PARAM_CHECK(pOptrInfo);




26,271,374✔





5268












5269



  int32_t              code = TSDB_CODE_SUCCESS;




26,296,681✔





5270



  int32_t              lino = 0;




26,296,681✔





5271



  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));




26,296,681✔





5272



  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




26,233,433✔





5273



  if (pInfo == NULL || pOperator == NULL) {




26,165,497✔





5274



    code = terrno;




×







5275



    goto _error;




×







5276



  }










5277












5278



  pOperator->pPhyNode = pTableScanNode;




26,173,066✔





5279



  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;




26,223,078✔





5280












5281



  int32_t numOfCols = 0;




26,223,885✔





5282



  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,




26,230,127✔





5283



                             &pInfo->base.matchInfo);










5284



  QUERY_CHECK_CODE(code, lino, _error);




26,293,795✔





5285












5286



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, false);




26,293,795✔





5287



  QUERY_CHECK_CODE(code, lino, _error);




26,161,350✔





5288












5289



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




26,161,350✔





5290



    SExprSupp* pSup = &pInfo->base.pseudoSup;




10,769,882✔





5291



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);




10,746,655✔





5292



    QUERY_CHECK_CODE(code, lino, _error);




10,772,539✔





5293












5294



    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,




10,772,539✔





5295



                                      &pTaskInfo->storageAPI.functionStore);










5296



    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);




10,712,160✔





5297



  }










5298












5299



  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};




26,121,045✔





5300












5301



  if (tsMetaEntryCache && readHandle->streamRtInfo == NULL) {




26,054,407✔





5302



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(tsMetaEntryCacheSize, -1, .5);




×







5303



    QUERY_CHECK_NULL(pInfo->base.metaCache.pTableMetaEntryCache, code, lino, _error, terrno);




×







5304



  }










5305












5306



  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;




26,054,407✔





5307



  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




26,188,106✔





5308



  pInfo->base.scanFlag = MAIN_SCAN;




26,052,025✔





5309



  pInfo->base.readHandle = *readHandle;




26,110,252✔





5310












5311



  pInfo->readIdx = -1;




26,232,176✔





5312












5313



  pInfo->base.limitInfo.limit.limit = -1;




26,033,449✔





5314



  pInfo->base.limitInfo.slimit.limit = -1;




26,067,204✔





5315



  pInfo->base.pTableListInfo = pTableListInfo;




26,146,332✔





5316












5317



  pInfo->sample.sampleRatio = pTableScanNode->ratio;




26,250,637✔





5318



  pInfo->sample.seed = taosGetTimestampSec();




26,138,987✔





5319












5320



  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,




26,245,589✔





5321



                            pTaskInfo->pStreamRuntimeInfo);




26,219,469✔





5322



  QUERY_CHECK_CODE(code, lino, _error);




26,155,050✔





5323












5324



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




26,155,050✔





5325












5326



  pInfo->mergeLimit = -1;




26,147,347✔





5327



  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;




26,248,571✔





5328



  if (hasLimit) {




26,138,610✔





5329



    pInfo->mergeLimit = pInfo->limitInfo.limit.offset != -1




3,909,717✔





5330



                            ? pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset




869,804✔





5331



                            : pInfo->limitInfo.limit.limit;




2,821,831✔





5332



    pInfo->mSkipTables = NULL;




1,953,472✔





5333



  }










5334












5335



  initResultSizeInfo(&pOperator->resultInfo, 1024);




26,132,306✔





5336



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




26,212,382✔





5337



  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);




26,342,747✔





5338



  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);




26,205,863✔





5339



  QUERY_CHECK_CODE(code, lino, _error);




26,329,177✔





5340



  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {




26,329,177✔





5341



    pInfo->bSortRowId = true;




5,435,214✔





5342



  } else {










5343



    pInfo->bSortRowId = false;




20,868,346✔





5344



  }










5345












5346



  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);




26,288,756✔





5347



  QUERY_CHECK_CODE(code, lino, _error);




26,265,480✔





5348












5349



  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo);




26,265,480✔





5350



  QUERY_CHECK_CODE(code, lino, _error);




26,260,529✔





5351












5352



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);




26,260,529✔





5353



  QUERY_CHECK_CODE(code, lino, _error);




26,281,770✔





5354












5355



  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;




26,281,770✔





5356












5357



  int32_t  rowSize = pInfo->pResBlock->info.rowSize;




26,297,879✔





5358



  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);




26,287,031✔





5359












5360



  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);




26,174,610✔





5361












5362



  // start one reader variable










5363



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);




26,297,468✔





5364



  QUERY_CHECK_CODE(code, lino, _error);




26,308,451✔





5365












5366



  if (!tsExperimental) {




26,308,451✔





5367



    pInfo->filesetDelimited = false;




×







5368



  } else {










5369



    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




26,308,451✔





5370



  }










5371



  // end one reader variable










5372



  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,




26,289,434✔





5373



                  pInfo, pTaskInfo);










5374



  pOperator->exprSupp.numOfExprs = numOfCols;




26,232,763✔





5375












5376



  pOperator->fpSet = createOperatorFpSet(




26,206,054✔





5377



      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,




26,303,304✔





5378



      destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn,










5379



      NULL);










5380



  setOperatorResetStateFn(pOperator, resetTableMergeScanOperatorState);     




26,215,867✔





5381



  pOperator->cost.openCost = 0;




26,276,261✔





5382












5383



  *pOptrInfo = pOperator;




26,298,294✔





5384



  return code;




26,148,280✔





5385












5386



_error:




×







5387



  if (code != TSDB_CODE_SUCCESS) {




×







5388



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5389



  }










5390



  pTaskInfo->code = code;




×







5391



  if (pInfo != NULL) {




×







5392



    pInfo->base.pTableListInfo = NULL;




×







5393



    destroyTableMergeScanOperatorInfo(pInfo);




×







5394



  }










5395



  if (pOperator != NULL) {




×







5396



    pOperator->info = NULL;




×







5397



    destroyOperator(pOperator);




×







5398



  }










5399



  return code;




×







5400



}










5401












5402



// ====================================================================================================================










5403



// TableCountScanOperator










5404



static void        destoryTableCountScanOperator(void* param);










5405



static int32_t     buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5406



                                                  SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI);










5407



static int32_t     buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5408



                                                  SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI);










5409



static int32_t     buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5410



                                             STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName);










5411



static int32_t     buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5412



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName);










5413



static int32_t     buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5414



                                          STableCountScanSupp* pSupp, SSDataBlock* pRes);










5415



static void        buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5416



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5417



                                               size_t perfdbTableNum);










5418



static void        buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,










5419



                                              size_t infodbTableNum, size_t perfdbTableNum);










5420



static const char* GROUP_TAG_DB_NAME = "db_name";










5421



static const char* GROUP_TAG_STABLE_NAME = "stable_name";










5422












5423



int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {




25,930✔





5424



  if (scanCols != NULL) {




25,930✔





5425



    SNode* pNode = NULL;




14,313✔





5426



    FOREACH(pNode, scanCols) {




33,430✔





5427



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




19,117✔





5428



        return TSDB_CODE_QRY_SYS_ERROR;




×







5429



      }










5430



      STargetNode* targetNode = (STargetNode*)pNode;




19,117✔





5431



      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {




19,117✔





5432



        return TSDB_CODE_QRY_SYS_ERROR;




×







5433



      }










5434



      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);




19,117✔





5435



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




19,117✔





5436



        supp->dbNameSlotId = targetNode->slotId;




9,440✔





5437



      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




9,677✔





5438



        supp->stbNameSlotId = targetNode->slotId;




9,677✔





5439



      }










5440



    }










5441



  }










5442



  return TSDB_CODE_SUCCESS;




25,930✔





5443



}










5444












5445



int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {




25,930✔





5446



  if (pseudoCols != NULL) {




25,930✔





5447



    SNode* pNode = NULL;




25,930✔





5448



    FOREACH(pNode, pseudoCols) {




51,860✔





5449



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




25,930✔





5450



        return TSDB_CODE_QRY_SYS_ERROR;




×







5451



      }










5452



      STargetNode* targetNode = (STargetNode*)pNode;




25,930✔





5453



      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {




25,930✔





5454



        return TSDB_CODE_QRY_SYS_ERROR;




×







5455



      }










5456



      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);




25,930✔





5457



      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {




25,930✔





5458



        supp->tbCountSlotId = targetNode->slotId;




25,930✔





5459



      }










5460



    }










5461



  }










5462



  return TSDB_CODE_SUCCESS;




25,930✔





5463



}










5464












5465



int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {




25,930✔





5466



  if (groupTags != NULL) {




25,930✔





5467



    SNode* pNode = NULL;




14,313✔





5468



    FOREACH(pNode, groupTags) {




33,430✔





5469



      if (nodeType(pNode) != QUERY_NODE_COLUMN) {




19,117✔





5470



        return TSDB_CODE_QRY_SYS_ERROR;




×







5471



      }










5472



      SColumnNode* colNode = (SColumnNode*)pNode;




19,117✔





5473



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




19,117✔





5474



        supp->groupByDbName = true;




9,440✔





5475



      }










5476



      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




19,117✔





5477



        supp->groupByStbName = true;




9,677✔





5478



      }










5479



    }










5480



  } else {










5481



    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);




11,617✔





5482



    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);




11,617✔





5483



  }










5484



  return TSDB_CODE_SUCCESS;




25,930✔





5485



}










5486












5487



int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,




25,930✔





5488



                              STableCountScanSupp* supp, SExecTaskInfo* taskInfo) {










5489



  int32_t code = 0;




25,930✔





5490



  code = tblCountScanGetInputs(groupTags, tableName, supp);




25,930✔





5491



  if (code != TSDB_CODE_SUCCESS) {




25,930✔





5492



    qError("%s get table count scan supp. get inputs error", GET_TASKID(taskInfo));




×







5493



    return code;




×







5494



  }










5495












5496



  supp->dbNameSlotId = -1;




25,930✔





5497



  supp->stbNameSlotId = -1;




25,930✔





5498



  supp->tbCountSlotId = -1;




25,930✔





5499












5500



  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);




25,930✔





5501



  if (code != TSDB_CODE_SUCCESS) {




25,930✔





5502



    qError("%s get table count scan supp. get group tags slot id error", GET_TASKID(taskInfo));




×







5503



    return code;




×







5504



  }










5505












5506



  code = tblCountScanGetCountSlotId(pseudoCols, supp);




25,930✔





5507



  if (code != TSDB_CODE_SUCCESS) {




25,930✔





5508



    qError("%s get table count scan supp. get count error", GET_TASKID(taskInfo));




×







5509



    return code;




×







5510



  }










5511



  return code;




25,930✔





5512



}










5513












5514



int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,




25,930✔





5515



                                         SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










5516



  QRY_PARAM_CHECK(pOptrInfo);




25,930✔





5517












5518



  int32_t                      code = TSDB_CODE_SUCCESS;




25,930✔





5519



  int32_t                      lino = 0;




25,930✔





5520



  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;




25,930✔





5521



  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));




25,779✔





5522



  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




25,930✔





5523



  if (!pInfo || !pOperator) {




25,930✔





5524



    code = terrno;




×







5525



    goto _error;




×







5526



  }










5527












5528



  pInfo->readHandle = *readHandle;




25,930✔





5529












5530



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




25,930✔





5531



  initResultSizeInfo(&pOperator->resultInfo, 1);




25,930✔





5532



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




25,930✔





5533



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




25,930✔





5534












5535



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




25,930✔





5536



  QUERY_CHECK_CODE(code, lino, _error);




25,930✔





5537












5538



  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,




25,930✔





5539



                               pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp,










5540



                               pTaskInfo);










5541



  QUERY_CHECK_CODE(code, lino, _error);




25,930✔





5542












5543



  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,




25,930✔





5544



                  pInfo, pTaskInfo);










5545



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,




25,930✔





5546



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










5547



  *pOptrInfo = pOperator;




25,930✔





5548



  return code;




25,930✔





5549












5550



_error:




×







5551



  if (pInfo != NULL) {




×







5552



    destoryTableCountScanOperator(pInfo);




×







5553



  }










5554



  if (pOperator != NULL) {




×







5555



    pOperator->info = NULL;




×







5556



    destroyOperator(pOperator);




×







5557



  }










5558



  pTaskInfo->code = code;




×







5559



  return code;




×







5560



}










5561












5562



int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,




35,703✔





5563



                                    SSDataBlock* pRes) {










5564



  int32_t code = TSDB_CODE_SUCCESS;




35,703✔





5565



  int32_t lino = 0;




35,703✔





5566



  if (pSupp->dbNameSlotId != -1) {




35,703✔





5567



    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




14,240✔





5568



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);




14,240✔





5569



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




14,240✔





5570












5571



    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




14,240✔





5572



    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);




14,240✔





5573












5574



    varDataSetLen(varDbName, strlen(dbName));




14,240✔





5575



    code = colDataSetVal(colInfoData, 0, varDbName, false);




14,240✔





5576



    QUERY_CHECK_CODE(code, lino, _end);




14,240✔





5577



  }










5578












5579



  if (pSupp->stbNameSlotId != -1) {




35,703✔





5580



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);




18,504✔





5581



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




18,504✔





5582



    if (strlen(stbName) != 0) {




18,504✔





5583



      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,284✔





5584



      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);




13,284✔





5585



      varDataSetLen(varStbName, strlen(stbName));




13,284✔





5586



      code = colDataSetVal(colInfoData, 0, varStbName, false);




13,284✔





5587



      QUERY_CHECK_CODE(code, lino, _end);




13,284✔





5588



    } else {










5589



      colDataSetNULL(colInfoData, 0);










5590



    }










5591



  }










5592












5593



  if (pSupp->tbCountSlotId != -1) {




35,703✔





5594



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);




35,703✔





5595



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




35,703✔





5596



    code = colDataSetVal(colInfoData, 0, (char*)&count, false);




35,703✔





5597



    QUERY_CHECK_CODE(code, lino, _end);




35,703✔





5598



  }










5599



  pRes->info.rows = 1;




35,703✔





5600












5601



_end:




35,703✔





5602



  if (code != TSDB_CODE_SUCCESS) {




35,703✔





5603



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5604



  }










5605



  return code;




35,703✔





5606



}










5607












5608



static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {




10,558✔





5609



  STableCountScanSupp* pSupp = &pInfo->supp;




10,558✔





5610



  SSDataBlock*         pRes = pInfo->pRes;




10,558✔





5611












5612



  size_t infodbTableNum;




10,558✔





5613



  getInfosDbMeta(NULL, &infodbTableNum);




10,558✔





5614



  infodbTableNum -= 1;




10,558✔





5615



  size_t perfdbTableNum;




10,558✔





5616



  getPerfDbMeta(NULL, &perfdbTableNum);




10,558✔





5617












5618



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




10,558✔





5619



    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);




9,051✔





5620



    return (pRes->info.rows > 0) ? pRes : NULL;




9,051✔





5621



  } else {










5622



    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);




1,507✔





5623



    return (pRes->info.rows > 0) ? pRes : NULL;




1,507✔





5624



  }










5625



}










5626












5627



static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,




1,507✔





5628



                                       size_t infodbTableNum, size_t perfdbTableNum) {










5629



  int32_t        code = TSDB_CODE_SUCCESS;




1,507✔





5630



  int32_t        lino = 0;




1,507✔





5631



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,507✔





5632



  if (strlen(pSupp->stbNameFilter) != 0) {




1,507✔





5633



    // sys dbs do not contain any stable, so the count is always 0










5634



    code = fillTableCountScanDataBlock(pSupp, "", "", 0, pRes);




513✔





5635



    QUERY_CHECK_CODE(code, lino, _end);




513✔





5636



  } else if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) {




994✔





5637



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




171✔





5638



    QUERY_CHECK_CODE(code, lino, _end);




171✔





5639



  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {




823✔





5640



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




×







5641



    QUERY_CHECK_CODE(code, lino, _end);




×







5642



  } else if (strlen(pSupp->dbNameFilter) == 0) {




823✔





5643



    code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes);




652✔





5644



    QUERY_CHECK_CODE(code, lino, _end);




652✔





5645



  } else {










5646



    // other dbs do not exist in sys dbs, so the count is always 0










5647



    code = fillTableCountScanDataBlock(pSupp, pSupp->dbNameFilter, pSupp->stbNameFilter, 0, pRes);




171✔





5648



    QUERY_CHECK_CODE(code, lino, _end);




171✔





5649



  }










5650












5651



_end:




171✔





5652



  if (code != TSDB_CODE_SUCCESS) {




1,507✔





5653



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5654



    pTaskInfo->code = code;




×







5655



    T_LONG_JMP(pTaskInfo->env, code);




×







5656



  }










5657



  setOperatorCompleted(pOperator);




1,507✔





5658



}




1,507✔





5659












5660



static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




9,051✔





5661



                                        STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5662



                                        size_t perfdbTableNum) {










5663



  int32_t        code = TSDB_CODE_SUCCESS;




9,051✔





5664



  int32_t        lino = 0;




9,051✔





5665



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,051✔





5666



  if (pInfo->currGrpIdx == 0) {




9,051✔





5667



    uint64_t groupId = 0;




3,017✔





5668



    if (pSupp->groupByDbName) {




3,017✔





5669



      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));




2,062✔





5670



    } else {










5671



      groupId = calcGroupId("", 0);




955✔





5672



    }










5673












5674



    pRes->info.id.groupId = groupId;




3,017✔





5675



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




3,017✔





5676



    QUERY_CHECK_CODE(code, lino, _end);




3,017✔





5677



  } else if (pInfo->currGrpIdx == 1) {




6,034✔





5678



    uint64_t groupId = 0;




3,017✔





5679



    if (pSupp->groupByDbName) {




3,017✔





5680



      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));




2,062✔





5681



    } else {










5682



      groupId = calcGroupId("", 0);




955✔





5683



    }










5684












5685



    pRes->info.id.groupId = groupId;




3,017✔





5686



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




3,017✔





5687



    QUERY_CHECK_CODE(code, lino, _end);




3,017✔





5688



  } else {










5689



    setOperatorCompleted(pOperator);




3,017✔





5690



  }










5691



  pInfo->currGrpIdx++;




9,051✔





5692












5693



_end:




9,051✔





5694



  if (code != TSDB_CODE_SUCCESS) {




9,051✔





5695



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5696



    pTaskInfo->code = code;




×







5697



    T_LONG_JMP(pTaskInfo->env, code);




×







5698



  }










5699



}




9,051✔





5700












5701



static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




61,633✔





5702



  int32_t                      code = TSDB_CODE_SUCCESS;




61,633✔





5703



  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;




61,633✔





5704



  STableCountScanOperatorInfo* pInfo = pOperator->info;




61,633✔





5705



  STableCountScanSupp*         pSupp = &pInfo->supp;




61,493✔





5706



  SSDataBlock*                 pRes = pInfo->pRes;




61,493✔





5707












5708



  blockDataCleanup(pRes);




61,493✔





5709



  QRY_PARAM_CHECK(ppRes);




61,633✔





5710












5711



  if (pOperator->status == OP_EXEC_DONE) {




61,633✔





5712



    return code;




15,307✔





5713



  }










5714












5715



  if (pInfo->readHandle.mnd != NULL) {




46,326✔





5716



    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);




10,558✔





5717



    return code;




10,558✔





5718



  }










5719












5720



  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);




35,768✔





5721



  if (code != TSDB_CODE_SUCCESS) {




35,768✔





5722



    qError("%s failed since %s", __func__, tstrerror(code));




×







5723



    pTaskInfo->code = code;




×







5724



    T_LONG_JMP(pTaskInfo->env, code);




×







5725



  }










5726



  if (pRes->info.rows > 0) {




35,768✔





5727



    *ppRes = pRes;




28,162✔





5728



  }










5729












5730



  return code;




35,768✔





5731



}










5732












5733



static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




35,768✔





5734



                                      STableCountScanSupp* pSupp, SSDataBlock* pRes) {










5735



  int32_t        code = TSDB_CODE_SUCCESS;




35,768✔





5736



  int32_t        lino = 0;




35,768✔





5737



  const char*    db = NULL;




35,768✔





5738



  int32_t        vgId = 0;




35,768✔





5739



  char           dbName[TSDB_DB_NAME_LEN] = {0};




35,768✔





5740



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




35,768✔





5741



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




35,768✔





5742












5743



  // get dbname










5744



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);




35,768✔





5745



  SName sn = {0};




35,768✔





5746












5747



  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);




35,768✔





5748



  QUERY_CHECK_CODE(code, lino, _end);




35,768✔





5749












5750



  code = tNameGetDbName(&sn, dbName);




35,768✔





5751



  QUERY_CHECK_CODE(code, lino, _end);




35,768✔





5752












5753



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




35,768✔





5754



    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);




25,658✔





5755



  } else {










5756



    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);




10,110✔





5757



  }










5758












5759



_end:




35,768✔





5760



  if (code != TSDB_CODE_SUCCESS) {




35,768✔





5761



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5762



    pTaskInfo->code = code;




×







5763



  }










5764












5765



  return code;




35,768✔





5766



}










5767












5768



static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




25,658✔





5769



                                           STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) {










5770



  int32_t        code = TSDB_CODE_SUCCESS;




25,658✔





5771



  int32_t        lino = 0;




25,658✔





5772



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




25,658✔





5773



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




25,658✔





5774












5775



  if (pSupp->groupByStbName) {




25,658✔





5776



    if (pInfo->stbUidList == NULL) {




21,968✔





5777



      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));




7,606✔





5778



      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);




7,606✔





5779



      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);




7,606✔





5780



      QUERY_CHECK_CODE(code, lino, _end);




7,606✔





5781



    }










5782












5783



    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {




21,968✔





5784



      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);




13,284✔





5785



      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);




13,284✔





5786



      QUERY_CHECK_CODE(code, lino, _end);




13,284✔





5787












5788



      pInfo->currGrpIdx++;




13,284✔





5789



    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {




8,684✔





5790



      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);




7,606✔





5791



      QUERY_CHECK_CODE(code, lino, _end);




7,606✔





5792












5793



      pInfo->currGrpIdx++;




7,606✔





5794



    } else {










5795



      setOperatorCompleted(pOperator);




1,078✔





5796



    }










5797



  } else {










5798



    uint64_t groupId = calcGroupId(dbName, strlen(dbName));




3,690✔





5799



    pRes->info.id.groupId = groupId;




3,690✔





5800












5801



    int64_t dbTableCount = 0;




3,690✔





5802



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);




3,690✔





5803



    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);




3,690✔





5804



    QUERY_CHECK_CODE(code, lino, _end);




3,690✔





5805



    setOperatorCompleted(pOperator);




3,690✔





5806



  }










5807












5808



_end:




25,658✔





5809



  if (code != TSDB_CODE_SUCCESS) {




25,658✔





5810



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5811



    pTaskInfo->code = code;




×







5812



  }










5813



  return code;




25,658✔





5814



}










5815












5816



static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




10,110✔





5817



                                         STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) {










5818



  int32_t        code = TSDB_CODE_SUCCESS;




10,110✔





5819



  int32_t        lino = 0;




10,110✔





5820



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




10,110✔





5821



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




10,110✔





5822












5823



  if (strlen(pSupp->dbNameFilter) != 0 && strcmp(dbName, pSupp->dbNameFilter) != 0) {




10,110✔





5824



    // db name not match, return count 0










5825



    code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




×







5826



    QUERY_CHECK_CODE(code, lino, _end);




×







5827



  } else if (strlen(pSupp->stbNameFilter) != 0) {




10,110✔





5828



    uint64_t uid = 0;




3,014✔





5829



    code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid);




3,014✔





5830



    if (code == TSDB_CODE_TDB_TABLE_NOT_EXIST) {




3,014✔





5831



      // table not exist, return count 0










5832



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




1,368✔





5833



      QUERY_CHECK_CODE(code, lino, _end);




1,368✔





5834



    } else {










5835



      QUERY_CHECK_CODE(code, lino, _end);




1,646✔





5836












5837



      int64_t numOfChildTables = 0;




1,646✔





5838



      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL, NULL);




1,646✔





5839



      QUERY_CHECK_CODE(code, lino, _end);




1,646✔





5840












5841



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes);




1,646✔





5842



      QUERY_CHECK_CODE(code, lino, _end);




1,646✔





5843



    }










5844



  } else {










5845



    int64_t tbNumVnode = 0;




7,096✔





5846



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);




7,096✔





5847



    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);




7,096✔





5848



    QUERY_CHECK_CODE(code, lino, _end);




7,096✔





5849



  }










5850












5851



_end:




10,110✔





5852



  if (code != TSDB_CODE_SUCCESS) {




10,110✔





5853



    pTaskInfo->code = code;




×







5854



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5855



  }










5856












5857



  setOperatorCompleted(pOperator);




10,110✔





5858



  return code;




10,110✔





5859



}










5860












5861



static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




7,606✔





5862



                                              SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) {










5863



  int32_t code = TSDB_CODE_SUCCESS;




7,606✔





5864



  int32_t lino = 0;




7,606✔





5865



  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




7,606✔





5866



  if (pSupp->groupByDbName) {




7,606✔





5867



    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");




3,688✔





5868



  }










5869












5870



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




7,606✔





5871



  pRes->info.id.groupId = groupId;




7,606✔





5872












5873



  int64_t numOfTables = 0;




7,606✔





5874



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);




7,606✔





5875












5876



  if (numOfTables != 0) {




7,606✔





5877



    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);




1,078✔





5878



  }










5879












5880



_end:




6,528✔





5881



  if (code != TSDB_CODE_SUCCESS) {




7,606✔





5882



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5883



  }










5884



  return code;




7,606✔





5885



}










5886












5887



static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




13,284✔





5888



                                              SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) {










5889



  int32_t code = TSDB_CODE_SUCCESS;




13,284✔





5890



  int32_t lino = 0;




13,284✔





5891



  char    stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




13,284✔





5892



  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);




13,284✔





5893



  QUERY_CHECK_CODE(code, lino, _end);




13,284✔





5894












5895



  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




13,284✔





5896



  if (pSupp->groupByDbName) {




13,284✔





5897



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));




6,132✔





5898



  } else {










5899



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));




7,152✔





5900



  }










5901












5902



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




13,284✔





5903



  pRes->info.id.groupId = groupId;




13,284✔





5904












5905



  int64_t ctbNum = 0;




13,284✔





5906



  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL, NULL);




13,284✔





5907



  QUERY_CHECK_CODE(code, lino, _end);




13,284✔





5908



  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);




13,284✔





5909



  QUERY_CHECK_CODE(code, lino, _end);




13,284✔





5910












5911



_end:




13,284✔





5912



  if (code != TSDB_CODE_SUCCESS) {




13,284✔





5913



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5914



  }










5915



  return code;




13,284✔





5916



}










5917












5918



static void destoryTableCountScanOperator(void* param) {




25,930✔





5919



  STableCountScanOperatorInfo* pTableCountScanInfo = param;




25,930✔





5920



  blockDataDestroy(pTableCountScanInfo->pRes);




25,930✔





5921












5922



  taosArrayDestroy(pTableCountScanInfo->stbUidList);




25,930✔





5923



  taosMemoryFreeClear(param);




25,930✔





5924



}




25,930✔



















    

  • 

    •