taosdata / TDengine / #4970

coverage: 67.707% (+0.02%) from 67.69%
#4970

push

travis-ci

web-flow 
fix(planner): disable project block merge in non-top-level subplans (#34617)

208390 of 307783 relevant lines covered (67.71%)

125793239.88 hits per line

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

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









16



#include "executor.h"










17



#include "executorInt.h"










18



#include "filter.h"










19



#include "function.h"










20



#include "functionMgt.h"










21



#include "os.h"










22



#include "querynodes.h"










23



#include "streamexecutorInt.h"










24



#include "systable.h"










25



#include "taoserror.h"










26



#include "tarray.h"










27



#include "tdef.h"










28



#include "tname.h"










29












30



#include "tdatablock.h"










31



#include "tmsg.h"










32



#include "ttime.h"










33












34



#include "operator.h"










35



#include "query.h"










36



#include "querytask.h"










37



#include "tcompare.h"










38



#include "thash.h"










39



#include "ttypes.h"










40












41



#include "function.h"










42



#include "storageapi.h"










43



#include "wal.h"










44












45



int32_t scanDebug = 0;










46












47



#define MULTI_READER_MAX_TABLE_NUM     5000










48



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










49



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










50



#define STREAM_SCAN_OP_NAME            "StreamScanOperator"










51



#define STREAM_SCAN_OP_STATE_NAME      "StreamScanFillHistoryState"










52



#define STREAM_SCAN_OP_CHECKPOINT_NAME "StreamScanOperator_Checkpoint"










53












54



typedef struct STableMergeScanExecInfo {










55



  SFileBlockLoadRecorder blockRecorder;










56



  SSortExecInfo          sortExecInfo;










57



} STableMergeScanExecInfo;










58












59



typedef struct STableMergeScanSortSourceParam {










60



  SOperatorInfo* pOperator;










61



  int32_t        readerIdx;










62



  uint64_t       uid;










63



  STsdbReader*   reader;










64



} STableMergeScanSortSourceParam;










65












66



typedef struct STableCountScanOperatorInfo {










67



  SReadHandle  readHandle;










68



  SSDataBlock* pRes;










69












70



  STableCountScanSupp supp;










71












72



  int32_t currGrpIdx;










73



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










74



} STableCountScanOperatorInfo;










75












76



static bool    processBlockWithProbability(const SSampleExecInfo* pInfo);










77



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










78












79



bool processBlockWithProbability(const SSampleExecInfo* pInfo) {




479,095,161✔





80



#if 0










81



  if (pInfo->sampleRatio == 1) {










82



    return true;










83



  }










84












85



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










86



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










87



#else










88



  return true;




479,095,161✔





89



#endif










90



}










91












92



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




66,641✔





93



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




66,641✔





94



    SWITCH_ORDER(pCtx[i].order);




×







95



  }










96



}




66,641✔





97












98



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




520,833,571✔





99



  int32_t     code = TSDB_CODE_SUCCESS;




520,833,571✔





100



  STimeWindow w = {0};




520,833,571✔





101












102



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










103



  if (pInterval->interval == 0) {




520,995,598✔





104



    *overlap = false;




483,749,173✔





105



    return code;




483,746,990✔





106



  }










107












108



  if (order == TSDB_ORDER_ASC) {




37,271,662✔





109



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




36,081,639✔





110



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




36,080,917✔





111



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




×







112



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







113



    }










114












115



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




36,073,789✔





116



      *overlap = true;




31,371,363✔





117



      return code;




31,369,983✔





118



    }










119












120



    while (1) {










121



      getNextTimeWindow(pInterval, &w, order);




4,712,348✔





122



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




4,716,791✔





123



        break;




4,444,224✔





124



      }










125












126



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




269,570✔





127



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




×







128



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







129



      }










130



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




269,570✔





131



        *overlap = true;




269,570✔





132



        return code;




269,570✔





133



      }










134



    }










135



  } else {










136



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




1,190,023✔





137



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




1,190,995✔





138



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




×







139



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







140



    }










141












142



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




1,190,604✔





143



      *overlap = true;




1,022,544✔





144



      return code;




1,022,544✔





145



    }










146












147



    while (1) {










148



      getNextTimeWindow(pInterval, &w, order);




168,060✔





149



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




167,841✔





150



        break;




165,261✔





151



      }










152












153



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




2,580✔





154



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




×







155



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







156



      }










157



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




2,580✔





158



        *overlap = true;




2,580✔





159



        return code;




2,580✔





160



      }










161



    }










162



  }










163












164



  *overlap = false;




4,609,485✔





165



  return code;




4,610,706✔





166



}










167












168



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










169



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




106,495,815✔





170



  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {




106,495,815✔





171



    return NULL;




×







172



  }










173












174



  int64_t buf[2] = {0};




106,521,465✔





175



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




106,508,828✔





176












177



  STableScanInfo* pTableScanInfo = pOperator->info;




106,511,120✔





178












179



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




106,475,742✔





180



                                                               buf, GET_RES_WINDOW_KEY_LEN(sizeof(groupId)));










181












182



  if (p1 == NULL) {




106,551,429✔





183



    return NULL;




47,706,595✔





184



  }










185












186



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




58,844,834✔





187



  if (NULL == *pPage) {




58,831,154✔





188



    return NULL;




×







189



  }










190












191



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




58,833,574✔





192



}










193












194



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




11,812,926✔





195



  if (NULL == pTableScanInfo->pIgnoreTables) {




11,812,926✔





196



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




1,139,511✔





197



    pTableScanInfo->pIgnoreTables =




1,139,185✔





198



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




1,139,511✔





199



    if (NULL == pTableScanInfo->pIgnoreTables) {




1,139,185✔





200



      return terrno;




×







201



    }










202



  }










203












204



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




11,814,174✔





205



                                sizeof(pTableScanInfo->scanTimes));










206



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




11,792,592✔





207



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




×







208



    return tempRes;




×







209



  }










210



  return TSDB_CODE_SUCCESS;




11,792,592✔





211



}










212












213



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




579,497,474✔





214



  STableScanInfo* pTableScanInfo = pOperator->info;




579,497,474✔





215



  int32_t         code = TSDB_CODE_SUCCESS;




579,817,975✔





216












217



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




579,817,975✔





218



    return TSDB_CODE_SUCCESS;




473,220,815✔





219



  }










220












221



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




106,517,739✔





222












223



  SFilePage*  pPage = NULL;




106,537,723✔





224



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




106,528,836✔





225












226



  if (pRow == NULL) {




106,520,121✔





227



    return TSDB_CODE_SUCCESS;




47,697,012✔





228



  }










229












230



  bool notLoadBlock = true;




58,823,109✔





231



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




2,147,483,647✔





232



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




2,147,483,647✔





233












234



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




2,147,483,647✔





235












236



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




2,147,483,647✔





237



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




2,147,483,647✔





238



      notLoadBlock = false;




47,018,612✔





239



      break;




47,018,612✔





240



    }










241



  }










242












243



  // release buffer pages










244



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




58,483,309✔





245












246



  if (notLoadBlock) {




58,833,747✔





247



    *status = FUNC_DATA_REQUIRED_NOT_LOAD;




11,816,222✔





248



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




11,816,638✔





249



  }










250












251



  return code;




58,802,289✔





252



}










253












254



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




9,104,064✔





255



                                  int32_t numOfRows, bool* keep) {










256



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




9,104,064✔





257



    *keep = true;




×







258



    return TSDB_CODE_SUCCESS;




×







259



  }










260












261



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




9,107,004✔





262



}










263












264



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




121,272,249✔





265



                              bool* pLoad) {










266



  SStorageAPI* pAPI = &pTaskInfo->storageAPI;




121,272,249✔





267



  bool         allColumnsHaveAgg = true;




121,290,952✔





268



  bool         hasNullSMA = false;




121,300,899✔





269



  if (pLoad != NULL) {




121,274,761✔





270



    *pLoad = false;




121,271,663✔





271



  }










272












273



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




121,240,917✔





274



                                                               &hasNullSMA);










275



  if (code != TSDB_CODE_SUCCESS) {




121,243,117✔





276



    return code;




×







277



  }










278












279



  if (!allColumnsHaveAgg || hasNullSMA) {




121,243,117✔





280



    *pLoad = false;




106,685,075✔





281



  } else {










282



    *pLoad = true;




14,558,042✔





283



  }










284












285



  return code;




121,244,957✔





286



}










287












288



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




611,582,946✔





289



                                  int32_t rows) {










290



  int32_t    code = 0;




611,582,946✔





291



  SExprSupp* pSup = &pTableScanInfo->pseudoSup;




611,582,946✔





292



  if (pSup->numOfExprs > 0) {




611,852,497✔





293



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




274,456,380✔





294



                                  pTaskInfo, &pTableScanInfo->metaCache);










295



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










296



    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




274,258,518✔





297



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




×







298



      code = 0;




×







299



    }










300



  }










301












302



  return code;




611,711,349✔





303



}










304












305



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




954,685,410✔





306



  SLimit*     pLimit = &pLimitInfo->limit;




954,685,410✔





307



  const char* id = GET_TASKID(pTaskInfo);




954,816,091✔





308












309



  if (pLimitInfo->remainOffset > 0) {




954,923,002✔





310



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




4,926,698✔





311



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




2,460,054✔





312



      blockDataEmpty(pBlock);




2,460,050✔





313



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




2,460,054✔





314



      return false;




2,460,054✔





315



    } else {










316



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




2,466,644✔





317



      if (code != TSDB_CODE_SUCCESS) {




2,466,644✔





318



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




×







319



        pTaskInfo->code = code;




×







320



        T_LONG_JMP(pTaskInfo->env, code);




×







321



      }










322



      pLimitInfo->remainOffset = 0;




2,466,644✔





323



    }










324



  }










325












326



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




952,500,701✔





327



    // limit the output rows










328



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




26,773,415✔





329



    blockDataKeepFirstNRows(pBlock, keep);




26,773,941✔





330












331



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




26,773,455✔





332



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




26,771,857✔





333



    return true;




26,774,997✔





334



  }










335












336



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




925,434,281✔





337



  return false;




925,692,950✔





338



}










339












340



static bool isDynVtbScan(SOperatorInfo* pOperator) {




×







341



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




×







342



}










343












344



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




608,331,867✔





345



                             uint32_t* status) {










346



  int32_t        code = TSDB_CODE_SUCCESS;




608,331,867✔





347



  int32_t        lino = 0;




608,331,867✔





348



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




608,331,867✔





349



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




608,474,226✔





350



  bool           loadSMA = false;




608,383,901✔





351












352



  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;




608,383,901✔





353












354



  pCost->totalBlocks += 1;




608,364,884✔





355



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




608,372,209✔





356



  *status = pTableScanInfo->dataBlockLoadFlag;




608,245,067✔





357












358



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




608,301,681✔





359



    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




87,247,775✔





360



  } else {










361



    bool overlap = false;




520,911,895✔





362



    int  ret =










363



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




521,003,177✔





364



    if (ret != TSDB_CODE_SUCCESS) {




520,768,416✔





365



      return ret;




×







366



    }










367



    if (overlap) {




520,768,416✔





368



      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




32,661,864✔





369



    }










370



  }










371












372



  SDataBlockInfo* pBlockInfo = &pBlock->info;




608,243,040✔





373



  taosMemoryFreeClear(pBlock->pBlockAgg);




608,152,864✔





374












375



  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {




608,307,950✔





376



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




×







377



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










378



    pCost->filterOutBlocks += 1;




×







379



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




×







380



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




×







381



    return TSDB_CODE_SUCCESS;




×







382



  } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




607,961,849✔





383



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




19,723,192✔





384



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










385



           pBlockInfo->id.uid);










386



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




19,730,754✔





387



    pCost->skipBlocks += 1;




19,731,387✔





388



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




19,729,809✔





389



    return code;




19,728,093✔





390



  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {




588,136,736✔





391



    pCost->loadBlockStatis += 1;




34,034,125✔





392



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




34,026,520✔





393



    bool success = true;




34,026,520✔





394



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




34,030,571✔





395



    if (code) {




34,023,984✔





396



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




×







397



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




×







398



      QUERY_CHECK_CODE(code, lino, _end);




197✔





399



    }










400












401



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




34,022,950✔





402



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




5,452,659✔





403



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










404



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




5,452,659✔





405



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




5,452,519✔





406



      return code;




5,452,939✔





407



    } else {










408



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




28,570,291✔





409



      *status = FUNC_DATA_REQUIRED_DATA_LOAD;




28,580,922✔





410



    }










411



  }










412












413



  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {




582,852,102✔





414



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




×







415



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




×







416



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







417



  }










418












419



  // try to filter data block according to sma info










420



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




582,844,647✔





421



    bool success = true;




87,266,448✔





422



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




87,270,191✔





423



    if (code) {




87,198,938✔





424



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




×







425



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




×







426



      QUERY_CHECK_CODE(code, lino, _end);




40,014✔





427



    }










428












429



    if (success) {




87,238,896✔





430



      size_t size = taosArrayGetSize(pBlock->pDataBlock);




9,108,264✔





431



      bool   keep = false;




9,106,584✔





432



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




9,107,144✔





433



      if (code) {




9,107,704✔





434



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




×







435



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




×







436



        QUERY_CHECK_CODE(code, lino, _end);




×







437



      }










438












439



      if (!keep) {




9,106,724✔





440



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




3,317,114✔





441



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










442



        pCost->filterOutBlocks += 1;




3,317,114✔





443



        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;




3,317,114✔





444



        taosMemoryFreeClear(pBlock->pBlockAgg);




3,317,114✔





445












446



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




3,317,114✔





447



        return TSDB_CODE_SUCCESS;




3,317,114✔





448



      }










449



    }










450



  }










451












452



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










453



  taosMemoryFreeClear(pBlock->pBlockAgg);




579,732,311✔





454












455



  // try to filter data block according to current results










456



  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);




579,557,167✔





457



  if (code) {




579,574,741✔





458



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




×







459



    QUERY_CHECK_CODE(code, lino, _end);




×







460



  }










461












462



  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




579,574,741✔





463



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




11,806,528✔





464



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










465



    pCost->skipBlocks += 1;




11,819,200✔





466



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




11,817,152✔





467












468



    STableScanInfo* p1 = pOperator->info;




11,816,638✔





469



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




11,816,638✔





470



      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;




2,789,338✔





471



    } else {










472



      *status = FUNC_DATA_REQUIRED_FILTEROUT;




9,027,300✔





473



    }










474



    return TSDB_CODE_SUCCESS;




11,816,638✔





475



  }










476












477



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




567,536,303✔





478



  pCost->loadBlocks += 1;




567,732,877✔





479












480



  SSDataBlock* p = NULL;




567,687,510✔





481



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




567,653,874✔





482



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




567,966,907✔





483



    return code;




×







484



  }










485












486



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




567,966,907✔





487



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




440,639,172✔





488



    // do nothing










489



  } else {










490



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










491



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




540,301,434✔





492



    if (code) {




540,350,226✔





493



      return code;




×







494



    }










495



  }










496












497



  // restore the previous value










498



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




567,782,244✔





499












500



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




567,919,321✔





501



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




83,904,305✔





502



    QUERY_CHECK_CODE(code, lino, _end);




83,904,980✔





503












504



    int64_t st = taosGetTimestampUs();




83,791,529✔





505



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




83,793,679✔





506



    pTableScanInfo->readRecorder.filterTime += el;




83,793,679✔





507












508



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




83,779,246✔





509



      pCost->filterOutBlocks += 1;




15,375,875✔





510



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




15,368,395✔





511



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










512



    } else {










513



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




68,380,794✔





514



    }










515



  }










516












517



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




567,618,926✔





518



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




567,804,327✔





519



    setOperatorCompleted(pOperator);




3,510,248✔





520



  }










521












522



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




567,804,842✔





523












524



_end:




568,033,686✔





525



  if (code != TSDB_CODE_SUCCESS) {




568,003,856✔





526



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




130,448✔





527



  }










528



  return code;




567,717,982✔





529



}










530












531



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




66,641✔





532



  SET_REVERSE_SCAN_FLAG(pTableScanInfo);




66,641✔





533












534



  switchCtxOrder(pCtx, numOfOutput);




66,641✔





535



  pTableScanInfo->cond.order = TSDB_ORDER_DESC;




66,641✔





536



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










537



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










538



}




66,641✔





539












540



typedef struct STableCachedVal {










541



  const char* pName;










542



  STag*       pTags;










543



} STableCachedVal;










544












545



static void freeTableCachedVal(void* param) {




×







546



  if (param == NULL) {




×







547



    return;




×







548



  }










549












550



  STableCachedVal* pVal = param;




×







551



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




×







552



  taosMemoryFree(pVal->pTags);




×







553



  taosMemoryFree(pVal);




×







554



}










555












556



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




×







557



  int32_t          code = TSDB_CODE_SUCCESS;




×







558



  int32_t          lino = 0;




×







559



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




×







560



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




×







561












562



  pVal->pTags = NULL;




×







563



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




×







564



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




×







565












566



  // only child table has tag value










567



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




×







568



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




×







569



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




×







570



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




×







571



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




×







572



  }










573












574



  (*ppResVal) = pVal;




×







575












576



_end:




×







577



  if (code != TSDB_CODE_SUCCESS) {




×







578



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




×







579



    freeTableCachedVal(pVal);




×







580



  }










581



  return code;




×







582



}










583












584



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










585



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




×







586



  (void)key;










587



  (void)keyLen;










588



  (void)ud;










589



  freeTableCachedVal(value);




×







590



}




×







591












592



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




×







593



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




×







594



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




×







595












596



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




×







597



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




×







598



  }










599



}




×







600












601



static void freeTableCachedValObj(STableCachedVal* pVal) {




×







602



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




×







603



  taosMemoryFree(pVal->pTags);




×







604



}




×







605












606



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




274,674,783✔





607



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










608



  int32_t          code = TSDB_CODE_SUCCESS;




274,674,783✔





609



  int32_t          lino = 0;




274,674,783✔





610



  bool             freeReader = false;




274,674,783✔





611



  LRUHandle*       h = NULL;




274,674,783✔





612



  STableCachedVal  val = {0};




274,674,783✔





613



  SMetaReader      mr = {0};




274,674,783✔





614



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




274,636,729✔





615



  int32_t          insertRet = TAOS_LRU_STATUS_OK;




274,710,218✔





616



  STableCachedVal* pVal = NULL;




274,710,218✔





617












618



  // currently only the tbname pseudo column










619



  if (numOfExpr <= 0) {




274,813,145✔





620



    return TSDB_CODE_SUCCESS;




171,031✔





621



  }










622












623



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










624












625



  // backup the rows










626



  int32_t backupRows = pBlock->info.rows;




274,642,114✔





627



  pBlock->info.rows = rows;




274,611,239✔





628












629



  // todo refactor: extract method










630



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










631












632



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










633



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




274,599,733✔





634



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




274,563,192✔





635



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




274,688,066✔





636



    if (code != TSDB_CODE_SUCCESS) {




274,486,744✔





637



      // when encounter the TSDB_CODE_PAR_TABLE_NOT_EXIST error, we proceed.










638



      if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







639



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




×







640



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










641












642



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










643



        doSetNullValue(pBlock, pExpr, numOfExpr);




×







644



      } else {










645



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




×







646



      }










647



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




×







648



      return code;




×







649



    }










650












651



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




274,486,744✔





652












653



    val.pName = mr.me.name;




274,630,257✔





654



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




274,630,257✔





655












656



    freeReader = true;




274,630,257✔





657



  } else {










658



    pCache->metaFetch += 1;




×







659












660



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




×







661



    if (h == NULL) {




×







662



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




×







663



      freeReader = true;




×







664



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




×







665



      if (code != TSDB_CODE_SUCCESS) {




×







666



        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







667



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




×







668



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










669



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










670



          doSetNullValue(pBlock, pExpr, numOfExpr);




×







671



        } else {










672



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




×







673



                 idStr);










674



        }










675



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




×







676



        return code;




×







677



      }










678












679



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




×







680












681



      code = createTableCacheVal(&mr, &pVal);




×







682



      QUERY_CHECK_CODE(code, lino, _end);




×







683












684



      val = *pVal;




×







685



    } else {










686



      pCache->cacheHit += 1;




×







687



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




×







688



      val = *pValTmp;




×







689












690



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




×







691



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




×







692



    }










693












694



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




×







695



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










696



  }










697












698



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




873,519,188✔





699



    const SExprInfo* pExpr1 = &pExpr[j];




598,819,916✔





700



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




598,806,381✔





701












702



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




598,999,506✔





703



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




599,036,345✔





704












705



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




599,026,079✔





706












707



    // this is to handle the tbname










708



    if (fmIsScanPseudoColumnFunc(functionId)) {




599,088,663✔





709



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




92,223,817✔





710



      if (fType == FUNCTION_TYPE_TBNAME) {




92,232,105✔





711



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




92,232,105✔





712



        QUERY_CHECK_CODE(code, lino, _end);




92,214,798✔





713



      } else if (fType == FUNCTION_TYPE_VGID) {




×







714



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




×







715



        QUERY_CHECK_CODE(code, lino, _end);




×







716



      } else if (fType == FUNCTION_TYPE_VGVER) {




×







717



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




×







718



        QUERY_CHECK_CODE(code, lino, _end);




×







719



      }










720



    } else {  // these are tags










721



      STagVal tagVal = {0};




506,621,534✔





722



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




506,631,662✔





723



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




506,786,414✔





724












725



      char* data = NULL;




506,790,983✔





726



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




506,790,983✔





727



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




500,524,954✔





728



      } else {










729



        data = (char*)p;




6,262,766✔





730



      }










731












732



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




506,612,168✔





733



      if (isNullVal) {




506,699,285✔





734



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




5,776,408✔





735



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




500,922,877✔





736



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




500,354,862✔





737



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




500,475,652✔





738



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




191,826,558✔





739



          if (tmp != NULL) {




191,858,153✔





740



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




191,858,153✔





741



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




191,854,110✔





742



                   pBlock->info.id.uid);










743



            taosMemoryFree(tmp);




191,901,693✔





744



          }










745



          taosMemoryFree(data);




191,900,721✔





746



        }










747



        QUERY_CHECK_CODE(code, lino, _end);




500,400,308✔





748



      } else {  // todo opt for json tag










749



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




2,999,251✔





750



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




2,512,514✔





751



          QUERY_CHECK_CODE(code, lino, _end);




2,513,262✔





752



        }










753



      }










754



    }










755



  }










756












757



  // restore the rows










758



  pBlock->info.rows = backupRows;




274,699,272✔





759












760



_end:




274,643,292✔





761












762



  if (NULL != pVal) {




274,562,492✔





763



    insertRet =




×







764



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




×







765



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










766



    if (insertRet != TAOS_LRU_STATUS_OK) {




×







767



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




×







768



    }










769



  }










770












771



  if (freeReader) {




274,562,492✔





772



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




274,548,933✔





773



  }










774



  if (code != TSDB_CODE_SUCCESS) {




274,672,683✔





775



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




×







776



  }










777



  return code;




274,597,683✔





778



}










779












780



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




92,216,160✔





781



                         const char* name) {










782



  int32_t                     code = TSDB_CODE_SUCCESS;




92,216,160✔





783



  int32_t                     lino = 0;




92,216,160✔





784



  struct SScalarFuncExecFuncs fpSet = {0};




92,216,160✔





785



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




92,219,904✔





786



  QUERY_CHECK_CODE(code, lino, _end);




92,237,824✔





787












788



  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;




92,237,824✔





789



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




92,237,824✔





790



  STR_TO_VARSTR(buf, name)




92,233,469✔





791












792



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




92,209,269✔





793












794



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




92,209,998✔





795



  QUERY_CHECK_CODE(code, lino, _end);




92,214,634✔





796












797



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




92,214,634✔





798



  QUERY_CHECK_CODE(code, lino, _end);




92,211,117✔





799












800



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




92,211,117✔





801



  SScalarParam param = {.columnData = pColInfoData};




92,218,479✔





802












803



  if (fpSet.process != NULL) {




92,197,840✔





804



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




92,197,840✔





805



    QUERY_CHECK_CODE(code, lino, _end);




92,230,660✔





806



  } else {










807



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




×







808



  }










809












810



  colDataDestroy(&infoData);




92,230,660✔





811












812



_end:




92,228,826✔





813



  if (code != TSDB_CODE_SUCCESS) {




92,233,579✔





814



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




×







815



  }










816



  return code;




92,233,579✔





817



}










818












819



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




×







820



  int32_t                     code = TSDB_CODE_SUCCESS;




×







821



  int32_t                     lino = 0;




×







822



  struct SScalarFuncExecFuncs fpSet = {0};




×







823



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







824



  QUERY_CHECK_CODE(code, lino, _end);




×







825












826



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




×







827












828



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




×







829



  QUERY_CHECK_CODE(code, lino, _end);




×







830












831



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




×







832



  QUERY_CHECK_CODE(code, lino, _end);




×







833












834



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




×







835



  SScalarParam param = {.columnData = pColInfoData};




×







836












837



  if (fpSet.process != NULL) {




×







838



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




×







839



    QUERY_CHECK_CODE(code, lino, _end);




×







840



  } else {










841



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




×







842



  }










843












844



_end:




×







845



  colDataDestroy(&infoData);




×







846



  if (code != TSDB_CODE_SUCCESS) {




×







847



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




×







848



  }










849



  return code;




×







850



}










851












852



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




×







853



  int32_t                     code = TSDB_CODE_SUCCESS;




×







854



  int32_t                     lino = 0;




×







855



  struct SScalarFuncExecFuncs fpSet = {0};




×







856



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







857



  QUERY_CHECK_CODE(code, lino, _end);




×







858












859



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




×







860












861



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




×







862



  QUERY_CHECK_CODE(code, lino, _end);




×







863












864



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




×







865



  QUERY_CHECK_CODE(code, lino, _end);




×







866












867



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




×







868



  SScalarParam param = {.columnData = pColInfoData};




×







869












870



  if (fpSet.process != NULL) {




×







871



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




×







872



    QUERY_CHECK_CODE(code, lino, _end);




×







873



  } else {










874



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




×







875



  }










876












877



_end:




×







878



  colDataDestroy(&infoData);




×







879



  if (code != TSDB_CODE_SUCCESS) {




×







880



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




×







881



  }










882



  return code;




×







883



}










884












885



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




174,107,896✔





886



  int32_t code = TSDB_CODE_SUCCESS;




174,107,896✔





887



  int32_t lino = 0;




174,107,896✔





888



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




174,107,896✔





889



  QUERY_CHECK_CODE(code, lino, _end);




173,895,881✔





890












891



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




173,895,881✔





892



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




174,003,101✔





893



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




173,864,797✔





894



  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);




173,897,638✔





895












896



  if (!pInfo->needCountEmptyTable) {




174,047,885✔





897



    pInfo->countState = TABLE_COUNT_STATE_END;




156,795,009✔





898



  } else {










899



    pInfo->countState = TABLE_COUNT_STATE_SCAN;




17,210,697✔





900



  }










901












902



_end:




173,973,548✔





903



  if (code != TSDB_CODE_SUCCESS) {




173,973,548✔





904



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




×







905



  }










906



  return code;




173,905,747✔





907



}










908












909



void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {




497,154,674✔





910



  if (pInfo->countState == TABLE_COUNT_STATE_END) {




497,154,674✔





911



    return;




427,600,775✔





912



  }










913



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




69,699,099✔





914



    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;




221,248✔





915



  } else {










916



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




69,467,292✔





917



    if (code != TSDB_CODE_SUCCESS) {




69,479,535✔





918



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




5,819,511✔





919



    }










920



  }










921



}










922












923



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




46,164,624✔





924



                                         const STableKeyInfo* tbInfo) {










925



  blockDataEmpty(pBlock);




46,164,624✔





926



  pBlock->info.rows = 1;




46,166,087✔





927



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




46,166,087✔





928



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




46,166,590✔





929



  pBlock->info.blankFill = true;




46,161,606✔





930












931



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










932



  int32_t col_num = blockDataGetNumOfCols(pBlock);




46,161,103✔





933



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




190,875,873✔





934



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




144,709,740✔





935



    colDataSetNULL(pColInfoData, 0);










936



  }










937












938



  // set tag/tbname










939



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




46,166,133✔





940












941



  return pBlock;




46,162,612✔





942



}










943












944



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




44,364,588✔





945



  STableScanInfo* pTableScanInfo = pOperator->info;




44,364,588✔





946



  SSDataBlock*    pBlock =










947



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




44,366,051✔





948












949



  pOperator->resultInfo.totalRows++;




44,359,101✔





950



  return pBlock;




44,366,554✔





951



}










952












953



/**










954



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










955



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










956



*/










957



static int32_t prepareTableScan(SOperatorInfo* pOperator) {




651,004,578✔





958



  int32_t code = TSDB_CODE_SUCCESS;




651,004,578✔





959



  int32_t lino = 0;




651,004,578✔





960












961



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




651,004,578✔





962



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




651,080,297✔





963



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




651,301,142✔





964



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




31,637,015✔





965



         NOTIFY_TYPE_SCAN_PARAM &&




2,991,566✔





966



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




2,991,566✔





967



    STableScanOperatorParam* pNotify =




2,991,566✔





968



      (STableScanOperatorParam*)pGetParam->value;










969












970



    STableScanInfo* pTableScanInfo = pOperator->info;




2,991,566✔





971



    SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




2,991,566✔





972



    SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




2,991,566✔





973



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




2,991,566✔





974



                                             pNotify->notifyTs);










975



    QUERY_CHECK_CODE(code, lino, _end);




2,991,566✔





976












977



    if (!pGetParam->reUse) {




2,991,566✔





978



      freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




96,196✔





979



    } else {










980



      /**










981



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










982



        the parent operator after getting next block.










983



      */










984



      pGetParam->reUse = false;




2,895,370✔





985



    }










986



    /**










987



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










988



    */










989



    pOperator->pOperatorGetParam = NULL;




2,991,566✔





990



  }










991












992



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




651,309,488✔





993



_end:




83,789,724✔





994



  if (code != TSDB_CODE_SUCCESS) {




651,296,860✔





995



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




×







996



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










997



  }










998



  return code;




651,301,776✔





999



}










1000












1001



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




612,858,123✔





1002



  int32_t         code = TSDB_CODE_SUCCESS;




612,858,123✔





1003



  int32_t         lino = 0;




612,858,123✔





1004



  STableScanInfo* pTableScanInfo = pOperator->info;




612,858,123✔





1005



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




612,916,824✔





1006



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




612,762,636✔





1007



  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;




612,836,592✔





1008



  bool            hasNext = false;




612,798,073✔





1009



  int64_t         st = taosGetTimestampUs();




612,763,121✔





1010












1011



  QRY_PARAM_CHECK(ppRes);




612,763,121✔





1012



  pBlock->info.dataLoad = false;




612,803,951✔





1013












1014



  while (true) {




23,362,776✔





1015



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




636,100,075✔





1016



    if (code != TSDB_CODE_SUCCESS) {




636,005,882✔





1017



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




×







1018



      QUERY_CHECK_CODE(code, lino, _end);




×







1019



    }










1020












1021



    if (!hasNext) {




635,956,018✔





1022



      break;




156,891,536✔





1023



    }










1024












1025



    if (isTaskKilled(pTaskInfo)) {




479,064,482✔





1026



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




10,787✔





1027



      code = pTaskInfo->code;




10,787✔





1028



      QUERY_CHECK_CODE(code, lino, _end);




10,787✔





1029



    }










1030












1031



    if (pOperator->status == OP_EXEC_DONE) {




479,440,781✔





1032



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




178,080✔





1033



      break;




178,080✔





1034



    }










1035












1036



    // process this data block based on the probabilities










1037



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




479,178,713✔





1038



    if (!processThisBlock) {




479,204,132✔





1039



      continue;




×







1040



    }










1041












1042



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




479,204,132✔





1043



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




479,272,338✔





1044



    }










1045












1046



    uint32_t status = 0;




479,346,326✔





1047



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




479,347,352✔





1048



    QUERY_CHECK_CODE(code, lino, _end);




479,055,584✔





1049












1050



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




478,941,442✔





1051



      break;




2,789,526✔





1052



    }










1053












1054



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










1055



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




476,151,916✔





1056



      continue;




23,363,306✔





1057



    }










1058












1059



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




452,860,100✔





1060



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




452,962,332✔





1061












1062



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




452,966,457✔





1063



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




453,002,971✔





1064












1065



    (*ppRes) = pBlock;




452,986,202✔





1066



    return code;




452,849,734✔





1067



  }










1068












1069



_end:




160,002,967✔





1070



  if (code != TSDB_CODE_SUCCESS) {




160,011,584✔





1071



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




140,789✔





1072



    pTaskInfo->code = code;




140,789✔





1073



    T_LONG_JMP(pTaskInfo->env, code);




124,929✔





1074



  }










1075



  return code;




159,870,795✔





1076



}










1077












1078



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




659,903,892✔





1079



  int32_t         code = TSDB_CODE_SUCCESS;




659,903,892✔





1080



  int32_t         lino = 0;




659,903,892✔





1081



  STableScanInfo* pTableScanInfo = pOperator->info;




659,903,892✔





1082



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




659,978,431✔





1083



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




659,815,731✔





1084












1085



  QRY_PARAM_CHECK(pBlock);




659,845,494✔





1086












1087



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










1088



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




659,793,699✔





1089



    return code;




2,784,778✔





1090



  }










1091












1092



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










1093



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




802,659,092✔





1094



    SSDataBlock* p = NULL;




561,837,671✔





1095



    code = doTableScanImplNext(pOperator, &p);




561,779,338✔





1096



    QUERY_CHECK_CODE(code, lino, _end);




561,618,201✔





1097












1098



    if (p != NULL) {




561,618,201✔





1099



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




415,982,578✔





1100



      *pBlock = p;




416,016,288✔





1101



      return code;




416,010,787✔





1102



    }










1103












1104



    pTableScanInfo->scanTimes += 1;




145,635,623✔





1105



    taosHashClear(pTableScanInfo->pIgnoreTables);




145,643,546✔





1106












1107



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




145,640,611✔





1108



      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




83,922✔





1109



      pTableScanInfo->base.scanFlag = MAIN_SCAN;




83,922✔





1110



      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




83,922✔





1111



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




83,922✔





1112












1113



      // do prepare for the next round table scan operation










1114



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




83,922✔





1115



      QUERY_CHECK_CODE(code, lino, _end);




85,115✔





1116



    }










1117



  }










1118












1119



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




240,925,703✔





1120



  if (pTableScanInfo->scanTimes < total) {




240,891,989✔





1121



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




51,030,697✔





1122



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




66,641✔





1123



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




66,641✔





1124



      QUERY_CHECK_CODE(code, lino, _end);




66,641✔





1125



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




66,641✔





1126



    }










1127












1128



    while (pTableScanInfo->scanTimes < total) {




65,225,577✔





1129



      SSDataBlock* p = NULL;




51,033,691✔





1130



      code = doTableScanImplNext(pOperator, &p);




51,016,596✔





1131



      QUERY_CHECK_CODE(code, lino, _end);




50,989,555✔





1132












1133



      if (p != NULL) {




50,989,555✔





1134



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




36,787,438✔





1135



        *pBlock = p;




36,838,473✔





1136



        return code;




36,830,891✔





1137



      }










1138












1139



      pTableScanInfo->scanTimes += 1;




14,202,117✔





1140



      taosHashClear(pTableScanInfo->pIgnoreTables);




14,206,634✔





1141












1142



      if (pTableScanInfo->scanTimes < total) {




14,204,426✔





1143



        setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




×







1144



        pTableScanInfo->base.scanFlag = MAIN_SCAN;




×







1145












1146



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




×







1147



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




×







1148



        QUERY_CHECK_CODE(code, lino, _end);




×







1149



      }










1150



    }










1151



  }










1152












1153



  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {




204,054,535✔





1154



    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;




60,961,367✔





1155



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




60,958,349✔





1156



      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {




112,926✔





1157



        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;




1,988✔





1158



        STableKeyInfo* pStart =










1159



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




1,988✔





1160












1161



        if (NULL == pStart) {




1,988✔





1162



          return code;




×







1163



        }










1164












1165



        *pBlock = getBlockForEmptyTable(pOperator, pStart);




1,988✔





1166



        return code;




1,988✔





1167



      }










1168



    } else {  // group by tag + no sort










1169



      int32_t numOfTables = 0;




60,844,471✔





1170



      code = tableListGetSize(pTableListInfo, &numOfTables);




60,842,656✔





1171



      QUERY_CHECK_CODE(code, lino, _end);




60,846,531✔





1172












1173



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




60,846,531✔





1174



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










1175



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




59,918,258✔





1176



        if (pIte != NULL) {




59,914,707✔





1177



          size_t        keySize = 0;




44,362,097✔





1178



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




44,362,600✔





1179



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




44,360,085✔





1180



          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);




44,361,594✔





1181



          markGroupProcessed(pTableScanInfo, *pGroupId);




44,363,103✔





1182



          *pBlock = getBlockForEmptyTable(pOperator, &info);




44,358,576✔





1183












1184



          return code;




44,362,051✔





1185



        }










1186



      }










1187



    }










1188



    pTableScanInfo->countState = TABLE_COUNT_STATE_END;




16,593,557✔





1189



  }










1190












1191



_end:




143,123,533✔





1192



  if (code != TSDB_CODE_SUCCESS) {




159,705,622✔





1193



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




×







1194



    pTaskInfo->code = code;




×







1195



  }










1196












1197



  return code;




159,705,622✔





1198



}










1199












1200



static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {




957,754✔





1201



  STableScanInfo*          pInfo = pOperator->info;




957,754✔





1202



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




957,754✔





1203



  int32_t                  code = 0;




957,754✔





1204



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




957,754✔





1205



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




957,754✔





1206



  int32_t                  num = taosArrayGetSize(pParam->pUidList);




957,754✔





1207



  if (num <= 0) {




957,754✔





1208



    qError("empty table scan uid list");




×







1209



    return TSDB_CODE_INVALID_PARA;




×







1210



  }










1211












1212



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




957,754✔





1213



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










1214



         pOperator->status);










1215












1216



  if (pParam->tableSeq) {




957,754✔





1217



    pListInfo->oneTableForEachGroup = true;




705,267✔





1218



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




705,267✔





1219



      taosHashClear(pListInfo->map);




×







1220



      taosArrayClear(pListInfo->pTableList);




×







1221



      pOperator->status = OP_EXEC_DONE;




×







1222



    }










1223



  } else {










1224



    pListInfo->oneTableForEachGroup = false;




252,487✔





1225



    pListInfo->numOfOuputGroups = 1;




252,487✔





1226



  }










1227



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




957,754✔





1228



    // do nothing










1229



  } else {










1230



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




700,839✔





1231



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




700,839✔





1232



  }










1233












1234



  STableKeyInfo info = {.groupId = 0};




957,754✔





1235



  int32_t       tableIdx = 0;




957,754✔





1236



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




9,053,881✔





1237



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




8,096,127✔





1238



    if (!pUid) {




8,096,127✔





1239



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




×







1240



      return terrno;




×







1241



    }










1242












1243



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




8,096,127✔





1244



      if (TSDB_CODE_DUP_KEY == terrno) {




6,788,889✔





1245



        continue;




6,788,889✔





1246



      }










1247



      return terrno;




×







1248



    }










1249












1250



    info.uid = *pUid;




1,307,238✔





1251



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




1,307,238✔





1252



    if (p == NULL) {




1,307,238✔





1253



      return terrno;




×







1254



    }










1255












1256



    tableIdx++;




1,307,238✔





1257



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




1,307,238✔





1258



  }










1259












1260



  return code;




957,754✔





1261



}










1262












1263



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




160,060,843✔





1264



                            STableKeyInfo** pList) {










1265



  const char* idStr = GET_TASKID(pTaskInfo);




160,060,843✔





1266



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




160,122,566✔





1267



  if (code) {




159,678,224✔





1268



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




×







1269



    return code;




×







1270



  }










1271












1272



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




159,678,224✔





1273



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




×







1274



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







1275



  }










1276












1277



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




319,681,762✔





1278



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




160,013,630✔





1279



  if (code) {




159,970,580✔





1280



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




2,240✔





1281



  }










1282












1283



  return code;




159,816,873✔





1284



}










1285












1286



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




299,110,433✔





1287



  SColIdPair* node1 = (SColIdPair*)elem1;




299,110,433✔





1288



  SColIdPair* node2 = (SColIdPair*)elem2;




299,110,433✔





1289












1290



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




299,110,433✔





1291



    return 0;




108,944✔





1292



  }










1293












1294



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




299,139,544✔





1295



}










1296












1297



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




402,313,387✔





1298



  SColIdSlotIdPair* node1 = (SColIdSlotIdPair*)elem1;




402,313,387✔





1299



  SColIdSlotIdPair* node2 = (SColIdSlotIdPair*)elem2;




402,313,387✔





1300












1301



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




402,313,387✔





1302



    return 0;




166,424✔





1303



  }










1304












1305



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




402,292,065✔





1306



}










1307












1308



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




×







1309



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




×







1310



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




×







1311












1312



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




×







1313



    return 0;




×







1314



  }










1315












1316



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




×







1317



}










1318












1319



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




94,345,659✔





1320



  if (pList == NULL) {




94,345,659✔





1321



    return NULL;




×







1322



  }










1323












1324



  int32_t left = 0;




94,345,659✔





1325



  int32_t right = taosArrayGetSize(pList) - 1;




94,345,659✔





1326



  while (left <= right) {




292,432,417✔





1327



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




292,432,417✔





1328



    SColMatchItem* pItem = taosArrayGet(pList, mid);




292,432,417✔





1329



    if (pItem->colId == colId) {




292,432,417✔





1330



      // return the first matched item in sorted order










1331



      while (mid > 0) {




94,345,659✔





1332



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




70,753,152✔





1333



        if (pPrev->colId != colId) {




70,753,152✔





1334



          break;




70,753,152✔





1335



        }










1336



        mid--;




×







1337



      }










1338



      return taosArrayGet(pList, mid);




94,345,659✔





1339



    }










1340












1341



    if (pItem->colId < colId) {




198,086,758✔





1342



      left = mid + 1;




93,050,291✔





1343



    } else {










1344



      right = mid - 1;




105,036,467✔





1345



    }










1346



  }










1347












1348



  return NULL;




×







1349



}










1350












1351



static bool isNewScanParam(STableScanOperatorParam* pParam) {




40,340,766✔





1352



  return pParam->isNewParam;




40,340,766✔





1353



}










1354












1355



static int32_t createVTableScanInfoFromBatchParam(SOperatorInfo* pOperator) {




17,543,734✔





1356



  int32_t                  code = 0;




17,543,734✔





1357



  int32_t                  lino = 0;




17,543,734✔





1358



  STableScanInfo*          pInfo = pOperator->info;




17,543,734✔





1359



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




17,546,694✔





1360



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




17,535,980✔





1361



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




17,535,784✔





1362



  SMetaReader              orgTable = {0};




17,542,230✔





1363



  SMetaReader              superTable = {0};




17,563,230✔





1364



  SSchemaWrapper*          schema = NULL;




17,547,534✔





1365



  SArray*                  pColArray = NULL;




17,547,534✔





1366



  SArray*                  pBlockColArray = NULL;




17,547,534✔





1367



  int32_t                  num = 0;




17,547,534✔





1368



  STableKeyInfo*           pList = NULL;




17,549,540✔





1369



  SOrgTbInfo*              pOrgTbInfo;










1370



  bool                     isNewTable;










1371












1372



  cleanupQueryTableDataCond(&pInfo->base.cond);




17,549,026✔





1373












1374



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




17,544,430✔





1375



  if (pGetParam &&




17,549,276✔





1376



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




4,085,802✔





1377



    STableScanOperatorParam* pParam =




4,090,988✔





1378



      (STableScanOperatorParam*)pGetParam->value;










1379



    pInfo->pBatchColMap = pParam->pBatchTbInfo;




4,079,848✔





1380



    pParam->pBatchTbInfo = NULL;




4,081,188✔





1381



    pInfo->cachedTimeWindow = pParam->window;




4,071,610✔





1382



    pInfo->currentBatchIdx = 0;




4,080,734✔





1383



    pInfo->lastBatchIdx = -1;




4,078,514✔





1384



    pInfo->cachedTagList = pParam->pTagList;




4,072,940✔





1385



    pParam->pTagList = NULL;




4,081,138✔





1386



    pInfo->cachedGroupId = pParam->groupid;




4,084,324✔





1387












1388



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




4,082,614✔





1389



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










1390



    taosHashClear(pInfo->pIgnoreTables);




4,082,614✔





1391












1392



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




4,096,736✔





1393



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




3,896,722✔





1394



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




48,822,410✔





1395



        SqlFunctionCtx ctx = pSup->pCtx[i];




44,993,000✔





1396



        ctx.skipDynDataCheck = false;




44,931,600✔





1397



      }










1398



    }










1399



  }










1400












1401



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




17,502,630✔





1402



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




17,552,588✔





1403












1404



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




17,552,588✔





1405



    isNewTable = false;




10,679,642✔





1406



  } else {










1407



    isNewTable = true;




6,868,362✔





1408



    pInfo->lastBatchIdx = pInfo->currentBatchIdx;




6,868,362✔





1409



  }










1410












1411



  if (isNewTable) {




17,548,304✔





1412



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




6,868,336✔





1413



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




6,884,482✔





1414



    pAPI->metaReaderFn.readerReleaseLock(&orgTable);




6,866,406✔





1415



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




6,857,648✔





1416



    QUERY_CHECK_CODE(code, lino, _return);




6,802,872✔





1417



    switch (orgTable.me.type) {




6,802,872✔





1418



      case TSDB_CHILD_TABLE:




282,340✔





1419



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




282,340✔





1420



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




282,340✔





1421



        pAPI->metaReaderFn.readerReleaseLock(&superTable);




282,340✔





1422



        QUERY_CHECK_CODE(code, lino, _return);




282,340✔





1423



        schema = &superTable.me.stbEntry.schemaRow;




282,340✔





1424



        break;




282,340✔





1425



      case TSDB_NORMAL_TABLE:




6,527,072✔





1426



        schema = &orgTable.me.ntbEntry.schemaRow;




6,527,072✔





1427



        break;




6,527,072✔





1428



      default:




×







1429



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




×







1430



        return TSDB_CODE_INVALID_PARA;




×







1431



        break;










1432



    }










1433












1434



    pListInfo->oneTableForEachGroup = true;




6,809,412✔





1435



    taosHashClear(pListInfo->map);




6,829,034✔





1436



    taosArrayClear(pListInfo->pTableList);




6,888,740✔





1437












1438



    uint64_t      pUid = orgTable.me.uid;




6,887,712✔





1439



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




6,887,712✔





1440



    int32_t       tableIdx = 0;




6,886,872✔





1441



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




6,887,060✔





1442



    QUERY_CHECK_CODE(code, lino, _return);




6,888,740✔





1443



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




13,768,842✔





1444



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




6,880,102✔





1445












1446



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




6,880,102✔





1447



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




6,871,316✔





1448



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




6,871,316✔





1449



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




6,871,726✔





1450












1451



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










1452



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




6,871,726✔





1453



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




6,875,174✔





1454












1455



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




26,284,942✔





1456



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




19,397,202✔





1457



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




153,743,472✔





1458



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




153,477,007✔





1459



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




19,420,466✔





1460



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




19,412,459✔





1461



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




19,412,459✔





1462



                 pPair.vtbColId, GET_TASKID(pTaskInfo));










1463



          break;




19,397,529✔





1464



        }










1465



      }










1466



    }










1467












1468



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




33,176,059✔





1469



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




26,277,717✔





1470



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




157,036,185✔





1471



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




156,623,901✔





1472



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




156,702,603✔





1473



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




26,295,478✔





1474



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




26,316,482✔





1475



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




26,316,482✔





1476



                 colIdSlotIdPair.vtbSlotId, GET_TASKID(pTaskInfo));










1477



          break;




26,285,337✔





1478



        }










1479



      }










1480



    }










1481












1482



    taosArraySort(pColArray, compareColIdPair);




6,883,574✔





1483



    taosArraySort(pBlockColArray, compareColIdSlotIdPair);




6,873,164✔





1484



    if (pInfo->pBlockColMap) {




6,880,591✔





1485



      taosArrayDestroy(pInfo->pBlockColMap);




4,897,430✔





1486



      pInfo->pBlockColMap = NULL;




4,894,596✔





1487



    }










1488



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




6,873,896✔





1489



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




6,874,380✔





1490












1491












1492



    taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




6,853,707✔





1493



    taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




6,865,859✔





1494












1495



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




6,883,876✔





1496



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




6,159,104✔





1497



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




76,374,338✔





1498



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




70,238,077✔





1499



        bool           needScan = false;




70,227,972✔





1500



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




141,420,604✔





1501



          SFunctParam pParam = ctx->param[j];




71,186,257✔





1502



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




340,823,479✔





1503



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




285,721,827✔





1504



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




286,846,104✔





1505



              needScan |= true;




17,729,486✔





1506



              break;




17,729,486✔





1507



            }










1508



          }










1509



        }










1510



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




70,251,425✔





1511



        if (!needScan) {




70,284,490✔





1512



          ctx->skipDynDataCheck = true;




52,572,694✔





1513



        } else {










1514



          ctx->skipDynDataCheck = false;




17,711,796✔





1515



        }










1516



      }










1517



    }










1518












1519












1520



  } else {










1521



    pColArray = pInfo->lastColArray;




10,679,968✔





1522



    pBlockColArray = pInfo->lastBlockColArray;




10,680,294✔





1523



  }










1524












1525



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




17,558,478✔





1526



  QUERY_CHECK_CODE(code, lino, _return);




17,563,794✔





1527












1528



  if (pInfo->pResBlock) {




17,563,794✔





1529



    blockDataDestroy(pInfo->pResBlock);




13,458,614✔





1530



    pInfo->pResBlock = NULL;




13,458,614✔





1531



  }










1532












1533



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




17,562,816✔





1534



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










1535



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










1536



         isNewTable, pInfo->base.orgCond.order,










1537



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










1538



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










1539



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










1540












1541



  if (isNewTable) {




17,540,774✔





1542



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




6,860,994✔





1543



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




6,141,451✔





1544



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




6,125,879✔





1545



    } else {










1546



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




719,503✔





1547



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




714,902✔





1548



    }










1549



  } else {










1550



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




10,679,780✔





1551



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




1,400,624✔





1552



    else {










1553



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




9,277,476✔





1554



    }










1555



  }










1556












1557



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




17,502,137✔





1558



  pInfo->currentGroupId = 0;




17,520,200✔





1559



  pInfo->ignoreTag = true;




17,515,854✔





1560












1561



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




17,499,939✔





1562



  QUERY_CHECK_CODE(code, lino, _return);




17,546,794✔





1563












1564



  if (isNewTable) {




17,546,794✔





1565



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




6,868,368✔





1566



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




4,901,868✔





1567



    }










1568



    pInfo->base.dataReader = NULL;




6,844,410✔





1569












1570



    taosRLockLatch(&pTaskInfo->lock);




6,847,944✔





1571



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




6,883,638✔





1572



    taosRUnLockLatch(&pTaskInfo->lock);




6,843,830✔





1573



    QUERY_CHECK_CODE(code, lino, _return);




6,858,712✔





1574












1575



    pInfo->newReader = true;




6,858,712✔





1576



    if (pInfo->lastColArray) {




6,857,684✔





1577



      taosArrayDestroy(pInfo->lastColArray);




2,778,320✔





1578



      pInfo->lastColArray = NULL;




2,777,154✔





1579



    }










1580



    if (pInfo->lastBlockColArray) {




6,816,342✔





1581



      taosArrayDestroy(pInfo->lastBlockColArray);




2,777,744✔





1582



      pInfo->lastBlockColArray = NULL;




2,777,806✔





1583



    }










1584



    pInfo->lastColArray = pColArray;




6,809,230✔





1585



    pInfo->lastBlockColArray = pBlockColArray;




6,812,417✔





1586



  } else {










1587



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




10,678,426✔





1588



    QUERY_CHECK_CODE(code, lino, _return);




10,679,968✔





1589












1590



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




10,679,968✔





1591



    pInfo->newReader = false;




10,679,968✔





1592



    pInfo->scanTimes = 0;




10,679,968✔





1593



  }










1594












1595



  pOperator->status = OP_OPENED;




17,475,422✔





1596












1597



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




17,480,724✔





1598



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




×







1599



  }










1600












1601



  pInfo->currentGroupId = -1;




17,505,372✔





1602



_return:




17,510,404✔





1603



  if (code) {




17,453,766✔





1604



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




×







1605



  }










1606



  pAPI->metaReaderFn.clearReader(&superTable);




17,453,766✔





1607



  pAPI->metaReaderFn.clearReader(&orgTable);




17,499,764✔





1608



  return code;




17,525,402✔





1609



}










1610












1611



static int32_t createVTableScanInfoFromParam(SOperatorInfo* pOperator) {




23,592,507✔





1612



  int32_t                  code = 0;




23,592,507✔





1613



  int32_t                  lino = 0;




23,592,507✔





1614



  STableScanInfo*          pInfo = pOperator->info;




23,592,507✔





1615



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




23,592,507✔





1616



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




23,592,507✔





1617



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




23,592,507✔





1618



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




23,592,507✔





1619



  SMetaReader              orgTable = {0};




23,592,507✔





1620



  SMetaReader              superTable = {0};




23,592,507✔





1621



  SSchemaWrapper*          schema = NULL;




23,592,507✔





1622



  SArray*                  pColArray = NULL;




23,592,507✔





1623



  SArray*                  pBlockColArray = NULL;




23,592,507✔





1624



  int32_t                  num = 0;




23,592,507✔





1625



  STableKeyInfo*           pList = NULL;




23,592,507✔





1626



  SOrgTbInfo*              pOrgTbInfo;










1627



  SArray*                  pMatchList = NULL;




23,592,507✔





1628












1629



  cleanupQueryTableDataCond(&pInfo->base.cond);




23,592,507✔





1630












1631



  pOrgTbInfo = pParam->pOrgTbInfo;




23,592,507✔





1632












1633



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




23,592,507✔





1634












1635



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




23,592,507✔





1636



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




23,592,507✔





1637



  pAPI->metaReaderFn.readerReleaseLock(&orgTable);




23,592,507✔





1638



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




23,592,507✔





1639



  QUERY_CHECK_CODE(code, lino, _return);




23,592,507✔





1640



  switch (orgTable.me.type) {




23,592,507✔





1641



    case TSDB_CHILD_TABLE:




6,450,449✔





1642



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




6,450,449✔





1643



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




6,450,449✔





1644



      pAPI->metaReaderFn.readerReleaseLock(&superTable);




6,450,449✔





1645



      QUERY_CHECK_CODE(code, lino, _return);




6,450,449✔





1646



      schema = &superTable.me.stbEntry.schemaRow;




6,450,449✔





1647



      break;




6,450,449✔





1648



    case TSDB_NORMAL_TABLE:




17,142,058✔





1649



      schema = &orgTable.me.ntbEntry.schemaRow;




17,142,058✔





1650



      break;




17,142,058✔





1651



    default:




×







1652



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




×







1653



      return TSDB_CODE_INVALID_PARA;




×







1654



      break;










1655



  }










1656












1657



  pListInfo->oneTableForEachGroup = true;




23,592,507✔





1658



  taosHashClear(pListInfo->map);




23,592,507✔





1659



  taosArrayClear(pListInfo->pTableList);




23,592,507✔





1660












1661



  uint64_t      pUid = orgTable.me.uid;




23,592,507✔





1662



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




23,592,507✔





1663



  int32_t       tableIdx = 0;




23,592,507✔





1664



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




23,592,507✔





1665



  QUERY_CHECK_CODE(code, lino, _return);




23,592,507✔





1666



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




47,185,014✔





1667



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




23,592,507✔





1668












1669



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




23,592,507✔





1670



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




23,592,507✔





1671



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




23,592,507✔





1672



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




23,592,507✔





1673



  if (pInfo->pBlockColMap) {




23,592,507✔





1674



    taosArrayDestroy(pInfo->pBlockColMap);




21,192,893✔





1675



    pInfo->pBlockColMap = NULL;




21,192,893✔





1676



  }










1677



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




23,592,507✔





1678



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




23,592,507✔





1679












1680



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










1681



  SColIdPair tsPair = {.vtbColId = PRIMARYKEY_TIMESTAMP_COL_ID,




23,592,507✔





1682



                       .orgColId = PRIMARYKEY_TIMESTAMP_COL_ID,










1683



                       .type.type = TSDB_DATA_TYPE_TIMESTAMP,










1684



                       .type.bytes = 8};










1685



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




23,592,507✔





1686












1687



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




94,345,659✔





1688



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




70,753,152✔





1689



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




596,701,535✔





1690



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




596,701,535✔





1691



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




70,753,152✔





1692



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




70,753,152✔





1693



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




70,753,152✔





1694



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




70,753,152✔





1695



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




70,753,152✔





1696



        break;




70,753,152✔





1697



      }










1698



    }










1699



  }










1700












1701



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




23,592,507✔





1702



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




23,592,507✔





1703



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




×







1704



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




×







1705



      taosArraySort(pMatchList, compareColMatchItemByColId);




×







1706



    } else {










1707



      pMatchList = pInfo->base.matchInfo.pList;




23,592,507✔





1708



    }










1709



  }










1710












1711



  // skip ts pair










1712



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




117,937,534✔





1713



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




94,345,659✔





1714



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




94,345,659✔





1715



    if (pItem) {




94,345,659✔





1716



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




94,345,659✔





1717



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




632✔





1718



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










1719



        code = TSDB_CODE_VTABLE_COLUMN_TYPE_MISMATCH;




632✔





1720



        goto _return;




632✔





1721



      }










1722



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




94,345,027✔





1723



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




94,345,027✔





1724



      if (i > 0) {




94,345,027✔





1725



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




141,505,040✔





1726



      }










1727



    }










1728



  }










1729












1730



  taosArraySort(pColArray, compareColIdPair);




23,591,875✔





1731



  taosArraySort(pBlockColArray, compareColIdSlotIdPair);




23,591,875✔





1732



  taosArraySort(pInfo->pBlockColMap, compareColIdSlotIdPair);




23,591,875✔





1733












1734



  taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




23,591,875✔





1735



  taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




23,591,875✔





1736












1737



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




23,591,875✔





1738



  QUERY_CHECK_CODE(code, lino, _return);




23,591,875✔





1739












1740



  if (pInfo->pResBlock) {




23,591,875✔





1741



    blockDataDestroy(pInfo->pResBlock);




16,751,163✔





1742



    pInfo->pResBlock = NULL;




16,751,163✔





1743



  }










1744












1745



  if (isNewScanParam(pParam)) {




23,591,875✔





1746



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




6,848,073✔





1747



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




6,848,073✔





1748



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




6,848,073✔





1749



    } else {










1750



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




×







1751



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




×







1752



    }










1753



  } else {










1754



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




16,743,802✔





1755



  }










1756



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




23,591,875✔





1757



  pInfo->currentGroupId = 0;




23,591,875✔





1758



  pInfo->ignoreTag = true;




23,591,875✔





1759












1760



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




23,591,875✔





1761



  QUERY_CHECK_CODE(code, lino, _return);




23,591,875✔





1762












1763



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




23,591,875✔





1764



  if (reader) {




23,591,875✔





1765



    if (isNewScanParam(pParam)) {




16,748,891✔





1766



      pAPI->tsdReader.tsdReaderClose(*reader);




5,089✔





1767



      pInfo->base.dataReader = NULL;




5,089✔





1768












1769



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




5,089✔





1770



      QUERY_CHECK_CODE(code, lino, _return);




5,089✔





1771












1772



      taosRLockLatch(&pTaskInfo->lock);




5,089✔





1773



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




5,089✔





1774



      taosRUnLockLatch(&pTaskInfo->lock);




5,089✔





1775



      QUERY_CHECK_CODE(code, lino, _return);




5,089✔





1776












1777



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




5,089✔





1778



      QUERY_CHECK_CODE(code, lino, _return);




5,089✔





1779



      pInfo->newReader = true;




5,089✔





1780



    } else {










1781



      pInfo->base.dataReader = *reader;




16,743,802✔





1782



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




16,743,802✔





1783



      QUERY_CHECK_CODE(code, lino, _return);




16,743,802✔





1784












1785



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




16,743,802✔





1786



      pInfo->newReader = false;




16,743,802✔





1787



      pInfo->scanTimes = 0;




16,743,802✔





1788



    }










1789



  } else {










1790



    pInfo->base.dataReader = NULL;




6,842,984✔





1791












1792



    taosRLockLatch(&pTaskInfo->lock);




6,842,984✔





1793



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




6,842,984✔





1794



    taosRUnLockLatch(&pTaskInfo->lock);




6,842,984✔





1795



    QUERY_CHECK_CODE(code, lino, _return);




6,842,984✔





1796












1797



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




6,842,984✔





1798



    QUERY_CHECK_CODE(code, lino, _return);




6,842,984✔





1799



    pInfo->newReader = true;




6,842,984✔





1800



  }










1801



  pOperator->status = OP_OPENED;




23,591,875✔





1802












1803



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




23,591,875✔





1804



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




×







1805



  }










1806












1807



  pInfo->currentGroupId = -1;




23,591,875✔





1808



_return:




23,592,507✔





1809



  if (code) {




23,592,507✔





1810



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




632✔





1811



  }










1812



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




23,592,507✔





1813



    taosArrayDestroy(pMatchList);




×







1814



  }










1815



  taosArrayDestroy(pColArray);




23,592,507✔





1816



  taosArrayDestroy(pBlockColArray);




23,592,507✔





1817



  pAPI->metaReaderFn.clearReader(&superTable);




23,592,507✔





1818



  pAPI->metaReaderFn.clearReader(&orgTable);




23,592,507✔





1819



  return code;




23,592,507✔





1820



}










1821












1822



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




156,785,842✔





1823



  int32_t         code = TSDB_CODE_SUCCESS;




156,785,842✔





1824



  int32_t         lino = 0;




156,785,842✔





1825



  STableScanInfo* pInfo = pOperator->info;




156,785,842✔





1826



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




156,804,331✔





1827



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




156,780,198✔





1828



  int32_t         numOfTables = 0;




156,753,750✔





1829












1830



  QRY_PARAM_CHECK(pResult);




156,740,081✔





1831












1832



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




156,729,056✔





1833



  QUERY_CHECK_CODE(code, lino, _end);




156,790,347✔





1834












1835



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




156,790,347✔





1836



    setOperatorCompleted(pOperator);




142,715,600✔





1837



    if (pOperator->dynamicTask) {




142,709,114✔





1838



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




956,268✔





1839



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




956,647✔





1840



    }










1841



    return code;




142,726,875✔





1842



  }










1843












1844



  // reset value for the next group data output










1845



  pOperator->status = OP_OPENED;




13,963,982✔





1846



  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);




14,056,461✔





1847












1848



  int32_t        num = 0;




14,045,709✔





1849



  STableKeyInfo* pList = NULL;




14,046,361✔





1850



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




14,044,881✔





1851



  QUERY_CHECK_CODE(code, lino, _end);




14,068,067✔





1852












1853



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




14,068,067✔





1854



  QUERY_CHECK_CODE(code, lino, _end);




14,052,009✔





1855












1856



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




14,052,009✔





1857



  QUERY_CHECK_CODE(code, lino, _end);




14,027,319✔





1858



  pInfo->scanTimes = 0;




14,027,319✔





1859












1860



  code = doGroupedTableScan(pOperator, pResult);




14,030,555✔





1861



  QUERY_CHECK_CODE(code, lino, _end);




14,090,661✔





1862












1863



  if (*pResult != NULL) {




14,090,661✔





1864



    if (pOperator->dynamicTask) {




11,384,220✔





1865



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




11,131,517✔





1866



    }










1867



    return code;




11,383,894✔





1868



  }










1869












1870



_end:




2,707,093✔





1871



  if (code != TSDB_CODE_SUCCESS) {




2,709,025✔





1872



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




×







1873



    pTaskInfo->code = code;




×







1874



  }










1875



  return code;




2,707,797✔





1876



}










1877












1878



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




606,821,249✔





1879



  int32_t         code = TSDB_CODE_SUCCESS;




606,821,249✔





1880



  int32_t         lino = 0;




606,821,249✔





1881



  STableScanInfo* pInfo = pOperator->info;




606,821,249✔





1882



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




606,840,149✔





1883



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




606,771,503✔





1884



  int32_t         num = 0;




606,712,162✔





1885



  STableKeyInfo*  pList = NULL;




606,624,974✔





1886



  SSDataBlock*    pResult = NULL;




606,641,083✔





1887



  const char*     idStr = GET_TASKID(pTaskInfo);




606,685,692✔





1888












1889



  QRY_PARAM_CHECK(pResBlock);




606,718,823✔





1890












1891



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




606,741,782✔





1892



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




146,274,999✔





1893



      setOperatorCompleted(pOperator);




×







1894



      return code;




×







1895



    }










1896












1897



    taosRLockLatch(&pTaskInfo->lock);




146,327,769✔





1898



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




146,416,025✔





1899



    taosRUnLockLatch(&pTaskInfo->lock);




146,276,940✔





1900



    QUERY_CHECK_CODE(code, lino, _end);




146,368,016✔





1901












1902



    if (pInfo->filesetDelimited) {




146,365,776✔





1903



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




253,584✔





1904



    }










1905












1906



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




146,367,397✔





1907



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




×







1908



    }










1909



  }










1910












1911



  code = doGroupedTableScan(pOperator, &pResult);




606,697,586✔





1912



  QUERY_CHECK_CODE(code, lino, _end);




606,368,496✔





1913












1914



  if (pResult != NULL) {




606,368,496✔





1915



    if (pOperator->dynamicTask) {




463,686,243✔





1916



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




2,029,613✔





1917



    }










1918












1919



    *pResBlock = pResult;




463,681,348✔





1920



    return code;




463,418,139✔





1921



  }










1922












1923



  while (true) {










1924



    code = startNextGroupScan(pOperator, &pResult);




142,762,033✔





1925



    QUERY_CHECK_CODE(code, lino, _end);




143,078,844✔





1926












1927



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




143,078,844✔





1928



      *pResBlock = pResult;




142,987,255✔





1929



      return code;




142,969,710✔





1930



    }










1931



  }










1932












1933



_end:




2,240✔





1934



  if (code != TSDB_CODE_SUCCESS) {




2,240✔





1935



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




2,240✔





1936



    pTaskInfo->code = code;




2,240✔





1937



  }










1938












1939



  return code;




2,240✔





1940



}










1941












1942



static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {




23,591,875✔





1943



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




23,591,875✔





1944



}










1945












1946



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




957,754✔





1947



  int32_t                  code = TSDB_CODE_SUCCESS;




957,754✔





1948



  int32_t                  lino = 0;




957,754✔





1949



  STableScanInfo*          pInfo = pOperator->info;




957,754✔





1950



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




957,754✔





1951



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




957,754✔





1952



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




957,754✔





1953












1954



  code = createTableListInfoFromParam(pOperator);




957,754✔





1955



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




957,754✔





1956



  pOperator->pOperatorGetParam = NULL;




957,754✔





1957



  QUERY_CHECK_CODE(code, lino, _end);




957,754✔





1958












1959



  if (pOperator->status == OP_EXEC_DONE) {




957,754✔





1960



    pInfo->currentGroupId = -1;




23,031✔





1961



    pOperator->status = OP_OPENED;




23,031✔





1962



    SSDataBlock* result = NULL;




23,031✔





1963












1964



    while (true) {










1965



      code = startNextGroupScan(pOperator, &result);




23,031✔





1966



      QUERY_CHECK_CODE(code, lino, _end);




23,031✔





1967












1968



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




23,031✔





1969



        (*ppRes) = result;




23,031✔





1970



        return code;




23,031✔





1971



      }










1972



    }










1973



  }










1974



_end:




934,723✔





1975



  if (code) {




934,723✔





1976



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




×







1977



  }










1978



  return code;




934,723✔





1979



}










1980












1981



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




16,752,890✔





1982



  int32_t      code = TSDB_CODE_SUCCESS;




16,752,890✔





1983



  int32_t      lino = 0;




16,752,890✔





1984



  bool         found = false;




16,752,890✔





1985












1986



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




16,752,890✔





1987



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




16,752,890✔





1988












1989



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




83,386,177✔





1990



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




66,633,287✔





1991



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




66,633,287✔





1992



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




190,859,214✔





1993



      SColIdSlotIdPair* pColPair = taosArrayGet(pColMap, j);




174,109,314✔





1994



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




174,109,314✔





1995



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




174,109,314✔





1996



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




49,883,387✔





1997



        found = true;




49,883,387✔





1998



        break;




49,883,387✔





1999



      }










2000



    }










2001



    if (!found) {




66,633,287✔





2002



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




16,749,900✔





2003



        pSrcCol->info.slotId = -1;




16,749,900✔





2004



      } else {










2005



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




×







2006



               (int32_t)taosArrayGetSize(pColMap));










2007



        code = TSDB_CODE_QRY_VSTB_SLOTID_NOT_FOUND;




×







2008



      }










2009



    }










2010



  }










2011












2012



  return code;




16,752,890✔





2013



_return:




×







2014



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




×







2015



  return code;




×







2016



}










2017












2018



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




23,592,507✔





2019



  int32_t                  code = TSDB_CODE_SUCCESS;




23,592,507✔





2020



  int32_t                  lino = 0;




23,592,507✔





2021



  STableScanInfo*          pInfo = pOperator->info;




23,592,507✔





2022



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




23,592,507✔





2023



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




23,592,507✔





2024



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




23,592,507✔





2025












2026



  QRY_PARAM_CHECK(ppRes);




23,592,507✔





2027



  qTrace("%s call", __FUNCTION__);




23,592,507✔





2028












2029



  code = createVTableScanInfoFromParam(pOperator);




23,592,507✔





2030



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




23,592,507✔





2031



  pOperator->pOperatorGetParam = NULL;




23,592,507✔





2032












2033



  QUERY_CHECK_CODE(code, lino, _end);




23,592,507✔





2034












2035



  SSDataBlock* result = NULL;




23,591,875✔





2036



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




23,591,875✔





2037



    (*ppRes) = result;




18,344✔





2038



    return code;




18,344✔





2039



  }










2040












2041



  if (pInfo->newReader) {




23,573,531✔





2042



    code = startNextGroupScan(pOperator, &result);




6,848,073✔





2043



    QUERY_CHECK_CODE(code, lino, _end);




6,848,073✔





2044



  } else {










2045



    code = doGroupedTableScan(pOperator, &result);




16,725,458✔





2046



    QUERY_CHECK_CODE(code, lino, _end);




16,725,458✔





2047



  }










2048












2049



  if (result) {




23,573,531✔





2050



    SSDataBlock* res = NULL;




16,752,890✔





2051



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




16,752,890✔





2052



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




16,752,890✔





2053



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




16,752,890✔





2054












2055



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




16,752,890✔





2056



    QUERY_CHECK_CODE(code, lino, _end);




16,752,890✔





2057



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










2058



    //QUERY_CHECK_CODE(code, lino, _end);










2059












2060



    //pInfo->pResBlock = res;










2061



    //blockDataDestroy(result);










2062



    (*ppRes) = result;




16,752,890✔





2063



  } else {










2064



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




6,820,641✔





2065



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




6,820,641✔





2066












2067



    blockDataDestroy(pInfo->pResBlock);




6,820,641✔





2068



    pInfo->pResBlock = NULL;




6,820,641✔





2069












2070



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




6,820,641✔





2071



    if (reader) {




6,820,641✔





2072



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




6,820,641✔





2073



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




6,820,641✔





2074



        pInfo->base.dataReader = NULL;




6,820,641✔





2075



      }










2076



      if (pAPI->tsdReader.tsdReaderClose) {




6,820,641✔





2077



        pAPI->tsdReader.tsdReaderClose(*reader);




6,820,641✔





2078



      }










2079



    }










2080












2081



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




6,820,641✔





2082



    QUERY_CHECK_CODE(code, lino, _end);




6,820,641✔





2083



  }










2084



_end:




23,574,163✔





2085



  if (code) {




23,574,163✔





2086



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




632✔





2087



  }










2088



  return code;




23,574,163✔





2089



}










2090












2091



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




3,059,444✔





2092



  int32_t                  code = TSDB_CODE_SUCCESS;




3,059,444✔





2093



  int32_t                  lino = 0;




3,059,444✔





2094



  STableScanInfo*          pInfo = pOperator->info;




3,059,444✔





2095



  int32_t                  index = 0;




3,059,444✔





2096



  char*                    tagVal = NULL;




3,059,444✔





2097












2098



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




21,429,794✔





2099



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




18,370,676✔





2100



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




18,370,676✔





2101












2102



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




18,370,676✔





2103



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




18,370,676✔





2104












2105



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




2,147,483,647✔





2106



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




2,147,483,647✔





2107



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




2,147,483,647✔





2108



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




2,147,483,647✔





2109












2110



        varDataSetLen(tagVal, pTagVal->nData);




2,147,483,647✔





2111



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




2,147,483,647✔





2112



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




2,147,483,647✔





2113



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2114



        taosMemoryFreeClear(tagVal);




2,147,483,647✔





2115



      } else {










2116



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




2,147,483,647✔





2117



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2118



      }










2119



    }










2120



    index++;




18,370,350✔





2121



  }










2122



  return code;




3,059,444✔





2123



_end:




×







2124



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




×







2125



  taosMemoryFreeClear(tagVal);




×







2126



  return code;




×







2127



}










2128












2129



static void clearVstbBatchDynamicTableScanInfo(STableScanInfo* pInfo) {




4,108,138✔





2130



  if (pInfo->pBatchColMap) {




4,108,138✔





2131



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




10,994,596✔





2132



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




6,884,176✔





2133



      taosArrayDestroy(pOrgTbInfo->colMap);




6,885,154✔





2134



    }










2135



    taosArrayDestroy(pInfo->pBatchColMap);




4,108,138✔





2136



    pInfo->pBatchColMap = NULL;




4,107,812✔





2137



  }










2138



  if (pInfo->cachedTagList) {




4,109,116✔





2139



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




12,864,178✔





2140



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




10,962,262✔





2141



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




10,963,892✔





2142



        taosMemoryFreeClear(pTagVal->pData);




4,809,094✔





2143



      }










2144



    }










2145



    taosArrayDestroy(pInfo->cachedTagList);




1,901,916✔





2146



    pInfo->cachedTagList = NULL;




1,903,220✔





2147



  }










2148



  if (pInfo->lastColArray) {




4,108,790✔





2149



    taosArrayDestroy(pInfo->lastColArray);




4,108,138✔





2150



    pInfo->lastColArray = NULL;




4,107,160✔





2151



  }










2152



  if (pInfo->lastBlockColArray) {




4,108,138✔





2153



    taosArrayDestroy(pInfo->lastBlockColArray);




4,107,812✔





2154



    pInfo->lastBlockColArray = NULL;




4,107,160✔





2155



  }










2156












2157



  blockDataDestroy(pInfo->pResBlock);




4,106,834✔





2158



  pInfo->pResBlock = NULL;




4,109,442✔





2159



}




4,109,768✔





2160












2161



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




14,750,850✔





2162



  int32_t                  code = TSDB_CODE_SUCCESS;




14,750,850✔





2163



  int32_t                  lino = 0;




14,750,850✔





2164



  STableScanInfo*          pInfo = pOperator->info;




14,750,850✔





2165



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




14,759,388✔





2166



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




14,761,602✔





2167



  SSDataBlock*             result = NULL;




14,767,972✔





2168












2169



  QRY_PARAM_CHECK(ppRes);




14,769,430✔





2170



  qTrace("%s call", __FUNCTION__);




14,764,724✔





2171












2172



  while (!result) {




28,233,682✔





2173



    code = createVTableScanInfoFromBatchParam(pOperator);




17,556,046✔





2174



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




17,519,182✔





2175



    pOperator->pOperatorGetParam = NULL;




17,502,822✔





2176



    QUERY_CHECK_CODE(code, lino, _end);




17,492,038✔





2177












2178



    if (pInfo->newReader) {




17,492,038✔





2179



      code = startNextGroupScan(pOperator, &result);




6,849,770✔





2180



      QUERY_CHECK_CODE(code, lino, _end);




6,886,744✔





2181



    } else {










2182



      code = doGroupedTableScan(pOperator, &result);




10,668,584✔





2183



      QUERY_CHECK_CODE(code, lino, _end);




10,679,266✔





2184



    }










2185



    if (!result) {




17,566,010✔





2186



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




6,882,294✔





2187



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










2188



      pInfo->currentBatchIdx++;




6,882,294✔





2189



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




6,878,146✔





2190



        // all batch scan finished










2191



        break;




4,107,812✔





2192



      }










2193



    }










2194



  }










2195












2196



  if (result) {




14,785,448✔





2197



    SSDataBlock* res = NULL;




10,678,614✔





2198



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




10,678,614✔





2199



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




10,677,774✔





2200



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




10,677,774✔





2201












2202



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




10,679,454✔





2203



    QUERY_CHECK_CODE(code, lino, _end);




10,680,294✔





2204












2205



    if (pInfo->cachedTagList) {




10,680,294✔





2206



      code = setTagValFromTagList(pOperator, res);




3,059,444✔





2207



      QUERY_CHECK_CODE(code, lino, _end);




3,059,444✔





2208



    }










2209












2210



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




10,680,294✔





2211



    pInfo->pResBlock = res;




10,680,294✔





2212



    blockDataDestroy(result);




10,680,294✔





2213



    (*ppRes) = res;




10,680,294✔





2214












2215



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




10,680,294✔





2216



  } else {










2217



    clearVstbBatchDynamicTableScanInfo(pInfo);




4,106,834✔





2218



    setOperatorCompleted(pOperator);




4,109,116✔





2219



  }










2220












2221



_end:




14,789,410✔





2222



  return code;




14,789,410✔





2223



}










2224












2225



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




39,331,271✔





2226



  int32_t                  code = TSDB_CODE_SUCCESS;




39,331,271✔





2227



  int32_t                  lino = 0;




39,331,271✔





2228



  STableScanInfo*          pInfo = pOperator->info;




39,331,271✔





2229



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




39,336,637✔





2230



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




39,333,365✔





2231












2232



  QRY_PARAM_CHECK(ppRes);




39,329,053✔





2233



  qTrace("%s call", __FUNCTION__);




39,321,155✔





2234












2235



  pOperator->dynamicTask = true;




39,321,155✔





2236












2237



  switch (type) {




39,322,671✔





2238



    case DYN_TYPE_VSTB_WIN_SCAN:




957,754✔





2239



    case DYN_TYPE_STB_JOIN: {










2240



      code = doStbJoinDynamicTableScanNext(pOperator, ppRes);




957,754✔





2241



      QUERY_CHECK_CODE(code, lino, _end);




957,754✔





2242



      break;




957,754✔





2243



    }










2244



    case DYN_TYPE_VSTB_SINGLE_SCAN: {




23,592,507✔





2245



      code = doVstbSingleDynamicTableScanNext(pOperator, ppRes);




23,592,507✔





2246



      QUERY_CHECK_CODE(code, lino, _end);




23,592,507✔





2247



      break;




23,591,875✔





2248



    }










2249



    case DYN_TYPE_VSTB_BATCH_SCAN:




14,772,410✔





2250



      code = doVstbBatchDynamicTableScanNext(pOperator, ppRes);




14,772,410✔





2251



      QUERY_CHECK_CODE(code, lino, _end);




14,788,758✔





2252



      break;




14,788,758✔





2253



    default:




×







2254



      code = TSDB_CODE_INVALID_PARA;




×







2255



      QUERY_CHECK_CODE(code, lino, _end);




×







2256



      break;




×







2257



  }










2258












2259



_end:




39,339,019✔





2260



  return code;




39,339,019✔





2261



}










2262












2263



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




651,046,844✔





2264



  int32_t         code = TSDB_CODE_SUCCESS;




651,046,844✔





2265



  int32_t         lino = 0;




651,046,844✔





2266



  STableScanInfo* pInfo = pOperator->info;




651,046,844✔





2267



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




651,202,312✔





2268



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




651,149,509✔





2269



  QRY_PARAM_CHECK(ppRes);




651,079,068✔





2270



  qTrace("%s call", __FUNCTION__);




651,082,150✔





2271












2272



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




651,083,267✔





2273



  QUERY_CHECK_CODE(code, lino, _end);




651,307,275✔





2274












2275



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




651,307,275✔





2276



  if (pGetParam || pInfo->pBatchColMap) {




651,297,758✔





2277



    ETableScanDynType type = pGetParam ?




39,329,421✔





2278



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




39,327,673✔





2279



      DYN_TYPE_VSTB_BATCH_SCAN;










2280












2281



    code = doDynamicTableScanNext(pOperator, type, ppRes);




39,329,421✔





2282



    QUERY_CHECK_CODE(code, lino, _end);




39,339,019✔





2283












2284



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




39,338,387✔





2285



      return code;




38,404,968✔





2286



    }










2287



  }










2288












2289



  // scan table one by one sequentially










2290



  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {




612,881,071✔





2291



    int32_t       numOfTables = 0;




6,082,762✔





2292



    STableKeyInfo tInfo = {0};




6,082,762✔





2293



    pInfo->countState = TABLE_COUNT_STATE_END;




6,082,762✔





2294












2295



    while (1) {




5,673,388✔





2296



      SSDataBlock* result = NULL;




11,756,150✔





2297



      code = doGroupedTableScan(pOperator, &result);




11,754,250✔





2298



      QUERY_CHECK_CODE(code, lino, _end);




11,751,434✔





2299












2300



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




11,751,434✔





2301



        (*ppRes) = result;




6,031,450✔





2302



        return code;




6,036,807✔





2303



      }










2304












2305



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










2306



      pInfo->currentTable++;




5,720,966✔





2307












2308



      taosRLockLatch(&pTaskInfo->lock);




5,716,856✔





2309



      numOfTables = 0;




5,722,827✔





2310



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




5,722,827✔





2311



      if (code != TSDB_CODE_SUCCESS) {




5,718,398✔





2312



        taosRUnLockLatch(&pTaskInfo->lock);




×







2313



        TSDB_CHECK_CODE(code, lino, _end);




×







2314



      }










2315












2316



      if (pInfo->currentTable >= numOfTables) {




5,718,398✔





2317



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




45,955✔





2318



        taosRUnLockLatch(&pTaskInfo->lock);




45,955✔





2319



        (*ppRes) = NULL;




45,955✔





2320



        return code;




45,955✔





2321



      }










2322












2323



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




5,662,434✔





2324



      if (!tmp) {




5,671,246✔





2325



        taosRUnLockLatch(&pTaskInfo->lock);




×







2326



        (*ppRes) = NULL;




×







2327



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




×







2328



      }










2329












2330



      tInfo = *tmp;




5,671,246✔





2331



      taosRUnLockLatch(&pTaskInfo->lock);




5,667,127✔





2332












2333



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




5,675,962✔





2334



      QUERY_CHECK_CODE(code, lino, _end);




5,674,044✔





2335



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




5,674,044✔





2336



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










2337












2338



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




5,684,759✔





2339



      QUERY_CHECK_CODE(code, lino, _end);




5,667,387✔





2340



      pInfo->scanTimes = 0;




5,667,387✔





2341



    }










2342



  } else {  // scan table group by group sequentially










2343



    code = groupSeqTableScan(pOperator, ppRes);




606,719,522✔





2344



    QUERY_CHECK_CODE(code, lino, _end);




606,344,881✔





2345



  }










2346












2347



_end:




606,342,641✔





2348



  if (code != TSDB_CODE_SUCCESS) {




606,313,296✔





2349



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




2,872✔





2350



    pTaskInfo->code = code;




2,872✔





2351



    T_LONG_JMP(pTaskInfo->env, code);




2,872✔





2352



  }










2353












2354



  return code;




606,310,424✔





2355



}










2356












2357



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




20,571✔





2358



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




20,571✔





2359



  if (!pRecorder) {




20,571✔





2360



    return terrno;




×







2361



  }










2362



  STableScanInfo* pTableScanInfo = pOptr->info;




20,571✔





2363



  *pRecorder = pTableScanInfo->base.readRecorder;




20,571✔





2364



  *pOptrExplain = pRecorder;




20,571✔





2365



  *len = sizeof(SFileBlockLoadRecorder);




20,571✔





2366



  return 0;




20,571✔





2367



}










2368












2369



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




181,913,946✔





2370



  cleanupQueryTableDataCond(&pBase->cond);




181,913,946✔





2371



  cleanupQueryTableDataCond(&pBase->orgCond);




181,869,616✔





2372












2373



  if (pAPI->tsdReaderClose) {




181,882,425✔





2374



    pAPI->tsdReaderClose(pBase->dataReader);




181,908,299✔





2375



  }










2376



  pBase->dataReader = NULL;




181,809,816✔





2377












2378



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




181,837,095✔





2379



    taosArrayDestroy(pBase->matchInfo.pList);




181,852,746✔





2380



  }










2381












2382



  tableListDestroy(pBase->pTableListInfo);




181,802,838✔





2383



  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);




181,904,522✔





2384



  cleanupExprSupp(&pBase->pseudoSup);




181,860,154✔





2385



}




181,916,672✔





2386












2387



static void cleanReaderForVTable(STableScanInfo* pInfo){




5,212,751✔





2388



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




5,212,751✔





2389



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




5,213,151✔





2390



    while (pIter != NULL) {




5,235,170✔





2391



      void **reader = pIter;




22,343✔





2392



      if (*reader) {




22,343✔





2393



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




22,343✔





2394



          pInfo->base.dataReader = NULL;




20,071✔





2395



        }










2396



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




22,343✔





2397



      }










2398



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




22,343✔





2399



    }










2400



  }










2401



}




5,213,919✔





2402












2403



static void destroyTableScanOperatorInfo(void* param) {




156,646,043✔





2404



  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;




156,646,043✔





2405



  blockDataDestroy(pTableScanInfo->pResBlock);




156,646,043✔





2406



  blockDataDestroy(pTableScanInfo->pOrgBlock);




156,639,154✔





2407



  taosHashCleanup(pTableScanInfo->pIgnoreTables);




156,642,029✔





2408



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




156,609,165✔





2409



    cleanReaderForVTable(pTableScanInfo);




5,212,973✔





2410



    taosHashCleanup(pTableScanInfo->readerCache);




5,213,153✔





2411



  }










2412



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




156,611,859✔





2413



  taosArrayDestroy(pTableScanInfo->pBlockColMap);




156,625,479✔





2414



  taosMemoryFreeClear(param);




156,631,787✔





2415



}




156,608,520✔





2416












2417



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




156,518,712✔





2418



  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {




156,518,712✔





2419



    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);




7,290,416✔





2420



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




18,469,906✔





2421



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




11,184,184✔





2422



      if (pCol) {




11,195,303✔





2423



        pCol->info.noData = true;




11,193,341✔





2424



      }










2425



    }










2426



  }










2427



}




156,514,018✔





2428












2429



static int32_t resetTableScanOperatorState(SOperatorInfo* pOper) {




304,963✔





2430



  int32_t         code = TSDB_CODE_SUCCESS;




304,963✔





2431



  STableScanInfo*   pInfo = pOper->info;




304,963✔





2432



  pOper->status = OP_NOT_OPENED;




305,188✔





2433












2434



  pInfo->scanTimes = 0;




305,188✔





2435



  pInfo->currentGroupId = -1;




305,188✔





2436



  pInfo->tableEndIndex = -1;




304,963✔





2437



  pInfo->tableStartIndex = 0;




304,963✔





2438



  pInfo->currentTable = 0;




304,963✔





2439



  pInfo->scanMode = 0;




304,963✔





2440



  pInfo->countState = 0;




304,963✔





2441



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




305,188✔





2442












2443



  if (!pInfo->virtualStableScan) {




305,188✔





2444



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










2445



  //   cleanReaderForVTable(pInfo);










2446



  //   taosHashClear(pInfo->readerCache);










2447



  //   pInfo->readerCache = false;










2448



  // } else {










2449



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




141,811✔





2450



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




141,811✔





2451



    }










2452



    pInfo->base.dataReader = NULL;




141,811✔





2453



  }










2454



  tableListDestroy(pInfo->base.pTableListInfo);




304,963✔





2455



  pInfo->base.pTableListInfo = tableListCreate();




305,188✔





2456



  if (!pInfo->base.pTableListInfo) {




305,188✔





2457



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




×







2458



    return terrno;




×







2459



  }










2460



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




305,188✔





2461












2462



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




305,188✔





2463



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




305,188✔





2464



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




280,825✔





2465



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










2466



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




280,825✔





2467



    if (code) {




140,787✔





2468



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




×







2469



      return code;




×







2470



    }










2471



  }










2472












2473



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




305,188✔





2474



  cleanupQueryTableDataCond(&pInfo->base.cond);




305,188✔





2475



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




304,965✔





2476



  if (code) {




304,963✔





2477



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




×







2478



    return code;




×







2479



  }










2480



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




304,963✔





2481



    cleanupQueryTableDataCond(&pInfo->base.orgCond);




163,377✔





2482



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




163,377✔





2483



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




163,377✔





2484



  } 










2485












2486



  pOper->resultInfo.totalRows = 0;




304,963✔





2487



  blockDataEmpty(pInfo->pResBlock);




305,188✔





2488



  blockDataEmpty(pInfo->pOrgBlock);




305,188✔





2489



  taosHashClear(pInfo->pIgnoreTables);




305,188✔





2490



  taosArrayDestroy(pInfo->pBlockColMap);




305,188✔





2491



  pInfo->pBlockColMap = NULL;




305,188✔





2492



  return code;




304,963✔





2493



}










2494












2495



int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




156,637,058✔





2496



                                    STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










2497



                                    SOperatorInfo** pOptrInfo) {










2498



  QRY_PARAM_CHECK(pOptrInfo);




156,637,058✔





2499












2500



  int32_t         code = TSDB_CODE_SUCCESS;




156,646,129✔





2501



  int32_t         lino = 0;




156,646,129✔





2502



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




156,646,129✔





2503



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




156,624,720✔





2504



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




156,560,845✔





2505



    code = terrno;




55✔





2506



    goto _error;




×







2507



  }










2508












2509



  pOperator->pPhyNode = pTableScanNode;




156,561,842✔





2510



  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;




156,582,025✔





2511



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




156,584,326✔





2512












2513



  int32_t numOfCols = 0;




156,571,546✔





2514



  code =










2515



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




156,602,423✔





2516



  QUERY_CHECK_CODE(code, lino, _error);




156,509,361✔





2517












2518



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




156,509,361✔





2519



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




156,501,317✔





2520



  QUERY_CHECK_CODE(code, lino, _error);




156,311,814✔





2521












2522



  if (pScanNode->pScanPseudoCols != NULL) {




156,311,814✔





2523



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




50,588,213✔





2524



    pSup->pExprInfo = NULL;




50,623,441✔





2525



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




50,613,137✔





2526



    QUERY_CHECK_CODE(code, lino, _error);




50,596,259✔





2527












2528



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




50,596,259✔





2529



                                      &pTaskInfo->storageAPI.functionStore);










2530



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




50,571,111✔





2531



  }










2532












2533



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




156,335,460✔





2534



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




156,373,023✔





2535












2536



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




156,310,990✔





2537



  pInfo->base.readHandle = *readHandle;




156,276,830✔





2538



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




156,302,343✔





2539












2540



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




156,391,926✔





2541



  pInfo->sample.seed = taosGetTimestampSec();




156,273,218✔





2542












2543



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




156,462,203✔





2544



  initResultSizeInfo(&pOperator->resultInfo, 4096);




156,458,465✔





2545



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




156,287,780✔





2546



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




156,473,080✔





2547



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




156,275,780✔





2548












2549



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




156,251,450✔





2550



  QUERY_CHECK_CODE(code, lino, _error);




156,325,009✔





2551












2552



  pInfo->virtualStableScan = pScanNode->virtualStableScan;




156,325,009✔





2553



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




156,333,226✔





2554



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




5,207,356✔





2555



    pInfo->pResBlock = NULL;




5,206,238✔





2556



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




5,202,172✔





2557



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




5,203,437✔





2558



  }










2559












2560



  if (pInfo->virtualStableScan) {




156,284,469✔





2561



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




5,203,322✔





2562



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




5,215,659✔





2563



  }










2564












2565



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




156,324,399✔





2566



                            pTaskInfo->pStreamRuntimeInfo);




156,284,518✔





2567



  QUERY_CHECK_CODE(code, lino, _error);




156,379,916✔





2568












2569



  pInfo->currentGroupId = -1;




156,357,336✔





2570












2571



  pInfo->tableEndIndex = -1;




156,337,408✔





2572



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




156,360,520✔





2573



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




156,345,346✔





2574












2575



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




156,278,977✔





2576



                  pTaskInfo);










2577



  pOperator->exprSupp.numOfExprs = numOfCols;




156,281,715✔





2578












2579



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




156,310,291✔





2580



  pInfo->ignoreTag = false;




156,374,978✔





2581












2582



  pInfo->lastBatchIdx = -1;




156,349,634✔





2583



  pInfo->currentBatchIdx = 0;




156,287,135✔





2584



  pInfo->base.pTableListInfo = pTableListInfo;




156,289,602✔





2585



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




156,276,432✔





2586



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




×







2587



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




×







2588



      code = terrno;




×







2589



      QUERY_CHECK_CODE(code, lino, _error);




×







2590



    }










2591












2592



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




×







2593



  }










2594












2595



  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




156,276,432✔





2596












2597



  pOperator->fpSet = createOperatorFpSet(prepareTableScan, doTableScanNext,




156,131,655✔





2598



                                         NULL, destroyTableScanOperatorInfo,










2599



                                         optrDefaultBufFn,










2600



                                         getTableScannerExecInfo,










2601



                                         optrDefaultGetNextExtFn, NULL);










2602












2603



  setOperatorResetStateFn(pOperator, resetTableScanOperatorState); 




156,321,492✔





2604



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










2605



  pOperator->cost.openCost = 0;




156,297,022✔





2606



  *pOptrInfo = pOperator;




156,310,633✔





2607



  return TSDB_CODE_SUCCESS;




156,214,544✔





2608












2609



_error:




22,580✔





2610



  if (pInfo != NULL) {




22,580✔





2611



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




22,580✔





2612



    destroyTableScanOperatorInfo(pInfo);




22,580✔





2613



  }










2614












2615



  if (pOperator != NULL) {




22,580✔





2616



    pOperator->info = NULL;




22,580✔





2617



    destroyOperator(pOperator);




22,580✔





2618



  }










2619



  pTaskInfo->code = code;




22,580✔





2620



  return code;




22,580✔





2621



}










2622












2623



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




×







2624



  QRY_PARAM_CHECK(pOptrInfo);




×







2625












2626



  int32_t         code = 0;




×







2627



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




×







2628



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




×







2629



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




×







2630



    code = terrno;




×







2631



    goto _end;




×







2632



  }










2633












2634



  pInfo->base.dataReader = pReadHandle;




×







2635



  //  pInfo->prevGroupId       = -1;










2636












2637



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




×







2638



                  pInfo, pTaskInfo);










2639



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




×







2640



                                         optrDefaultGetNextExtFn, NULL);










2641



  *pOptrInfo = pOperator;




×







2642



  return code;




×







2643












2644



_end:




×







2645



  if (pInfo != NULL) {




×







2646



    taosMemoryFree(pInfo);




×







2647



  }










2648












2649



  if (pOperator != NULL) {




×







2650



    taosMemoryFree(pOperator);




×







2651



  }










2652












2653



  pTaskInfo->code = code;




×







2654



  return code;




×







2655



}










2656












2657



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




13,580✔





2658



  int32_t code = TSDB_CODE_SUCCESS;




13,580✔





2659



  int32_t lino = 0;




13,580✔





2660



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




13,580✔





2661



    return code;




1,644✔





2662



  }










2663



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




11,936✔





2664



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




11,936✔





2665



  bool hasUnqualified = false;




11,936✔





2666












2667



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




11,936✔





2668



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




11,936✔





2669












2670



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




11,936✔





2671



         VALUE_GET_TRIVIAL_DATUM(&offset->primaryKey));










2672



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




11,936✔





2673



                        TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);










2674












2675



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




11,936✔





2676



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




11,936✔





2677



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




42,876,118✔





2678



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




42,864,182✔





2679



    void*    data = colDataGetData(pColPk, i);




42,864,182✔





2680



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




42,866,486✔





2681



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




2,304✔





2682



        QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY, lino, _end);




×







2683



      }










2684



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




2,304✔





2685



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




2,304✔





2686



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




2,304✔





2687



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




2,304✔





2688



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




2,304✔





2689



      taosMemoryFree(tmq);




2,304✔





2690



    } else {










2691



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




42,861,878✔





2692



    }










2693












2694



    if (!p[i]) {




42,864,182✔





2695



      hasUnqualified = true;




15,282,752✔





2696



    }










2697



  }










2698












2699



  if (hasUnqualified) {




11,936✔





2700



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




4,019✔





2701



    QUERY_CHECK_CODE(code, lino, _end);




4,019✔





2702



  }










2703












2704



_end:




11,936✔





2705



  taosMemoryFree(p);




11,936✔





2706



  if (code != TSDB_CODE_SUCCESS) {




11,936✔





2707



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




×







2708



  }










2709



  return code;




11,936✔





2710



}










2711












2712



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




×







2713



  int32_t p1 = *(int32_t*)param1;




×







2714



  int32_t p2 = *(int32_t*)param2;




×







2715












2716



  if (p1 == p2) {




×







2717



    return 0;




×







2718



  } else {










2719



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




×







2720



  }










2721



}










2722












2723



static int32_t processBlock(SStreamScanInfo* pInfo) {




23,836,662✔





2724



  int32_t         code = TSDB_CODE_SUCCESS;




23,836,662✔





2725



  int32_t         lino = 0;




23,836,662✔





2726



  SOperatorInfo*  pOperator = pInfo->pStreamScanOp;




23,836,662✔





2727












2728



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




23,836,662✔





2729



  QUERY_CHECK_CODE(code, lino, _end);




23,836,662✔





2730












2731



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




23,836,662✔





2732



  QUERY_CHECK_CODE(code, lino, _end);




23,835,978✔





2733












2734



_end:




23,835,978✔





2735



  if (code != TSDB_CODE_SUCCESS) {




23,835,978✔





2736



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




×







2737



  }










2738



  return code;




23,836,320✔





2739



}










2740












2741



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




6,787,531✔





2742



  int32_t code = TSDB_CODE_SUCCESS;




6,787,531✔





2743



  int32_t lino = 0;




6,787,531✔





2744



  SValue  val = {0};




6,787,531✔





2745



  if (hasPrimaryKey) {




6,787,830✔





2746



    code = doBlockDataPrimaryKeyFilter(pBlock, offset);




13,580✔





2747



    if (code != TSDB_CODE_SUCCESS) {




13,580✔





2748



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




×







2749



      return code;




×







2750



    }










2751



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




13,580✔





2752












2753



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




13,580✔





2754



      return code;




3,731✔





2755



    }










2756



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




9,849✔





2757



    val.type = pColPk->info.type;




9,849✔





2758



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




9,849✔





2759



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




627✔





2760



        return TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY;




×







2761



      }










2762



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




627✔





2763



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




627✔





2764



      val.nData = varDataLen(tmp);




627✔





2765



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




627✔





2766



    } else {










2767



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




9,222✔





2768



    }










2769



  }










2770



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




6,784,099✔





2771












2772



_end:




6,784,099✔





2773



  if (code != TSDB_CODE_SUCCESS) {




6,784,099✔





2774



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




×







2775



  }










2776



  return code;




6,782,260✔





2777



}










2778












2779



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




24,024,018✔





2780



  int32_t        code = TSDB_CODE_SUCCESS;




24,024,018✔





2781



  int32_t        lino = 0;




24,024,018✔





2782



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




24,024,018✔





2783



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




24,026,077✔





2784












2785



  SStreamScanInfo* pInfo = pOperator->info;




24,025,393✔





2786



  const char*      id = GET_TASKID(pTaskInfo);




24,024,709✔





2787












2788



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




24,023,053✔





2789












2790



  if (isTaskKilled(pTaskInfo)) {




24,025,774✔





2791



    (*ppRes) = NULL;




×







2792



    return pTaskInfo->code;




×







2793



  }










2794












2795



  blockDataCleanup(pInfo->pRes);




24,026,419✔





2796



  int64_t st = taosGetTimestampMs();




24,026,419✔





2797



  










2798



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




24,026,419✔





2799



    while (1) {




5,765,367✔





2800



      SSDataBlock* pResult = NULL;




6,082,156✔





2801



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




6,080,864✔





2802



      QUERY_CHECK_CODE(code, lino, _end);




6,082,762✔





2803












2804



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




6,082,762✔





2805



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




6,036,807✔





2806



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




6,036,807✔





2807



        QUERY_CHECK_CODE(code, lino, _end);




6,036,175✔





2808



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




6,036,175✔





2809



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




6,037,123✔





2810



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




6,033,076✔





2811



          QUERY_CHECK_CODE(code, lino, _end);




6,032,444✔





2812



        }










2813



      } else {










2814



        break;










2815



      }










2816












2817



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




6,036,175✔





2818



        (*ppRes) = pInfo->pRes;




267,347✔





2819



        return code;




267,347✔





2820



      }










2821



      int64_t elapsed = taosGetTimestampMs() - st;




5,769,144✔





2822



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




5,769,144✔





2823



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




4,093✔





2824



          terrno = TSDB_CODE_TMQ_FETCH_TIMEOUT ;




×







2825



        }










2826



        (*ppRes) = pInfo->pRes;




3,145✔





2827



        return code;




3,145✔





2828



      }   










2829



    }










2830












2831



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




45,955✔





2832



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




45,955✔





2833












2834



    pTSInfo->base.dataReader = NULL;




45,955✔





2835



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




45,955✔





2836



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




45,955✔





2837



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




45,955✔





2838



    if (code == TSDB_CODE_WAL_LOG_NOT_EXIST) {




45,955✔





2839



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




14,185✔





2840



        (*ppRes) = NULL;




6,450✔





2841



      } else {










2842



        (*ppRes) = pInfo->pRes;




7,735✔





2843



      }










2844



      return 0;




14,185✔





2845



    }










2846



    QUERY_CHECK_CODE(code, lino, _end);




31,770✔





2847












2848



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




31,770✔





2849



  }










2850












2851



  while (1) {




94,920✔





2852



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




71,505,900✔





2853



                                                              pInfo->pCol2SlotId,










2854



                                                              pInfo->pPseudoExpr,










2855



                                                              pInfo->numOfPseudoExpr,










2856



                                                              pTaskInfo->streamInfo.sourceExcluded,




23,834,268✔





2857



                                                              pTaskInfo->streamInfo.minPollRows,










2858



                                                              pTaskInfo->streamInfo.timeout,










2859



                                                              pTaskInfo->streamInfo.enableReplay);




23,836,662✔





2860



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




23,836,044✔





2861



      goto _end;




×







2862



    }                                                              










2863



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




23,836,044✔





2864












2865



    // curVersion move to next










2866



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




23,836,320✔





2867












2868



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










2869



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




23,835,956✔





2870












2871



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




23,836,320✔





2872



            pTaskInfo->streamInfo.currentOffset.version);










2873



    int32_t ret = processBlock(pInfo);




23,836,684✔





2874



    if (ret != 0) {




23,836,320✔





2875



      code = ret;




×







2876



      goto _end;




×







2877



    }










2878



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




23,836,320✔





2879



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










2880



    










2881



    if (code != 0) {




23,836,662✔





2882



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




23,247,668✔





2883



        (*ppRes) = NULL;




11,023,930✔





2884



      } else {










2885



        (*ppRes) = pInfo->pRes;




12,223,738✔





2886



      }










2887



      return 0;




23,247,668✔





2888



    }










2889












2890



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




588,994✔





2891



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




99,906✔





2892



      (*ppRes) = pInfo->pRes;




494,074✔





2893



      return 0;




494,074✔





2894



    }










2895



  }










2896












2897



_end:




×







2898



  if (code != TSDB_CODE_SUCCESS) {




×







2899



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




×







2900



    pTaskInfo->code = code;




×







2901



    T_LONG_JMP(pTaskInfo->env, code);




×







2902



  }










2903



  (*ppRes) = NULL;




×







2904



  return code;




×







2905



}










2906












2907



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




327,887✔





2908



  int32_t code = TSDB_CODE_SUCCESS;




327,887✔





2909



  int32_t lino = 0;




327,887✔





2910



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




327,887✔





2911



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




329,738✔





2912












2913



  // Transfer the Array of STableKeyInfo into uid list.










2914



  int32_t size = 0;




329,738✔





2915



  code = tableListGetSize(pTableListInfo, &size);




329,738✔





2916



  QUERY_CHECK_CODE(code, lino, _end);




329,738✔





2917



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




9,625,461✔





2918



    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);




9,296,078✔





2919



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




9,295,802✔





2920



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




9,295,802✔





2921



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




9,295,723✔





2922



  }










2923












2924



  (*ppArrayRes) = tableIdList;




329,383✔





2925












2926



_end:




329,738✔





2927



  if (code != TSDB_CODE_SUCCESS) {




329,738✔





2928



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




×







2929



  }










2930



  return code;




329,738✔





2931



}










2932












2933



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




1,510,979✔





2934



  int32_t        code = TSDB_CODE_SUCCESS;




1,510,979✔





2935



  int32_t        lino = 0;




1,510,979✔





2936



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,510,979✔





2937



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,510,979✔





2938












2939



  SStreamRawScanInfo* pInfo = pOperator->info;




1,510,979✔





2940



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




1,510,979✔





2941



  pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL;




1,510,979✔





2942












2943



  qDebug("tmqsnap doRawScan called");




1,510,979✔





2944



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




1,510,979✔





2945



    bool hasNext = false;




1,505,486✔





2946



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




1,505,486✔





2947



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




1,504,639✔





2948



      if (code != TSDB_CODE_SUCCESS) {




1,503,144✔





2949



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




×







2950



        QUERY_CHECK_CODE(code, lino, _end);




×







2951



      }










2952



    }










2953












2954



    if (pInfo->dataReader && hasNext) {




1,503,991✔





2955



      if (isTaskKilled(pTaskInfo)) {




751,638✔





2956



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




×







2957



        return code;




×







2958



      }










2959












2960



      SSDataBlock* pBlock = NULL;




751,328✔





2961



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




751,937✔





2962



      QUERY_CHECK_CODE(code, lino, _end);




750,741✔





2963












2964



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




750,741✔





2965



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




751,040✔





2966



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




751,638✔





2967



        QUERY_CHECK_CODE(code, lino, _end);




750,730✔





2968



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




750,730✔





2969



        (*ppRes) = pBlock;




751,627✔





2970



        return code;




751,937✔





2971



      }










2972



    }










2973












2974



    SMetaTableInfo mtInfo = {0};




752,652✔





2975



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




752,951✔





2976



    QUERY_CHECK_CODE(code, lino, _end);




751,755✔





2977



    if (code != 0) {




751,755✔





2978



      destroyMetaTableInfo(&mtInfo);










2979



      QUERY_CHECK_CODE(code, lino, _end);




×







2980



    }










2981



    STqOffsetVal offset = {0};




751,755✔





2982



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




751,755✔





2983



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




10,039✔





2984



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




10,039✔





2985



    } else {










2986



      SValue val = {0};




743,521✔





2987



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




743,521✔





2988



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




742,336✔





2989



    }










2990



    destroyMetaTableInfo(&mtInfo);










2991



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




753,549✔





2992



    QUERY_CHECK_CODE(code, lino, _end);




753,549✔





2993



    (*ppRes) = NULL;




753,549✔





2994



    return code;




753,549✔





2995



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




5,493✔





2996



    SSnapContext* sContext = pInfo->sContext;




5,493✔





2997



    int64_t st = taosGetTimestampMs();




5,493✔





2998



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




40,828✔





2999



      void*   data = NULL;




40,150✔





3000



      int32_t dataLen = 0;




40,150✔





3001



      int16_t type = 0;




40,150✔





3002



      int64_t uid = 0;




40,150✔





3003



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




40,150✔





3004



        qError("tmqsnap getTableInfoFromSnapshot error");




×







3005



        taosMemoryFreeClear(data);




×







3006



        break;




×







3007



      }










3008












3009



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




40,150✔





3010



        STqOffsetVal offset = {0};




4,815✔





3011



        SValue       val = {0};




4,815✔





3012



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




×







3013



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




4,815✔





3014



        QUERY_CHECK_CODE(code, lino, _end);




4,815✔





3015



        break;




4,815✔





3016



      } else {










3017



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




35,335✔





3018



        SMqMetaRsp tmpMetaRsp = {0};




35,335✔





3019



        tmpMetaRsp.resMsgType = type;




35,335✔





3020



        tmpMetaRsp.metaRspLen = dataLen;




35,335✔





3021



        tmpMetaRsp.metaRsp = data;




35,335✔





3022



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




35,335✔





3023



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




4,283✔





3024



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




4,283✔





3025












3026



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




4,283✔





3027



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




4,283✔





3028



        }










3029



        int32_t  tempRes = TSDB_CODE_SUCCESS;




35,335✔





3030



        uint32_t len = 0;




35,335✔





3031



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




35,335✔





3032



        if (TSDB_CODE_SUCCESS != tempRes) {




35,335✔





3033



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3034



          taosMemoryFreeClear(data);




×







3035



          break;




×







3036



        }










3037












3038



        int32_t tLen = sizeof(SMqRspHead) + len;




35,335✔





3039



        void*   tBuf = taosMemoryCalloc(1, tLen);




35,335✔





3040



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




35,335✔





3041












3042



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




35,335✔





3043



        SEncoder encoder = {0};




35,335✔





3044



        tEncoderInit(&encoder, metaBuff, len);




35,335✔





3045



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




35,335✔





3046



        if (tempLen < 0) {




35,335✔





3047



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3048



          tEncoderClear(&encoder);




×







3049



          taosMemoryFreeClear(tBuf);




×







3050



          taosMemoryFreeClear(data);




×







3051



          break;




×







3052



        }










3053



        taosMemoryFreeClear(data);




35,335✔





3054



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




35,335✔





3055



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




35,335✔





3056












3057



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




35,335✔





3058



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




35,335✔





3059












3060



        int64_t elapsed = taosGetTimestampMs() - st;




35,335✔





3061



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




35,335✔





3062



          break;










3063



        }










3064



      }










3065



    }










3066












3067



    (*ppRes) = NULL;




5,493✔





3068



    return code;




5,493✔





3069



  }










3070












3071



_end:




×







3072



  if (code != TSDB_CODE_SUCCESS) {




×







3073



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




×







3074



    pTaskInfo->code = code;




×







3075



    T_LONG_JMP(pTaskInfo->env, code);




×







3076



  }










3077












3078



  (*ppRes) = NULL;




×







3079



  return code;




×







3080



}










3081












3082



static void destroyTmqRawScanOperatorInfo(void* param) {




122,332✔





3083



  SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;




122,332✔





3084



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




122,332✔





3085



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




122,332✔





3086



  tableListDestroy(pRawScan->pTableListInfo);




122,332✔





3087



  taosMemoryFree(pRawScan);




122,332✔





3088



}




122,332✔





3089












3090



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










3091



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










3092



// and schemas are decided when scanning










3093



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




122,044✔





3094



  // create operator










3095



  // create tb reader










3096



  // create meta reader










3097



  // create tq reader










3098












3099



  QRY_PARAM_CHECK(pOptrInfo);




122,044✔





3100



  int32_t code = TSDB_CODE_SUCCESS;




122,332✔





3101



  int32_t lino = 0;




122,332✔





3102












3103



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




122,332✔





3104



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




122,332✔





3105



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




122,332✔





3106



    code = terrno;




×







3107



    lino = __LINE__;




×







3108



    goto _end;




×







3109



  }










3110












3111



  pInfo->pTableListInfo = tableListCreate();




122,332✔





3112



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




122,332✔





3113



  pInfo->vnode = pHandle->vnode;




122,332✔





3114



  pInfo->pAPI = &pTaskInfo->storageAPI;




122,332✔





3115












3116



  pInfo->sContext = pHandle->sContext;




122,332✔





3117



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




122,332✔





3118



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




122,332✔





3119



                  pTaskInfo);










3120












3121



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




122,332✔





3122



                                         NULL, optrDefaultGetNextExtFn, NULL);










3123



  *pOptrInfo = pOperator;




122,332✔





3124



  return code;




122,332✔





3125












3126



_end:




×







3127



  if (code != TSDB_CODE_SUCCESS) {




×







3128



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




×







3129



  }










3130



  taosMemoryFree(pInfo);




×







3131



  taosMemoryFree(pOperator);




×







3132



  pTaskInfo->code = code;




×







3133



  return code;




×







3134



}










3135












3136



void destroyTmqScanOperatorInfo(void* param) {




329,738✔





3137



  if (param == NULL) {




329,738✔





3138



    return;




×







3139



  }










3140












3141



  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;




329,738✔





3142



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




329,738✔





3143



    destroyOperator(pStreamScan->pTableScanOp);




329,738✔





3144



  }










3145












3146



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




329,444✔





3147



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




329,738✔





3148



  }










3149



  if (pStreamScan->pVtableMergeHandles) {




329,770✔





3150



    taosHashCleanup(pStreamScan->pVtableMergeHandles);




×







3151



    pStreamScan->pVtableMergeHandles = NULL;




×







3152



  }










3153



  if (pStreamScan->pVtableMergeBuf) {




329,738✔





3154



    destroyDiskbasedBuf(pStreamScan->pVtableMergeBuf);




×







3155



    pStreamScan->pVtableMergeBuf = NULL;




×







3156



  }










3157



  if (pStreamScan->pVtableReadyHandles) {




329,738✔





3158



    taosArrayDestroy(pStreamScan->pVtableReadyHandles);




×







3159



    pStreamScan->pVtableReadyHandles = NULL;




×







3160



  }










3161



  if (pStreamScan->pTableListInfo) {




329,738✔





3162



    tableListDestroy(pStreamScan->pTableListInfo);




×







3163



    pStreamScan->pTableListInfo = NULL;




×







3164



  }










3165



  if (pStreamScan->pPseudoExpr) {




329,738✔





3166



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




191,348✔





3167



    taosMemoryFree(pStreamScan->pPseudoExpr);




191,348✔





3168



  }










3169












3170



  taosHashCleanup(pStreamScan->pCol2SlotId);




329,738✔





3171



  pStreamScan->pCol2SlotId = NULL;




329,387✔





3172












3173



  cleanupExprSupp(&pStreamScan->tbnameCalSup);




329,738✔





3174



  cleanupExprSupp(&pStreamScan->tagCalSup);




329,387✔





3175












3176



  blockDataDestroy(pStreamScan->pRes);




329,113✔





3177



  blockDataDestroy(pStreamScan->pDeleteDataRes);




329,738✔





3178



  blockDataDestroy(pStreamScan->pUpdateDataRes);




329,738✔





3179



  blockDataDestroy(pStreamScan->pCreateTbRes);




329,738✔





3180



  taosArrayDestroy(pStreamScan->pBlockLists);




329,738✔





3181



  blockDataDestroy(pStreamScan->pCheckpointRes);




329,472✔





3182












3183



  taosMemoryFree(pStreamScan);




329,738✔





3184



}










3185












3186



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




×







3187



  int32_t code = TSDB_CODE_SUCCESS;




×







3188



  int32_t lino = 0;




×







3189



  pBlock->info.rowSize += bytes;




×







3190



  SColumnInfoData infoData = {0};




×







3191



  infoData.info.type = type;




×







3192



  infoData.info.bytes = bytes;




×







3193



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




×







3194



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




×







3195












3196



_end:




×







3197



  if (code != TSDB_CODE_SUCCESS) {




×







3198



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




×







3199



  }










3200



  return code;




×







3201



}










3202












3203



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




329,738✔





3204



  size_t  numOfCols = LIST_LENGTH(pNodeList);




329,738✔





3205



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




2,076,562✔





3206



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




1,746,824✔





3207



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




1,746,824✔





3208



      *pTsSlotId = pNode->slotId;




329,738✔





3209



    }










3210



  }










3211



}




329,738✔





3212












3213



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




329,738✔





3214



  size_t  numOfCols = LIST_LENGTH(pNodeList);




329,738✔





3215



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




2,076,562✔





3216



    STargetNode* pNode = (STargetNode*)nodesListGetNode(pNodeList, i);




1,746,824✔





3217



    if (pNode == NULL) {




1,746,824✔





3218



      return TSDB_CODE_INVALID_PARA;




×







3219



    }










3220



    if (nodeType(pNode->pExpr) == QUERY_NODE_COLUMN) {




1,746,824✔





3221



      SColumnNode* pColNode = (SColumnNode*)pNode->pExpr;




1,746,824✔





3222



      int32_t code = taosHashPut(pCol2SlotId, (const void*)&pColNode->colId, sizeof(pColNode->colId), (const void*)&pNode->slotId, sizeof(pNode->slotId));




1,746,824✔





3223



      if (code != TSDB_CODE_SUCCESS) {




1,746,824✔





3224



        return code;




×







3225



      }










3226



    }










3227



  }










3228



  return TSDB_CODE_SUCCESS;




329,738✔





3229



}










3230












3231



int32_t createTmqScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,




329,380✔





3232



                                                  SNode* pTagCond, STableListInfo* pTableListInfo,










3233



                                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3234



  QRY_PARAM_CHECK(pOptrInfo);




329,380✔





3235












3236



  int32_t          code = TSDB_CODE_SUCCESS;




329,738✔





3237



  int32_t          lino = 0;




329,738✔





3238



  SStreamScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamScanInfo));




329,738✔





3239



  SOperatorInfo*   pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




329,738✔





3240



  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;




329,738✔





3241



  const char*      idstr = pTaskInfo->id.str;




329,738✔





3242












3243



  if (pInfo == NULL || pOperator == NULL) {




329,738✔





3244



    code = terrno;




×







3245



    goto _error;




×







3246



  }










3247












3248



  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;




329,738✔





3249



  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;




329,738✔





3250












3251



  pInfo->pTagCond = pTagCond;




329,738✔





3252



  pInfo->pGroupTags = pTableScanNode->pGroupTags;




329,738✔





3253












3254



  pInfo->primaryTsIndex = -1;




329,738✔





3255



  getTsSlotId(pScanPhyNode->pScanCols, &pInfo->primaryTsIndex);




329,738✔





3256



  pInfo->pCol2SlotId = taosHashInit(LIST_LENGTH(pScanPhyNode->pScanCols), taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_ENTRY_LOCK);




329,738✔





3257



  QUERY_CHECK_NULL(pInfo->pCol2SlotId, code, lino, _error, terrno);




329,738✔





3258



  code = buildCol2SlotId(pScanPhyNode->pScanCols, pInfo->pCol2SlotId);




329,738✔





3259



  QUERY_CHECK_CODE(code, lino, _error);




329,738✔





3260












3261



  SDataBlockDescNode* pNode = (SDataBlockDescNode*)pDescNode;




329,738✔





3262



  if (LIST_LENGTH(pNode->pSlots) != LIST_LENGTH(pScanPhyNode->pScanCols) + LIST_LENGTH(pScanPhyNode->pScanPseudoCols)) {




329,738✔





3263



    qError("%s column num mismatch between desc and scan node", __func__);




×







3264



    code = TSDB_CODE_TMQ_INVALID_MSG;




×







3265



    goto _error;




×







3266



  }










3267












3268



  pInfo->pPartTbnameSup = NULL;




329,412✔





3269



  if (pTableScanNode->pSubtable != NULL) {




329,412✔





3270



    SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo));




×







3271



    if (pSubTableExpr == NULL) {




×







3272



      code = terrno;




×







3273



      goto _error;




×







3274



    }










3275












3276



    pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;




×







3277



    code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);




×







3278



    QUERY_CHECK_CODE(code, lino, _error);




×







3279












3280



    if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) {




×







3281



      goto _error;




×







3282



    }










3283



  }










3284












3285



  if (pTableScanNode->pTags != NULL) {




329,412✔





3286



    int32_t    numOfTags;




×







3287



    SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags);




×







3288



    if (pTagExpr == NULL) {




×







3289



      goto _error;




×







3290



    }










3291



    code = initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore);




×







3292



    if (code != 0) {




×







3293



      goto _error;




×







3294



    }










3295



  }










3296












3297



  pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData));




329,412✔





3298



  TSDB_CHECK_NULL(pInfo->pBlockLists, code, lino, _error, terrno);




329,412✔





3299












3300



  SOperatorInfo* pTableScanOp = NULL;




329,412✔





3301



  code = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo, &pTableScanOp);




329,412✔





3302



  if (pTableScanOp == NULL || code != 0) {




329,412✔





3303



    qError("createTableScanOperatorInfo error, code:%d", pTaskInfo->code);




×







3304



    goto _error;




×







3305



  }










3306












3307



  STableScanInfo* pTSInfo = (STableScanInfo*)pTableScanOp->info;




329,412✔





3308



  if (pHandle->version > 0) {




329,412✔





3309



    pTSInfo->base.cond.endVersion = pHandle->version;




329,412✔





3310



  }










3311












3312



  STableKeyInfo* pList = NULL;




329,472✔





3313



  int32_t        num = 0;




329,472✔





3314



  code = tableListGetGroupList(pTableListInfo, 0, &pList, &num);




329,472✔





3315



  QUERY_CHECK_CODE(code, lino, _error);




329,146✔





3316












3317



  if (pHandle->initTableReader) {




329,146✔





3318



    pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;




329,412✔





3319



    pTSInfo->base.dataReader = NULL;




329,412✔





3320



  }










3321












3322



  if (pHandle->initTqReader) {




328,880✔





3323



    pInfo->tqReader = pAPI->tqReaderFn.tqReaderOpen(pHandle->vnode);




329,412✔





3324



    QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, terrno);




329,463✔





3325



  } else {










3326



    pInfo->tqReader = pHandle->tqReader;




×







3327



    QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




×







3328



  }










3329












3330



  pInfo->pUpdateInfo = NULL;




329,738✔





3331



  pInfo->pTableScanOp = pTableScanOp;




329,738✔





3332












3333



  pInfo->readHandle = *pHandle;




329,738✔





3334



  pTaskInfo->streamInfo.snapshotVer = pHandle->version;




329,738✔





3335



  pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup);




329,738✔





3336



  QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, terrno);




329,421✔





3337



  pInfo->hasPart = false;




329,421✔





3338












3339



  code = blockDataEnsureCapacity(pInfo->pCreateTbRes, 8);




329,738✔





3340



  QUERY_CHECK_CODE(code, lino, _error);




329,125✔





3341












3342



  SArray* tableIdList = NULL;




329,125✔





3343



  code = extractTableIdList(((STableScanInfo*)(pInfo->pTableScanOp->info))->base.pTableListInfo, &tableIdList);




328,850✔





3344



  QUERY_CHECK_CODE(code, lino, _error);




329,738✔





3345



  code = pAPI->tqReaderFn.tqReaderSetQueryTableList(pInfo->tqReader, tableIdList, idstr);




329,738✔





3346



  QUERY_CHECK_CODE(code, lino, _error);




329,738✔





3347



  taosArrayDestroy(tableIdList);




329,738✔





3348



  memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond));




329,738✔





3349












3350



  // create the pseduo columns info










3351



  code = createExprInfo(pScanPhyNode->pScanPseudoCols, NULL, &pInfo->pPseudoExpr, &pInfo->numOfPseudoExpr);




329,738✔





3352



  QUERY_CHECK_CODE(code, lino, _error);




329,738✔





3353












3354



  code = filterInitFromNode((SNode*)pScanPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0, NULL);




329,738✔





3355



  QUERY_CHECK_CODE(code, lino, _error);




329,738✔





3356












3357



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




329,738✔





3358



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




329,738✔





3359












3360



  pInfo->groupId = 0;




329,738✔





3361



  pInfo->igCheckGroupId = false;




329,738✔





3362



  pInfo->pStreamScanOp = pOperator;




329,738✔





3363



  pInfo->deleteDataIndex = 0;




329,738✔





3364



  code = createSpecialDataBlock(STREAM_DELETE_DATA, &pInfo->pDeleteDataRes);




329,738✔





3365



  QUERY_CHECK_CODE(code, lino, _error);




329,738✔





3366












3367



  pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX};




329,738✔





3368



  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateDataRes);




329,738✔





3369



  QUERY_CHECK_CODE(code, lino, _error);




329,738✔





3370












3371



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




329,738✔





3372



  pInfo->partitionSup.needCalc = false;




329,236✔





3373



  pInfo->igCheckUpdate = pTableScanNode->igCheckUpdate;




329,236✔





3374



  pInfo->igExpired = pTableScanNode->igExpired;




329,563✔





3375



  pInfo->twAggSup.maxTs = INT64_MIN;




329,411✔





3376



  pInfo->pState = pTaskInfo->streamInfo.pState;




328,919✔





3377



  pInfo->readerFn = pTaskInfo->storageAPI.tqReaderFn;




329,246✔





3378



  pInfo->pFillSup = NULL;




329,411✔





3379



  pInfo->useGetResultRange = false;




328,919✔





3380



  pInfo->pRangeScanRes = NULL;




328,919✔





3381












3382



  code = createSpecialDataBlock(STREAM_CHECKPOINT, &pInfo->pCheckpointRes);




329,411✔





3383



  QUERY_CHECK_CODE(code, lino, _error);




329,738✔





3384












3385



  setOperatorInfo(pOperator, STREAM_SCAN_OP_NAME, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, false, OP_NOT_OPENED, pInfo,




329,738✔





3386



                  pTaskInfo);










3387



  pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);




329,411✔





3388












3389



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doQueueScanNext, NULL, destroyTmqScanOperatorInfo, optrDefaultBufFn,




329,411✔





3390



                                         NULL, optrDefaultGetNextExtFn, NULL);










3391












3392



  *pOptrInfo = pOperator;




329,411✔





3393



  return code;




329,738✔





3394












3395



_error:




×







3396



  if (pInfo != NULL && pInfo->pTableScanOp != NULL) {




×







3397



    STableScanInfo* p = (STableScanInfo*)pInfo->pTableScanOp->info;




×







3398



    if (p != NULL) {




×







3399



      p->base.pTableListInfo = NULL;




×







3400



    }










3401



    destroyTmqScanOperatorInfo(pInfo);




×







3402



  }










3403












3404



  if (pOperator != NULL) {




×







3405



    pOperator->info = NULL;




×







3406



    destroyOperator(pOperator);




×







3407



  }










3408



  pTaskInfo->code = code;




×







3409



  return code;




×







3410



}










3411












3412



static int32_t doTagScanOneTable(SOperatorInfo* pOperator, SSDataBlock* pRes, SMetaReader* mr, SStorageAPI* pAPI) {




9,280,334✔





3413



  int32_t        code = TSDB_CODE_SUCCESS;




9,280,334✔





3414



  int32_t        lino = 0;




9,280,334✔





3415



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,280,334✔





3416



  STagScanInfo*  pInfo = pOperator->info;




9,282,344✔





3417



  SExprInfo*     pExprInfo = &pOperator->exprSupp.pExprInfo[0];




9,279,898✔





3418



  int32_t        count = pRes->info.rows;




9,277,842✔





3419












3420



  STableKeyInfo* item = tableListGetInfo(pInfo->pTableListInfo, pInfo->curPos);




9,277,516✔





3421



  if (!item) {




9,274,942✔





3422



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3423



           GET_TASKID(pTaskInfo));










3424



    tDecoderClear(&(*mr).coder);




×







3425



    goto _end;




×







3426



  }










3427












3428



  code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid);




9,274,942✔





3429



  tDecoderClear(&(*mr).coder);




9,284,015✔





3430



  if (code != TSDB_CODE_SUCCESS) {




9,282,666✔





3431



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3432



           GET_TASKID(pTaskInfo));










3433



    goto _end;




×







3434



  }










3435












3436



  char str[512];




9,282,570✔





3437



  for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




42,124,344✔





3438



    SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




32,841,253✔





3439












3440



    // refactor later










3441



    if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) {




32,841,070✔





3442



      STR_TO_VARSTR(str, (*mr).me.name);




3,760,632✔





3443



      code = colDataSetVal(pDst, (count), str, false);




3,759,274✔





3444



      QUERY_CHECK_CODE(code, lino, _end);




3,760,302✔





3445



    } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) {




29,078,139✔





3446



      code = colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false);




5,357,995✔





3447



      QUERY_CHECK_CODE(code, lino, _end);




5,357,995✔





3448



    } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) {




23,723,228✔





3449



      code = colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false);




15,215✔





3450



      QUERY_CHECK_CODE(code, lino, _end);




15,215✔





3451



    } else {  // it is a tag value










3452



      STagVal val = {0};




23,708,013✔





3453



      val.cid = pExprInfo[j].base.pParam[0].pCol->colId;




23,708,339✔





3454



      const char* p = pAPI->metaFn.extractTagVal((*mr).me.ctbEntry.pTags, pDst->info.type, &val);




23,709,743✔





3455












3456



      char* data = NULL;




23,709,382✔





3457



      if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {




23,709,382✔





3458



        data = tTagValToData((const STagVal*)p, false);




23,708,169✔





3459



      } else {










3460



        data = (char*)p;




1,386✔





3461



      }










3462












3463



      code = colDataSetVal(pDst, (count), data,




23,707,875✔





3464



                           (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));




23,706,521✔





3465



      QUERY_CHECK_CODE(code, lino, _end);




23,710,257✔





3466












3467



      if ((pDst->info.type != TSDB_DATA_TYPE_JSON) && (p != NULL) && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) &&




23,710,257✔





3468



          (data != NULL)) {










3469



        taosMemoryFree(data);




8,395,450✔





3470



      }










3471



    }










3472



  }










3473












3474



_end:




9,285,561✔





3475



  if (code != TSDB_CODE_SUCCESS) {




9,283,847✔





3476



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3477



    pTaskInfo->code = code;




×







3478



  } else {










3479



    pRes->info.rows++;




9,283,847✔





3480



  }










3481












3482



  return code;




9,282,473✔





3483



}










3484












3485



static void tagScanFreeUidTag(void* p) {




7,178,959✔





3486



  STUidTagInfo* pInfo = p;




7,178,959✔





3487



  if (pInfo->pTagVal != NULL) {




7,178,959✔





3488



    taosMemoryFree(pInfo->pTagVal);




7,180,692✔





3489



  }










3490



}




7,189,598✔





3491












3492



static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) {




1,627,933✔





3493



  SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData));




1,627,933✔





3494



  if (pColumnData == NULL) {




1,629,857✔





3495



    return terrno;




×







3496



  }










3497












3498



  pColumnData->info.type = pType->type;




1,629,857✔





3499



  pColumnData->info.bytes = pType->bytes;




1,629,627✔





3500



  pColumnData->info.scale = pType->scale;




1,629,132✔





3501



  pColumnData->info.precision = pType->precision;




1,627,180✔





3502












3503



  int32_t code = colInfoDataEnsureCapacity(pColumnData, numOfRows, true);




1,625,392✔





3504



  if (code != TSDB_CODE_SUCCESS) {




1,627,560✔





3505



    terrno = code;




×







3506



    taosMemoryFree(pColumnData);




×







3507



    return terrno;




×







3508



  }










3509












3510



  pParam->columnData = pColumnData;




1,627,560✔





3511



  pParam->colAlloced = true;




1,627,781✔





3512



  return TSDB_CODE_SUCCESS;




1,628,637✔





3513



}










3514












3515



static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {




10,015,002✔





3516



  int32_t                code = TSDB_CODE_SUCCESS;




10,015,002✔





3517



  int32_t                lino = 0;




10,015,002✔





3518



  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;




10,015,002✔





3519



  SColumnNode*           pSColumnNode = NULL;




10,015,002✔





3520



  if (QUERY_NODE_COLUMN == nodeType((*pNode))) {




10,016,623✔





3521



    pSColumnNode = *(SColumnNode**)pNode;




2,810,669✔





3522



  } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {




7,214,816✔





3523



    SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);




512✔





3524



    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {




512✔





3525



      pSColumnNode = NULL;




×







3526



      pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);




×







3527



      if (NULL == pSColumnNode) {




×







3528



        return DEAL_RES_ERROR;




×







3529



      }










3530



      pSColumnNode->colId = -1;




×







3531



      pSColumnNode->colType = COLUMN_TYPE_TBNAME;




×







3532



      pSColumnNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




×







3533



      pSColumnNode->node.resType.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;




×







3534



      nodesDestroyNode(*pNode);




×







3535



      *pNode = (SNode*)pSColumnNode;




×







3536



    } else {










3537



      return DEAL_RES_CONTINUE;




512✔





3538



    }










3539



  } else {










3540



    return DEAL_RES_CONTINUE;




7,206,156✔





3541



  }










3542












3543



  void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));




2,812,089✔





3544



  if (!data) {




2,811,252✔





3545



    code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));




1,631,773✔





3546



    if (code == TSDB_CODE_DUP_KEY) {




1,632,971✔





3547



      code = TSDB_CODE_SUCCESS;




×







3548



    }










3549



    QUERY_CHECK_CODE(code, lino, _end);




1,632,971✔





3550



    pSColumnNode->slotId = pCtx->index++;




1,632,971✔





3551



    SColumnInfo cInfo = {.colId = pSColumnNode->colId,




1,632,115✔





3552



                         .type = pSColumnNode->node.resType.type,




1,628,935✔





3553



                         .bytes = pSColumnNode->node.resType.bytes};




1,631,281✔





3554



    void*       tmp = taosArrayPush(pCtx->cInfoList, &cInfo);




1,630,281✔





3555



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,632,698✔





3556



  } else {










3557



    SColumnNode* col = *(SColumnNode**)data;




1,179,479✔





3558



    pSColumnNode->slotId = col->slotId;




1,179,479✔





3559



  }










3560












3561



_end:




2,808,912✔





3562



  if (code != TSDB_CODE_SUCCESS) {




2,810,123✔





3563



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




2,763✔





3564



    return DEAL_RES_ERROR;




×







3565



  }










3566



  return DEAL_RES_CONTINUE;




2,807,360✔





3567



}










3568












3569



static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode,




1,630,698✔





3570



                                      SStorageAPI* pAPI, STagScanInfo* pInfo, void* pStreamRuntimeInfo) {










3571



  int32_t code = TSDB_CODE_SUCCESS;




1,630,698✔





3572



  int32_t lino = 0;




1,630,698✔





3573



  int32_t numOfTables = taosArrayGetSize(aUidTags);




1,630,698✔





3574



  SArray* pBlockList = NULL;




1,630,212✔





3575












3576



  SSDataBlock* pResBlock = createTagValBlockForFilter(pInfo->filterCtx.cInfoList, numOfTables, aUidTags, pVnode, pAPI);




1,630,212✔





3577



  QUERY_CHECK_NULL(pResBlock, code, lino, _end, terrno);




1,628,780✔





3578












3579



  pBlockList = taosArrayInit(1, POINTER_BYTES);




1,628,780✔





3580



  QUERY_CHECK_NULL(pBlockList, code, lino, _end, terrno);




1,629,857✔





3581












3582



  void* tmp = taosArrayPush(pBlockList, &pResBlock);




1,630,698✔





3583



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,630,698✔





3584












3585



  SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)};




1,630,698✔





3586












3587



  SScalarParam output = {0};




1,629,496✔





3588



  code = tagScanCreateResultData(&type, numOfTables, &output);




1,630,337✔





3589



  QUERY_CHECK_CODE(code, lino, _end);




1,626,940✔





3590












3591



  gTaskScalarExtra.pStreamInfo = (void*)pStreamRuntimeInfo;




1,626,940✔





3592



  gTaskScalarExtra.pStreamRange = NULL;




1,626,940✔





3593



  code = scalarCalculate(pTagCond, pBlockList, &output, &gTaskScalarExtra);




1,626,585✔





3594



  QUERY_CHECK_CODE(code, lino, _end);




1,626,820✔





3595












3596



  bool* result = (bool*)output.columnData->pData;




1,626,820✔





3597



  for (int32_t i = 0; i < numOfTables; ++i) {




4,064,646✔





3598



    if (result[i]) {




2,442,131✔





3599



      void* tmp = taosArrayPush(aFilterIdxs, &i);




2,303,003✔





3600



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




2,303,003✔





3601



    }










3602



  }










3603












3604



  colDataDestroy(output.columnData);




1,627,659✔





3605



  taosMemoryFreeClear(output.columnData);




1,627,442✔





3606












3607



_end:




1,627,445✔





3608



  blockDataDestroy(pResBlock);




1,627,092✔





3609



  taosArrayDestroy(pBlockList);




1,625,530✔





3610



  if (code != TSDB_CODE_SUCCESS) {




1,620,739✔





3611



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3612



  }










3613



  return code;




1,620,739✔





3614



}










3615












3616



static int32_t tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo,




29,364,608✔





3617



                                         SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex,










3618



                                         const SStorageAPI* pAPI, void* pVnode) {










3619



  int32_t code = TSDB_CODE_SUCCESS;




29,364,608✔





3620



  int32_t lino = 0;




29,364,608✔





3621



  if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) {




29,364,608✔





3622



    if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) {  // tbname




14,010,050✔





3623



      char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×







3624



      STR_TO_VARSTR(str, "ctbidx");




×







3625












3626



      code = colDataSetVal(pColInfo, rowIndex, str, false);




×







3627



      QUERY_CHECK_CODE(code, lino, _end);




×







3628



    } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) {




13,990,918✔





3629



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false);




6,986,083✔





3630



      QUERY_CHECK_CODE(code, lino, _end);




7,002,599✔





3631



    } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) {




7,003,799✔





3632



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false);




6,995,163✔





3633



      QUERY_CHECK_CODE(code, lino, _end);




7,001,464✔





3634



    }










3635



  } else {










3636



    STagVal tagVal = {0};




15,348,744✔





3637



    tagVal.cid = pExprInfo->base.pParam[0].pCol->colId;




15,349,167✔





3638



    if (pUidTagInfo->pTagVal == NULL) {




15,358,131✔





3639



      colDataSetNULL(pColInfo, rowIndex);




×







3640



    } else {










3641



      const char* p = pAPI->metaFn.extractTagVal(pUidTagInfo->pTagVal, pColInfo->info.type, &tagVal);




15,350,218✔





3642












3643



      if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {




15,353,369✔





3644



        colDataSetNULL(pColInfo, rowIndex);




5,837✔





3645



      } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {




15,346,838✔





3646



        code = colDataSetVal(pColInfo, rowIndex, p, false);




×







3647



        QUERY_CHECK_CODE(code, lino, _end);




×







3648



      } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {




19,119,787✔





3649



        if (IS_STR_DATA_BLOB(pColInfo->info.type)) {




3,787,371✔





3650



          QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_TAG, lino, _end);




×







3651



        }










3652



        char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);




3,775,415✔





3653



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




3,774,315✔





3654












3655



        varDataSetLen(tmp, tagVal.nData);




3,774,315✔





3656



        memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);




3,771,395✔





3657



        code = colDataSetVal(pColInfo, rowIndex, tmp, false);




3,770,798✔





3658



        taosMemoryFree(tmp);




3,780,123✔





3659



        QUERY_CHECK_CODE(code, lino, _end);




3,776,580✔





3660



      } else {










3661



        code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false);




11,541,272✔





3662



        QUERY_CHECK_CODE(code, lino, _end);




11,570,311✔





3663



      }










3664



    }










3665



  }










3666












3667



_end:




29,364,002✔





3668



  if (code != TSDB_CODE_SUCCESS) {




29,364,002✔





3669



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3670



  }










3671



  return code;




29,350,025✔





3672



}










3673












3674



static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags,




4,592,236✔





3675



                                      SArray* aFilterIdxs, bool ignoreFilterIdx, SStorageAPI* pAPI) {










3676



  int32_t       code = TSDB_CODE_SUCCESS;




4,592,236✔





3677



  int32_t       lino = 0;




4,592,236✔





3678



  STagScanInfo* pInfo = pOperator->info;




4,592,236✔





3679



  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];




4,595,070✔





3680



  if (!ignoreFilterIdx) {




4,592,397✔





3681



    size_t szTables = taosArrayGetSize(aFilterIdxs);




1,621,974✔





3682



    for (int i = 0; i < szTables; ++i) {




3,923,283✔





3683



      int32_t       idx = *(int32_t*)taosArrayGet(aFilterIdxs, i);




2,301,154✔





3684



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);




2,299,532✔





3685



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




2,301,269✔





3686



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




13,107,825✔





3687



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




10,797,227✔





3688



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




10,808,934✔





3689



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




10,808,934✔





3690



        QUERY_CHECK_CODE(code, lino, _end);




10,806,556✔





3691



      }










3692



    }










3693



  } else {










3694



    size_t szTables = taosArrayGetSize(aUidTags);




2,970,423✔





3695



    for (int i = 0; i < szTables; ++i) {




7,721,457✔





3696



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);




4,750,303✔





3697



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




4,750,177✔





3698



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




23,283,640✔





3699



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




18,538,576✔





3700



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




18,539,148✔





3701



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




18,539,148✔





3702



        QUERY_CHECK_CODE(code, lino, _end);




18,533,463✔





3703



      }










3704



    }










3705



  }










3706












3707



_end:




2,971,154✔





3708



  if (code != TSDB_CODE_SUCCESS) {




4,593,283✔





3709



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3710



  }










3711



  return code;




4,598,455✔





3712



}










3713












3714



static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




9,168,928✔





3715



  int32_t        code = TSDB_CODE_SUCCESS;




9,168,928✔





3716



  int32_t        lino = 0;




9,168,928✔





3717



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,168,928✔





3718



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




9,170,978✔





3719












3720



  STagScanInfo* pInfo = pOperator->info;




9,170,649✔





3721



  SSDataBlock*  pRes = pInfo->pRes;




9,171,202✔





3722












3723



  QRY_PARAM_CHECK(ppRes);




9,167,375✔





3724












3725



  if (pOperator->status == OP_EXEC_DONE) {




9,168,726✔





3726



    return TSDB_CODE_SUCCESS;




4,503,360✔





3727



  }










3728



  blockDataCleanup(pRes);




4,662,641✔





3729












3730



  if (pInfo->pCtbCursor == NULL) {




4,672,423✔





3731



    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);




4,670,866✔





3732



    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);




4,674,240✔





3733



  } else {










3734



    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);




×







3735



    QUERY_CHECK_CODE(code, lino, _end);




×







3736



  }










3737












3738



  SArray* aUidTags = pInfo->aUidTags;




4,672,049✔





3739



  SArray* aFilterIdxs = pInfo->aFilterIdxs;




4,671,904✔





3740



  int32_t count = 0;




4,671,550✔





3741



  bool    ctbCursorFinished = false;




4,671,550✔





3742



  while (1) {




85,347✔





3743



    taosArrayClearEx(aUidTags, tagScanFreeUidTag);




4,756,897✔





3744



    taosArrayClear(aFilterIdxs);




4,758,757✔





3745












3746



    int32_t numTables = 0;




4,758,660✔





3747



    while (numTables < pOperator->resultInfo.capacity) {




11,951,741✔





3748



      SMCtbCursor* pCur = pInfo->pCtbCursor;




11,950,951✔





3749



      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);




11,952,162✔





3750



      if (uid == 0) {




11,948,536✔





3751



        ctbCursorFinished = true;




4,762,282✔





3752



        break;




4,762,282✔





3753



      }










3754



      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};




7,186,254✔





3755



      info.pTagVal = taosMemoryMalloc(pCur->vLen);




7,181,213✔





3756



      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);




7,179,318✔





3757












3758



      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);




7,179,318✔





3759



      void* tmp = taosArrayPush(aUidTags, &info);




7,192,289✔





3760



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




7,192,289✔





3761



      ++numTables;




7,192,289✔





3762



    }










3763












3764



    if (numTables == 0) {




4,762,282✔





3765



      break;




159,927✔





3766



    }










3767



    bool ignoreFilterIdx = true;




4,602,355✔





3768



    if (pInfo->pTagCond != NULL) {




4,602,355✔





3769



      ignoreFilterIdx = false;




1,630,698✔





3770



      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo, pTaskInfo->pStreamRuntimeInfo);




1,630,698✔





3771



      QUERY_CHECK_CODE(code, lino, _end);




1,623,545✔





3772



    } else {










3773



      ignoreFilterIdx = true;




2,970,294✔





3774



    }










3775












3776



    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);




4,593,839✔





3777



    QUERY_CHECK_CODE(code, lino, _end);




4,597,961✔





3778












3779



    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);




4,597,961✔





3780












3781



    if (count != 0) {




4,596,260✔





3782



      break;




4,510,913✔





3783



    }










3784



  }










3785












3786



  if (count > 0) {




4,670,840✔





3787



    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);




4,510,774✔





3788



  }










3789



  if (count == 0 || ctbCursorFinished) {




4,672,391✔





3790



    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




4,671,896✔





3791



    pInfo->pCtbCursor = NULL;




4,664,758✔





3792



    setOperatorCompleted(pOperator);




4,666,963✔





3793



  }










3794












3795



  pRes->info.rows = count;




4,665,230✔





3796



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




4,663,527✔





3797



  if (bLimitReached) {




4,669,640✔





3798



    setOperatorCompleted(pOperator);




×







3799



  }










3800












3801



  pOperator->resultInfo.totalRows += pRes->info.rows;




4,669,640✔





3802



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




4,661,596✔





3803












3804



_end:




4,657,840✔





3805



  if (code != TSDB_CODE_SUCCESS) {




4,657,840✔





3806



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3807



    pTaskInfo->code = code;




×







3808



    T_LONG_JMP(pTaskInfo->env, code);




×







3809



  }










3810












3811



  return code;




4,657,840✔





3812



}










3813












3814



static int32_t createTagScanTableListInfoFromParam(SOperatorInfo* pOperator) {




3,459,081✔





3815



  STagScanInfo*          pInfo = pOperator->info;




3,459,081✔





3816



  SExecTaskInfo*         pTaskInfo = pOperator->pTaskInfo;




3,459,081✔





3817



  int32_t                code = 0;




3,459,081✔





3818



  STableListInfo*        pListInfo = pInfo->pTableListInfo;




3,459,081✔





3819



  STagScanOperatorParam* pParam = (STagScanOperatorParam*)pOperator->pOperatorGetParam->value;




3,459,081✔





3820



  tb_uid_t               pUid = pParam->vcUid;




3,459,081✔





3821












3822



  // qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",










3823



  //        pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList),










3824



  //        pOperator->status);










3825












3826



  STableKeyInfo info = {.groupId = 0};




3,459,081✔





3827












3828



  int32_t tableIdx = 0;




3,459,081✔





3829



  taosHashClear(pListInfo->map);




3,459,081✔





3830



  taosArrayClear(pListInfo->pTableList);




3,459,081✔





3831












3832



  if (taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {




3,459,081✔





3833



    if (TSDB_CODE_DUP_KEY == terrno) {




×







3834



    } else {










3835



      return terrno;




×







3836



    }










3837



  }










3838












3839



  info.uid = pUid;




3,459,081✔





3840



  void* p = taosArrayPush(pListInfo->pTableList, &info);




3,459,081✔





3841



  if (p == NULL) {




3,459,081✔





3842



    return terrno;




×







3843



  }










3844












3845



  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));




3,459,081✔





3846












3847



  return code;




3,459,081✔





3848



}










3849












3850



static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




6,628,640✔





3851



  int32_t       code = TSDB_CODE_SUCCESS;




6,628,640✔





3852



  int32_t       lino = 0;




6,628,640✔





3853



  STagScanInfo* pInfo = pOperator->info;




6,628,640✔





3854



  if (pOperator->pOperatorGetParam) {




6,629,228✔





3855



    pOperator->resultInfo.totalRows = 0;




3,459,081✔





3856



    pOperator->dynamicTask = true;




3,459,081✔





3857



    pInfo->curPos = 0;




3,459,081✔





3858



    code = createTagScanTableListInfoFromParam(pOperator);




3,459,081✔





3859



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




3,459,081✔





3860



    pOperator->pOperatorGetParam = NULL;




3,459,081✔





3861



    QUERY_CHECK_CODE(code, lino, _end);




3,459,081✔





3862












3863



    if (pOperator->status == OP_EXEC_DONE) {




3,459,081✔





3864



      pOperator->status = OP_OPENED;




1,864,832✔





3865



    }










3866



  }










3867












3868



  if (pOperator->status == OP_EXEC_DONE) {




6,630,830✔





3869



    (*ppRes) = NULL;




1,572,482✔





3870



    return code;




1,572,996✔





3871



  }










3872












3873



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




5,056,484✔





3874



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




5,058,352✔





3875












3876



  SExprInfo*   pExprInfo = &pOperator->exprSupp.pExprInfo[0];




5,056,232✔





3877



  SSDataBlock* pRes = pInfo->pRes;




5,054,428✔





3878



  blockDataCleanup(pRes);




5,053,010✔





3879












3880



  int32_t size = 0;




5,059,050✔





3881



  code = tableListGetSize(pInfo->pTableListInfo, &size);




5,059,376✔





3882



  QUERY_CHECK_CODE(code, lino, _end);




5,057,182✔





3883












3884



  if (size == 0) {




5,057,182✔





3885



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




17,635✔





3886



    (*ppRes) = NULL;




17,635✔





3887



    return code;




17,635✔





3888



  }










3889












3890



  SMetaReader mr = {0};




5,039,547✔





3891



  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




5,038,707✔





3892



  pRes->info.rows = 0;




5,042,585✔





3893












3894



  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {




14,325,404✔





3895



    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);




9,276,548✔





3896



    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD &&




9,283,886✔





3897



        code != TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED) {










3898



      // ignore other error










3899



      code = TSDB_CODE_SUCCESS;




9,285,240✔





3900



    }










3901



    QUERY_CHECK_CODE(code, lino, _end);




9,283,886✔





3902












3903



    if (++pInfo->curPos >= size) {




9,283,886✔





3904



      setOperatorCompleted(pOperator);




5,042,585✔





3905



    }










3906



  }










3907












3908



  pAPI->metaReaderFn.clearReader(&mr);




5,044,833✔





3909



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




5,042,585✔





3910



  if (bLimitReached) {




5,042,392✔





3911



    setOperatorCompleted(pOperator);




×







3912



  }










3913












3914



  // qDebug("QInfo:0x%" PRIx64 ", create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);










3915



  if (pOperator->status == OP_EXEC_DONE) {




5,042,392✔





3916



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




5,042,585✔





3917



  }










3918












3919



  pOperator->resultInfo.totalRows += pRes->info.rows;




5,042,392✔





3920












3921



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




5,042,585✔





3922



_end:




5,042,585✔





3923



  if (code != TSDB_CODE_SUCCESS) {




5,042,392✔





3924



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3925



    pTaskInfo->code = code;




×







3926



    T_LONG_JMP(pTaskInfo->env, code);




×







3927



  }










3928



  return code;




5,042,392✔





3929



}










3930












3931



static void destroyTagScanOperatorInfo(void* param) {




8,188,751✔





3932



  STagScanInfo* pInfo = (STagScanInfo*)param;




8,188,751✔





3933



  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {




8,188,751✔





3934



    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




×







3935



  }










3936



  taosHashCleanup(pInfo->filterCtx.colHash);




8,197,545✔





3937



  taosArrayDestroy(pInfo->filterCtx.cInfoList);




8,177,142✔





3938



  taosArrayDestroy(pInfo->aFilterIdxs);




8,184,303✔





3939



  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);




8,182,913✔





3940












3941



  blockDataDestroy(pInfo->pRes);




8,188,278✔





3942



  taosArrayDestroy(pInfo->matchInfo.pList);




8,190,624✔





3943



  tableListDestroy(pInfo->pTableListInfo);




8,185,772✔





3944












3945



  pInfo->pRes = NULL;




8,194,829✔





3946



  pInfo->pTableListInfo = NULL;




8,196,886✔





3947



  taosMemoryFreeClear(param);




8,192,153✔





3948



}




8,198,270✔





3949












3950



static int32_t resetTagScanOperatorState(SOperatorInfo* pOper) {




4,724✔





3951



  int32_t         code = TSDB_CODE_SUCCESS;




4,724✔





3952



  STagScanInfo*   pInfo = pOper->info;




4,724✔





3953












3954



  pOper->status = OP_NOT_OPENED;




4,724✔





3955



  STagScanPhysiNode* pTagScanNode = (STagScanPhysiNode*)pOper->pPhyNode;




4,724✔





3956



  if (pTagScanNode->onlyMetaCtbIdx) {




4,724✔





3957



      SExecTaskInfo* pTaskInfo = pOper->pTaskInfo;




2,048✔





3958



      SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




2,048✔





3959



      pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




2,048✔





3960



      pInfo->pCtbCursor = NULL;




2,048✔





3961



  } else {










3962



      pInfo->curPos = 0;




2,676✔





3963



  }










3964












3965



  return code;




4,724✔





3966



}










3967












3968



int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,




8,198,501✔





3969



                                  STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond,










3970



                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3971



  QRY_PARAM_CHECK(pOptrInfo);




8,198,501✔





3972












3973



  int32_t         code = TSDB_CODE_SUCCESS;




8,199,463✔





3974



  int32_t         lino = 0;




8,199,463✔





3975



  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;




8,199,463✔





3976



  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));




8,199,463✔





3977



  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




8,189,580✔





3978



  if (pInfo == NULL || pOperator == NULL) {




8,183,055✔





3979



    code = terrno;




×







3980



    goto _error;




×







3981



  }










3982



  pOperator->pPhyNode = pTagScanNode;




8,183,055✔





3983



  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;




8,183,826✔





3984












3985



  int32_t    numOfExprs = 0;




8,186,745✔





3986



  SExprInfo* pExprInfo = NULL;




8,188,226✔





3987












3988



  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);




8,187,993✔





3989



  QUERY_CHECK_CODE(code, lino, _error);




8,191,418✔





3990












3991



  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);




8,191,418✔





3992



  QUERY_CHECK_CODE(code, lino, _error);




8,168,971✔





3993












3994



  int32_t num = 0;




8,168,971✔





3995



  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




8,173,448✔





3996



  QUERY_CHECK_CODE(code, lino, _error);




8,172,808✔





3997












3998



  pInfo->pTagCond = pTagCond;




8,172,808✔





3999



  pInfo->pTagIndexCond = pTagIndexCond;




8,175,289✔





4000



  pInfo->suid = pPhyNode->suid;




8,179,185✔





4001



  pInfo->pStorageAPI = &pTaskInfo->storageAPI;




8,179,199✔





4002












4003



  pInfo->pTableListInfo = pTableListInfo;




8,172,519✔





4004



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




8,176,348✔





4005



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




8,187,887✔





4006












4007



  pInfo->readHandle = *pReadHandle;




8,170,077✔





4008



  pInfo->curPos = 0;




8,182,082✔





4009












4010



  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);




8,163,229✔





4011



  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,




8,167,471✔





4012



                  pTaskInfo);










4013



  initResultSizeInfo(&pOperator->resultInfo, 4096);




8,165,678✔





4014



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




8,163,514✔





4015



  QUERY_CHECK_CODE(code, lino, _error);




8,200,256✔





4016












4017



  if (pTagScanNode->onlyMetaCtbIdx) {




8,200,256✔





4018



    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));




4,679,999✔





4019



    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);




4,681,589✔





4020












4021



    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));




4,680,724✔





4022



    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);




4,680,715✔





4023












4024



    pInfo->filterCtx.colHash =




4,679,019✔





4025



        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);




4,680,716✔





4026



    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);




4,680,245✔





4027












4028



    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));




4,676,755✔





4029



    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);




4,680,879✔





4030












4031



    if (pInfo->pTagCond != NULL) {




4,673,906✔





4032



      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);




1,631,275✔





4033



    }










4034



  }










4035



  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;




8,198,776✔





4036



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,




8,198,351✔





4037



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










4038



  setOperatorResetStateFn(pOperator, resetTagScanOperatorState);     




8,192,170✔





4039



  










4040



  *pOptrInfo = pOperator;




8,186,570✔





4041



  return code;




8,187,846✔





4042












4043



_error:




×







4044



  if (pInfo) {




×







4045



    pInfo->pTableListInfo = NULL;




×







4046



  }










4047












4048



  if (pInfo != NULL) destroyTagScanOperatorInfo(pInfo);




×







4049



  if (pOperator != NULL) {




×







4050



    pOperator->info = NULL;




×







4051



    destroyOperator(pOperator);




×







4052



  }










4053



  return code;




×







4054



}










4055












4056



// table merge scan operator










4057












4058



static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {




239,235,873✔





4059



  int32_t                 left = *(int32_t*)pLeft;




239,235,873✔





4060



  int32_t                 right = *(int32_t*)pRight;




239,236,595✔





4061



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




239,238,400✔





4062












4063



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




239,238,400✔





4064



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




239,240,205✔





4065












4066



  if (leftIdx == -1) {




239,244,176✔





4067



    return 1;




204,823,376✔





4068



  } else if (rightIdx == -1) {




34,420,800✔





4069



    return -1;




340,800✔





4070



  }










4071












4072



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




34,080,000✔





4073



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




34,080,000✔





4074



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




34,080,000✔





4075



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




34,080,000✔





4076



    ret = -1 * ret;




×







4077



  }










4078



  return ret;




34,080,000✔





4079



}










4080












4081



static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) {




×







4082



  int32_t                 left = *(int32_t*)pLeft;




×







4083



  int32_t                 right = *(int32_t*)pRight;




×







4084



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




×







4085












4086



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




×







4087



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




×







4088












4089



  if (leftIdx == -1) {




×







4090



    return 1;




×







4091



  } else if (rightIdx == -1) {




×







4092



    return -1;




×







4093



  }










4094












4095



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




×







4096



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




×







4097



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




×







4098



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




×







4099



    ret = -1 * ret;




×







4100



  }










4101



  if (ret == 0 && pInfo->pPkOrderInfo) {




×







4102



    ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx,




×







4103



                               pInfo->pPkOrderInfo);




×







4104



  }










4105



  return ret;




×







4106



}










4107












4108



int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {




3,040,965✔





4109



  int32_t code = TSDB_CODE_SUCCESS;




3,040,965✔





4110



  int32_t lino = 0;




3,040,965✔





4111



  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));




3,040,965✔





4112



  dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));




3,040,965✔





4113



  QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);




3,032,764✔





4114



  for (int i = 0; i < src->numOfCols; i++) {




9,966,491✔





4115



    dst->colList[i] = src->colList[i];




6,959,407✔





4116



  }










4117












4118



_end:




3,034,250✔





4119



  if (code != TSDB_CODE_SUCCESS) {




3,034,250✔





4120



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4121



  }










4122



  return code;




3,030,273✔





4123



}










4124












4125



static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,




4,561,776✔





4126



                                                bool* pSubTableHasBlock) {










4127



  int32_t code = 0;




4,561,776✔





4128












4129



  STableMergeScanInfo*    pInfo = pOperator->info;




4,561,776✔





4130



  SReadHandle*            pHandle = &pInfo->base.readHandle;




4,563,563✔





4131



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




4,564,664✔





4132



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




4,561,806✔





4133



  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;




4,563,942✔





4134












4135



  blockDataCleanup(pInput->pReaderBlock);




4,566,824✔





4136



  if (!pInput->bInMemReader) {




4,560,019✔





4137



    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,




4,573,103✔





4138



                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




2,288,874✔





4139



    if (code != 0) {




2,289,229✔





4140



      return code;




×







4141



    }










4142



  }










4143












4144



  pInfo->base.dataReader = pInput->pReader;




4,563,238✔





4145












4146



  while (true) {




13,357✔





4147



    bool hasNext = false;




4,575,861✔





4148



    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);




4,575,855✔





4149



    if (code != 0) {




4,582,678✔





4150



      pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4151



      pInfo->base.dataReader = NULL;




×







4152



      return code;




×







4153



    }










4154












4155



    if (!hasNext || isTaskKilled(pTaskInfo)) {




4,582,678✔





4156



      if (isTaskKilled(pTaskInfo)) {




3,054,882✔





4157



        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4158



        pInfo->base.dataReader = NULL;




×







4159



        return code;




×







4160



      }










4161












4162



      *pSubTableHasBlock = false;




3,054,882✔





4163



      break;




3,053,805✔





4164



    }










4165












4166



    if (pInput->tblCond.order == TSDB_ORDER_ASC) {




1,527,796✔





4167



      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;




1,502,165✔





4168



    } else {










4169



      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;




25,631✔





4170



    }










4171












4172



    uint32_t status = 0;




1,527,796✔





4173



    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);




1,527,796✔





4174



    if (code != 0) {




1,527,796✔





4175



      pInfo->base.dataReader = NULL;




×







4176



      return code;




×







4177



    }










4178












4179



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




1,527,796✔





4180



      *pSubTableHasBlock = false;




×







4181



      break;




×







4182



    }










4183



    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {




1,527,796✔





4184



      continue;




13,357✔





4185



    }










4186












4187



    *pSubTableHasBlock = true;




1,514,084✔





4188



    break;




1,514,084✔





4189



  }










4190












4191



  if (*pSubTableHasBlock) {




4,568,960✔





4192



    pInput->pReaderBlock->info.id.groupId =




3,028,878✔





4193



        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);




3,027,807✔





4194



    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;




1,514,439✔





4195



  }










4196



  if (!pInput->bInMemReader || !*pSubTableHasBlock) {




4,568,966✔





4197



    pAPI->tsdReader.tsdReaderClose(pInput->pReader);




3,435,400✔





4198



    pInput->pReader = NULL;




3,436,483✔





4199



  }










4200












4201



  pInfo->base.dataReader = NULL;




4,568,611✔





4202



  return TSDB_CODE_SUCCESS;




4,567,540✔





4203



}










4204












4205



static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {




1,895,841✔





4206



  pInfo->bGroupProcessed = false;




1,895,841✔





4207












4208



  int32_t numOfTables = 0;




1,888,338✔





4209



  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




1,875,925✔





4210



  if (code != TSDB_CODE_SUCCESS) {




1,865,564✔





4211



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4212



    return code;




×







4213



  }










4214












4215



  int32_t i = pInfo->tableStartIndex + 1;




1,865,564✔





4216



  for (; i < numOfTables; ++i) {




3,007,060✔





4217



    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




1,199,276✔





4218



    if (!tableKeyInfo) {




1,197,832✔





4219



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4220



      return terrno;




×







4221



    }










4222



    if (tableKeyInfo->groupId != pInfo->groupId) {




1,197,832✔





4223



      break;




57,040✔





4224



    }










4225



  }










4226



  pInfo->tableEndIndex = i - 1;




1,864,824✔





4227



  return TSDB_CODE_SUCCESS;




1,902,586✔





4228



}










4229












4230



static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {




1,909,054✔





4231



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,961,800✔





4232



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,054,515✔





4233



    if (pInput->rowIdx == -1) {




3,050,953✔





4234



      continue;




1,539,378✔





4235



    }










4236












4237



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,513,362✔





4238



      pInput->rowIdx = 0;




1,514,078✔





4239



      pInput->pageIdx = -1;




1,512,995✔





4240



    }










4241












4242



    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,513,362✔





4243



    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




1,513,362✔





4244



    if (!col) {




1,513,723✔





4245



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4246



      return terrno;




×







4247



    }










4248



    pInput->aTs = (int64_t*)col->pData;




1,513,723✔





4249



  }










4250












4251



  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;




1,909,060✔





4252



  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);




1,909,770✔





4253



}










4254












4255



static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {




1,894,788✔





4256



  int32_t code = setGroupStartEndIndex(pInfo);




1,894,788✔





4257



  if (code != TSDB_CODE_SUCCESS) {




1,899,728✔





4258



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4259



    return code;




×







4260



  }










4261



  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));




1,899,728✔





4262



  if (pSubTblsInfo == NULL) {




1,881,912✔





4263



    return terrno;




×







4264



  }










4265



  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);




1,881,912✔





4266



  if (!pSubTblsInfo->pTsOrderInfo) {




1,895,119✔





4267



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4268



    return terrno;




×







4269



  }










4270



  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {




1,880,498✔





4271



    pSubTblsInfo->pPkOrderInfo = taosArrayGet(pInfo->pSortInfo, 1);




×







4272



    if (!pSubTblsInfo->pPkOrderInfo) {




×







4273



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4274



      return terrno;




×







4275



    }










4276



  } else {










4277



    pSubTblsInfo->pPkOrderInfo = NULL;




1,878,374✔





4278



  }










4279



  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




1,889,433✔





4280



  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));




1,880,528✔





4281



  if (pSubTblsInfo->aInputs == NULL) {




1,874,836✔





4282



    taosMemoryFree(pSubTblsInfo);




×







4283



    return terrno;




×







4284



  }










4285



  int32_t bufPageSize = pInfo->bufPageSize;




1,876,629✔





4286



  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;




1,881,611✔





4287



  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);




1,886,232✔





4288



  if (code != TSDB_CODE_SUCCESS) {




1,883,031✔





4289



    taosMemoryFree(pSubTblsInfo->aInputs);




×







4290



    taosMemoryFree(pSubTblsInfo);




×







4291



    return code;




×







4292



  }










4293



  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;




1,883,031✔





4294



  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;




1,888,711✔





4295












4296



  pInfo->pSubTablesMergeInfo = pSubTblsInfo;




1,885,871✔





4297



  return TSDB_CODE_SUCCESS;




1,868,037✔





4298



}










4299












4300



static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {




1,893,019✔





4301



  int32_t        code = TSDB_CODE_SUCCESS;




1,893,019✔





4302



  int32_t        lino = 0;




1,893,019✔





4303



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,893,019✔





4304



  SReadHandle*   pHandle = &pInfo->base.readHandle;




1,889,451✔





4305



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,878,025✔





4306












4307



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




1,880,871✔





4308












4309



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,936,072✔





4310



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,038,498✔





4311



    pInput->type = SUB_TABLE_MEM_BLOCK;




3,030,261✔





4312












4313



    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);




3,027,030✔





4314



    QUERY_CHECK_CODE(code, lino, _end);




3,028,847✔





4315












4316



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);




3,028,847✔





4317



    QUERY_CHECK_CODE(code, lino, _end);




3,054,160✔





4318












4319



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);




3,054,160✔





4320



    QUERY_CHECK_CODE(code, lino, _end);




3,055,237✔





4321












4322



    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);




3,055,237✔





4323



    pInput->pKeyInfo = keyInfo;




3,053,811✔





4324












4325



    if (isTaskKilled(pTaskInfo)) {




3,050,598✔





4326



      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);




×







4327



    }










4328












4329



    if (i + 1 < pSubTblsInfo->numInMemReaders) {




3,041,308✔





4330



      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,




2,282,667✔





4331



                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




1,142,236✔





4332



      QUERY_CHECK_CODE(code, lino, _end);




1,141,153✔





4333



      pInput->bInMemReader = true;




1,141,153✔





4334



    } else {










4335



      pInput->pReader = NULL;




1,906,557✔





4336



      pInput->bInMemReader = false;




1,907,628✔





4337



    }










4338



    bool hasNext = true;




3,049,491✔





4339



    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);




3,049,491✔





4340



    QUERY_CHECK_CODE(code, lino, _end);




3,053,811✔





4341



    if (!hasNext) {




3,053,811✔





4342



      pInput->rowIdx = -1;




1,539,372✔





4343



      ++pSubTblsInfo->numSubTablesCompleted;




1,538,662✔





4344



      continue;




1,540,088✔





4345



    } else {










4346



      pInput->rowIdx = 0;




1,514,439✔





4347



      pInput->pageIdx = -1;




1,514,439✔





4348



    }










4349



  }










4350












4351



_end:




1,910,835✔





4352



  if (code != TSDB_CODE_SUCCESS) {




1,910,480✔





4353



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4354



  }










4355



  return code;




1,908,332✔





4356



}










4357












4358



static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




1,514,439✔





4359



  int32_t              code = TSDB_CODE_SUCCESS;




1,514,439✔





4360



  int32_t              lino = 0;




1,514,439✔





4361



  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;




1,514,439✔





4362



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




1,514,439✔





4363



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




1,514,439✔





4364



  bool                 hasNext = true;




1,514,439✔





4365



  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);




1,514,439✔





4366



  QUERY_CHECK_CODE(code, lino, _end);




1,514,439✔





4367












4368



  if (!hasNext) {




1,514,439✔





4369



    pInput->rowIdx = -1;




1,514,439✔





4370



    ++pSubTblsInfo->numSubTablesCompleted;




1,514,439✔





4371



  } else {










4372



    pInput->rowIdx = 0;




×







4373



  }










4374












4375



_end:




1,514,439✔





4376



  if (code != TSDB_CODE_SUCCESS) {




1,514,439✔





4377



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4378



    pTaskInfo->code = code;




×







4379



    T_LONG_JMP(pTaskInfo->env, code);




×







4380



  }










4381



}




1,514,439✔





4382












4383



static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




275,940,973✔





4384



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




275,940,973✔





4385



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




275,948,831✔





4386












4387



  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




275,942,736✔





4388



  if (pInput->rowIdx < pInputBlock->info.rows - 1) {




275,987,122✔





4389



    ++pInput->rowIdx;




274,473,724✔





4390



  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {




1,514,439✔





4391



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,514,439✔





4392



      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);




1,514,439✔





4393



    }










4394



    if (pInput->rowIdx != -1) {




1,514,439✔





4395



      SColumnInfoData* col = taosArrayGet(pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




×







4396



      if (!col) {




×







4397



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4398



        return terrno;




×







4399



      }










4400



      pInput->pInputBlock = pInputBlock;




×







4401



      pInput->aTs = (int64_t*)col->pData;




×







4402



    }










4403



  }










4404












4405



  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));




275,987,110✔





4406



}










4407












4408



static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {




275,838,428✔





4409



  int32_t            code = TSDB_CODE_SUCCESS;




275,838,428✔





4410



  int32_t            lino = 0;




275,838,428✔





4411



  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




275,838,428✔





4412



  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




275,853,374✔





4413












4414



  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {




1,117,697,919✔





4415



    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);




841,180,847✔





4416



    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);




841,132,409✔





4417












4418



    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);




841,132,409✔





4419



    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);




840,663,739✔





4420



    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);




840,663,739✔





4421












4422



    if (isNull) {




841,420,987✔





4423



      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);




66,548,431✔





4424



      QUERY_CHECK_CODE(code, lino, _end);




66,545,543✔





4425



    } else {










4426



      if (pSrcColInfo->pData != NULL) {




774,872,556✔





4427



        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);




774,833,736✔





4428



        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);




775,468,628✔





4429



        QUERY_CHECK_CODE(code, lino, _end);




775,323,284✔





4430



      }










4431



    }










4432



  }










4433



  pBlock->info.dataLoad = 1;




275,967,441✔





4434



  pBlock->info.scanFlag = pInputBlock->info.scanFlag;




275,968,163✔





4435



  pBlock->info.rows += 1;




275,967,098✔





4436












4437



_end:




275,957,429✔





4438



  if (code != TSDB_CODE_SUCCESS) {




275,957,429✔





4439



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4440



  }










4441



  return code;




275,950,654✔





4442



}










4443












4444



static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,




3,081,971✔





4445



                                       SSDataBlock** pResBlock) {










4446



  int32_t                 code = TSDB_CODE_SUCCESS;




3,081,971✔





4447



  int32_t                 lino = 0;




3,081,971✔





4448



  STableMergeScanInfo*    pInfo = pOperator->info;




3,081,971✔





4449



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




3,083,409✔





4450



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




3,080,906✔





4451



  bool                    finished = false;




3,081,249✔





4452












4453



  QRY_PARAM_CHECK(pResBlock);




3,081,249✔





4454












4455



  blockDataCleanup(pBlock);




3,080,539✔





4456












4457



  while (true) {




×







4458



    while (true) {










4459



      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {




278,940,068✔





4460



        finished = true;




3,084,119✔





4461



        break;




3,084,119✔





4462



      }










4463












4464



      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);




275,843,819✔





4465



      QUERY_CHECK_CODE(code, lino, _end);




275,947,453✔





4466












4467



      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);




275,947,453✔





4468



      QUERY_CHECK_CODE(code, lino, _end);




275,859,547✔





4469












4470



      if (pBlock->info.rows >= capacity) {




275,859,547✔





4471



        break;




×







4472



      }










4473



    }










4474












4475



    if (isTaskKilled(pTaskInfo)) {




3,084,119✔





4476



      return pTaskInfo->code;




×







4477



    }










4478












4479



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);




3,084,119✔





4480



    if (finished || limitReached || pBlock->info.rows > 0) {




3,083,403✔





4481



      break;










4482



    }










4483



  }










4484












4485



  if (pBlock->info.rows > 0) {




3,083,403✔





4486



    *pResBlock = pBlock;




1,173,639✔





4487



  }










4488












4489



_end:




1,909,770✔





4490



  if (code != TSDB_CODE_SUCCESS) {




3,083,409✔





4491



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4492



    pTaskInfo->code = code;




×







4493



  }










4494



  return code;




3,083,048✔





4495



}










4496












4497



static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {




1,891,226✔





4498



  int32_t              code = TSDB_CODE_SUCCESS;




1,891,226✔





4499



  int32_t              lino = 0;




1,891,226✔





4500



  STableMergeScanInfo* pInfo = pOperator->info;




1,891,226✔





4501












4502



  code = initSubTablesMergeInfo(pInfo);




1,889,090✔





4503



  QUERY_CHECK_CODE(code, lino, _end);




1,875,179✔





4504












4505



  code = initSubTableInputs(pOperator, pInfo);




1,875,179✔





4506



  QUERY_CHECK_CODE(code, lino, _end);




1,907,267✔





4507












4508



  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);




1,907,267✔





4509



  QUERY_CHECK_CODE(code, lino, _end);




1,909,409✔





4510












4511



_end:




1,909,409✔





4512



  if (code != TSDB_CODE_SUCCESS) {




1,909,409✔





4513



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4514



  }










4515



  return code;




1,909,403✔





4516



}










4517












4518



static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {




29,640,023✔





4519



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




29,640,023✔





4520



  if (pSubTblsInfo != NULL) {




29,647,520✔





4521



    tMergeTreeDestroy(&pSubTblsInfo->pTree);




1,910,480✔





4522












4523



    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,964,652✔





4524



      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,055,237✔





4525



      taosMemoryFree(pInput->tblCond.colList);




3,054,882✔





4526



      blockDataDestroy(pInput->pReaderBlock);




3,055,237✔





4527



      blockDataDestroy(pInput->pPageBlock);




3,055,237✔





4528



      taosArrayDestroy(pInput->aBlockPages);




3,055,237✔





4529



      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);




3,055,237✔





4530



      pInput->pReader = NULL;




3,054,527✔





4531



    }










4532












4533



    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);




1,909,770✔





4534



    taosMemoryFree(pSubTblsInfo->aInputs);




1,910,480✔





4535












4536



    taosMemoryFree(pSubTblsInfo);




1,910,125✔





4537



    pInfo->pSubTablesMergeInfo = NULL;




1,909,415✔





4538












4539



    // taosMemoryTrim(0);










4540



  }










4541



}




29,646,455✔





4542












4543



int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




3,058,997✔





4544



  QRY_PARAM_CHECK(ppRes);




3,058,997✔





4545












4546



  int32_t lino = 0;




3,061,139✔





4547



  int32_t tableListSize = 0;




3,061,139✔





4548



  int64_t st = taosGetTimestampUs();




3,044,039✔





4549












4550



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,044,039✔





4551



  STableMergeScanInfo* pInfo = pOperator->info;




3,042,992✔





4552












4553



  if (pOperator->status == OP_EXEC_DONE) {




3,047,252✔





4554



    return TSDB_CODE_SUCCESS;




×







4555



  }










4556












4557



  int32_t code = pOperator->fpSet._openFn(pOperator);




3,042,631✔





4558



  QUERY_CHECK_CODE(code, lino, _end);




3,046,903✔





4559












4560



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




3,046,903✔





4561



  QUERY_CHECK_CODE(code, lino, _end);




3,054,051✔





4562












4563



  if (!pInfo->hasGroupId) {




3,054,051✔





4564



    pInfo->hasGroupId = true;




1,868,992✔





4565












4566



    if (tableListSize == 0) {




1,860,436✔





4567



      setOperatorCompleted(pOperator);




45,847✔





4568



      (*ppRes) = NULL;




46,208✔





4569



      return code;




46,208✔





4570



    }










4571












4572



    pInfo->tableStartIndex = 0;




1,814,589✔





4573



    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,819,920✔





4574



    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




1,814,956✔





4575



    pInfo->groupId = pTmpGpId->groupId;




1,814,956✔





4576



    code = startSubTablesTableMergeScan(pOperator);




1,834,535✔





4577



    QUERY_CHECK_CODE(code, lino, _end);




1,852,357✔





4578



  }










4579












4580



  SSDataBlock* pBlock = NULL;




3,037,061✔





4581



  while (pInfo->tableStartIndex < tableListSize) {




3,082,681✔





4582



    if (isTaskKilled(pTaskInfo)) {




3,083,054✔





4583



      break;




×







4584



    }










4585












4586



    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);




3,083,409✔





4587



    QUERY_CHECK_CODE(code, lino, _end);




3,082,693✔





4588












4589



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




3,082,693✔





4590



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




×







4591



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




×







4592












4593



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




×







4594



    }










4595












4596



    if (pBlock != NULL) {




3,083,764✔





4597



      pBlock->info.id.groupId = pInfo->groupId;




1,173,639✔





4598



      pOperator->resultInfo.totalRows += pBlock->info.rows;




1,173,639✔





4599



      pInfo->bGroupProcessed = true;




1,173,639✔





4600



      break;




1,173,639✔





4601



    } else {










4602



      // Data of this group are all dumped, let's try the next group










4603



      stopSubTablesTableMergeScan(pInfo);




1,910,125✔





4604



      if (pInfo->tableEndIndex >= tableListSize - 1) {




1,908,705✔





4605



        setOperatorCompleted(pOperator);




1,851,659✔





4606



        break;




1,852,375✔





4607



      }










4608












4609



      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




57,040✔





4610



      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




57,040✔





4611



      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




57,040✔





4612












4613



      pInfo->groupId = pTmpGpId->groupId;




57,040✔





4614



      code = startSubTablesTableMergeScan(pOperator);




57,040✔





4615



      QUERY_CHECK_CODE(code, lino, _end);




57,040✔





4616



      resetLimitInfoForNextGroup(&pInfo->limitInfo);




57,040✔





4617



    }










4618



  }










4619












4620



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




3,026,014✔





4621












4622



_end:




3,027,079✔





4623



  if (code != TSDB_CODE_SUCCESS) {




3,027,079✔





4624



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4625



    pTaskInfo->code = code;




×







4626



    T_LONG_JMP(pTaskInfo->env, code);




×







4627



  } else {










4628



    (*ppRes) = pBlock;




3,027,079✔





4629



  }










4630












4631



  return code;




3,024,949✔





4632



}










4633












4634



static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {




3,526,938✔





4635



  int32_t              code = TSDB_CODE_SUCCESS;




3,526,938✔





4636



  int32_t              lino = 0;




3,526,938✔





4637



  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;




3,526,938✔





4638



  STableMergeScanInfo* pInfo = pOperator->info;




3,526,938✔





4639



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,526,938✔





4640












4641



  if (pInfo->mSkipTables == NULL) {




3,526,938✔





4642



    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,




389,824✔





4643



                                      taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);










4644



    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);




389,824✔





4645



  }










4646



  int bSkip = 1;




3,526,938✔





4647



  if (pInfo->mSkipTables != NULL) {




3,526,938✔





4648



    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));




3,526,520✔





4649



    if (code == TSDB_CODE_DUP_KEY) {




3,526,520✔





4650



      code = TSDB_CODE_SUCCESS;




×







4651



    }










4652



    QUERY_CHECK_CODE(code, lino, _end);




3,526,520✔





4653



  }










4654












4655



_end:




3,526,520✔





4656



  if (code != TSDB_CODE_SUCCESS) {




3,526,520✔





4657



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4658



    pTaskInfo->code = code;




×







4659



    T_LONG_JMP(pTaskInfo->env, code);




×







4660



  }










4661



}




3,526,520✔





4662












4663



static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {




156,510,084✔





4664



  STableMergeScanInfo* pInfo = pOperator->info;




156,510,084✔





4665



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




156,534,107✔





4666



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




156,514,713✔





4667



  SSDataBlock*         pBlock = pInfo->pReaderBlock;




156,508,036✔





4668



  int32_t              code = 0;




156,509,200✔





4669



  bool                 hasNext = false;




156,509,200✔





4670



  STsdbReader*         reader = pInfo->base.dataReader;




156,499,064✔





4671












4672



  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);




156,501,624✔





4673



  if (code != 0) {




156,491,658✔





4674



    pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4675



    qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo));




×







4676



    pTaskInfo->code = code;




×







4677



    return code;




×







4678



  }










4679












4680



  if (!hasNext || isTaskKilled(pTaskInfo)) {




156,491,658✔





4681



    if (isTaskKilled(pTaskInfo)) {




28,945,030✔





4682



      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));




×







4683



      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4684



    }










4685



    *pFinished = true;




28,919,010✔





4686



    return code;




28,914,083✔





4687



  }










4688












4689



  uint32_t status = 0;




127,562,495✔





4690



  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);




127,572,241✔





4691












4692



  if (code != TSDB_CODE_SUCCESS) {




127,565,541✔





4693



    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));




16,306✔





4694



    pTaskInfo->code = code;




16,306✔





4695



    return code;




16,306✔





4696



  }










4697












4698



  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




127,549,235✔





4699



    *pFinished = true;




×







4700



    return code;




×







4701



  }










4702












4703



  // current block is filter out according to filter condition, continue load the next block










4704



  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {




127,549,235✔





4705



    *pSkipped = true;




5,341,588✔





4706



    return code;




5,321,209✔





4707



  }










4708












4709



  return code;




122,233,833✔





4710



}










4711












4712



static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {




154,406,646✔





4713



  STableMergeScanSortSourceParam* source = param;




154,406,646✔





4714












4715



  SOperatorInfo*       pOperator = source->pOperator;




154,406,646✔





4716



  STableMergeScanInfo* pInfo = pOperator->info;




154,414,290✔





4717



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




154,435,664✔





4718



  SSDataBlock*         pBlock = NULL;




154,437,361✔





4719



  int64_t              st = taosGetTimestampUs();




154,435,371✔





4720



  int32_t              code = TSDB_CODE_SUCCESS;




154,435,371✔





4721












4722



  while (true) {










4723



    if (pInfo->rtnNextDurationBlocks) {




162,887,125✔





4724



      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",




6,378,241✔





4725



             GET_TASKID(pTaskInfo), pInfo->nextDurationBlocksIdx, pInfo->numNextDurationBlocks);










4726












4727



      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {




6,382,347✔





4728



        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];




3,138,239✔





4729



        ++pInfo->nextDurationBlocksIdx;




3,137,501✔





4730



      } else {










4731



        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




6,374,237✔





4732



          blockDataDestroy(pInfo->nextDurationBlocks[i]);




3,137,187✔





4733



          pInfo->nextDurationBlocks[i] = NULL;




3,133,866✔





4734



        }










4735












4736



        pInfo->rtnNextDurationBlocks = false;




3,238,526✔





4737



        pInfo->nextDurationBlocksIdx = 0;




3,239,264✔





4738



        pInfo->numNextDurationBlocks = 0;




3,236,681✔





4739



        continue;




3,235,943✔





4740



      }










4741



    } else {










4742



      bool bFinished = false;




156,509,587✔





4743



      bool bSkipped = false;




156,495,001✔





4744












4745



      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);




156,509,550✔





4746



      if (code != 0) {




156,481,599✔





4747



        return code;




16,306✔





4748



      }










4749












4750



      pBlock = pInfo->pReaderBlock;




156,465,293✔





4751



      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",




156,481,937✔





4752



             GET_TASKID(pTaskInfo), bFinished, bSkipped, pInfo->bNextDurationBlockEvent, pInfo->bNewFilesetEvent);










4753



      if (bFinished) {




156,537,364✔





4754



        pInfo->bNewFilesetEvent = false;




28,931,540✔





4755



        break;




28,931,036✔





4756



      }










4757












4758



      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {




127,605,824✔





4759



        if (!bSkipped) {




3,237,647✔





4760



          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);




3,137,870✔





4761



          if (code) {




3,130,059✔





4762



            *ppBlock = NULL;




×







4763



            return code;




×







4764



          }










4765












4766



          ++pInfo->numNextDurationBlocks;




3,130,059✔





4767



          if (pInfo->numNextDurationBlocks > 2) {




3,128,952✔





4768



            qError("%s table merge scan prefetch %d next duration blocks. end early.", GET_TASKID(pTaskInfo),




×







4769



                   pInfo->numNextDurationBlocks);










4770



            pInfo->bNewFilesetEvent = false;




×







4771



            break;




×







4772



          }










4773



        }










4774












4775



        if (pInfo->bNewFilesetEvent) {




3,228,791✔





4776



          pInfo->rtnNextDurationBlocks = true;




3,232,536✔





4777



          *ppBlock = NULL;




3,237,364✔





4778



          return code;




3,223,711✔





4779



        }










4780












4781



        if (pInfo->bNextDurationBlockEvent) {




369✔





4782



          pInfo->bNextDurationBlockEvent = false;




×







4783



          continue;




×







4784



        }










4785



      }










4786



      if (bSkipped) continue;




124,366,559✔





4787



    }










4788












4789



    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);




122,286,423✔





4790












4791



    pOperator->resultInfo.totalRows += pBlock->info.rows;




122,289,901✔





4792



    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;




122,281,746✔





4793



    *ppBlock = pBlock;




122,279,257✔





4794












4795



    return code;




122,278,673✔





4796



  }










4797












4798



  *ppBlock = NULL;




28,932,026✔





4799



  return code;




28,931,540✔





4800



}










4801












4802



int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {




25,253,846✔





4803



  int32_t code = TSDB_CODE_SUCCESS;




25,253,846✔





4804



  int32_t lino = 0;




25,253,846✔





4805



  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));




25,253,846✔





4806



  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);




25,210,455✔





4807



  SBlockOrderInfo biTs = {0};




25,210,455✔





4808



  SBlockOrderInfo biPk = {0};




25,207,359✔





4809












4810



  int32_t tsTargetSlotId = 0;




25,229,289✔





4811



  int32_t pkTargetSlotId = -1;




25,229,289✔





4812



  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {




91,022,530✔





4813



    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);




65,905,111✔





4814



    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);




65,909,797✔





4815



    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




65,909,797✔





4816



      tsTargetSlotId = colInfo->dstSlotId;




25,253,756✔





4817



      biTs.order = order;




25,257,604✔





4818



      biTs.slotId = tsTargetSlotId;




25,257,604✔





4819



      biTs.nullFirst = (order == TSDB_ORDER_ASC);




25,257,604✔





4820



      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);




25,257,604✔





4821



    }










4822



    // TODO: order by just ts










4823



    if (colInfo->isPk) {




65,825,393✔





4824



      pkTargetSlotId = colInfo->dstSlotId;




1,749,329✔





4825



      biPk.order = order;




1,749,329✔





4826



      biPk.slotId = pkTargetSlotId;




1,749,329✔





4827



      biPk.nullFirst = (order == TSDB_ORDER_ASC);




1,749,329✔





4828



      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);




1,749,329✔





4829



    }










4830



  }










4831












4832



  void* tmp = taosArrayPush(pSortInfo, &biTs);




25,272,642✔





4833



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




25,272,642✔





4834



  if (pkTargetSlotId != -1) {




25,272,642✔





4835



    tmp = taosArrayPush(pSortInfo, &biPk);




1,753,005✔





4836



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,753,005✔





4837



  }










4838












4839



  (*ppSortArray) = pSortInfo;




25,276,387✔





4840












4841



_end:




25,165,367✔





4842



  if (code != TSDB_CODE_SUCCESS) {




25,240,604✔





4843



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4844



  }










4845



  return code;




25,240,604✔





4846



}










4847












4848



void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {




4,570,820✔





4849



  STableMergeScanInfo* pTmsInfo = param;




4,570,820✔





4850



  if (type == TSD_READER_NOTIFY_DURATION_START) {




4,570,820✔





4851



    pTmsInfo->bNewFilesetEvent = true;




4,571,927✔





4852



  } else if (type == TSD_READER_NOTIFY_NEXT_DURATION_BLOCK) {




×







4853



    pTmsInfo->bNextDurationBlockEvent = true;




×







4854



  }










4855



  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);




4,563,525✔





4856












4857



  return;




4,585,309✔





4858



}










4859












4860



int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




32,348,070✔





4861



  STableMergeScanInfo* pInfo = pOperator->info;




32,348,070✔





4862



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




32,365,208✔





4863












4864



  int32_t code = TSDB_CODE_SUCCESS;




32,375,046✔





4865



  int32_t lino = 0;




32,375,046✔





4866



  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




32,375,046✔





4867












4868



  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));




32,359,283✔





4869



  pInfo->bNewFilesetEvent = false;




32,425,668✔





4870



  pInfo->bNextDurationBlockEvent = false;




32,392,673✔





4871












4872



  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;




32,393,854✔





4873



  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;




32,392,378✔





4874












4875



  pInfo->pSortHandle = NULL;




32,375,355✔





4876



  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,




64,792,298✔





4877



                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);




32,384,656✔





4878



  if (code) {




32,349,129✔





4879



    return code;




×







4880



  }










4881












4882



  if (pInfo->bSortRowId && numOfTable != 1) {




32,349,129✔





4883



    int32_t memSize = 512 * 1024 * 1024;




1,602,248✔





4884



    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);




1,602,248✔





4885



    QUERY_CHECK_CODE(code, lino, _end);




1,602,734✔





4886



  }










4887












4888



  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);




32,360,448✔





4889



  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);




32,342,650✔





4890



  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);




32,347,621✔





4891












4892



  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);




32,338,149✔





4893



  QUERY_CHECK_CODE(code, lino, _end);




32,320,209✔





4894












4895



  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));




32,320,209✔





4896



  QUERY_CHECK_NULL(param, code, lino, _end, terrno);




32,343,087✔





4897



  param->pOperator = pOperator;




32,343,087✔





4898












4899



  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));




32,332,166✔





4900



  if (ps == NULL) {




32,335,449✔





4901



    taosMemoryFree(param);




×







4902



    QUERY_CHECK_NULL(ps, code, lino, _end, terrno);




×







4903



  }










4904












4905



  ps->param = param;




32,335,449✔





4906



  ps->onlyRef = false;




32,328,450✔





4907



  code = tsortAddSource(pInfo->pSortHandle, ps);




32,365,623✔





4908



  QUERY_CHECK_CODE(code, lino, _end);




32,381,751✔





4909












4910



  if (numOfTable == 1) {




32,381,751✔





4911



    tsortSetSingleTableMerge(pInfo->pSortHandle);




22,856,337✔





4912



  } else {










4913



    code = tsortOpen(pInfo->pSortHandle);




9,525,414✔





4914



    QUERY_CHECK_CODE(code, lino, _end);




9,531,697✔





4915



  }










4916












4917



_end:




9,523,807✔





4918



  if (code != TSDB_CODE_SUCCESS) {




32,350,984✔





4919



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




7,890✔





4920



  }










4921



  return code;




32,357,237✔





4922



}










4923












4924



void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




32,394,467✔





4925



  STableMergeScanInfo* pInfo = pOperator->info;




32,394,467✔





4926



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




32,396,186✔





4927



  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));




32,397,662✔





4928












4929



  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);




32,403,596✔





4930



  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;




32,388,229✔





4931



  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;




32,387,586✔





4932



  pInfo->sortExecInfo.loops += sortExecInfo.loops;




32,387,956✔





4933



  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;




32,385,065✔





4934



  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;




32,378,691✔





4935












4936



  tsortDestroySortHandle(pInfo->pSortHandle);




32,371,407✔





4937



  pInfo->pSortHandle = NULL;




32,391,947✔





4938



}




32,388,003✔





4939












4940



void startGroupTableMergeScan(SOperatorInfo* pOperator) {




29,147,433✔





4941



  int32_t              code = TSDB_CODE_SUCCESS;




29,147,433✔





4942



  int32_t              lino = 0;




29,147,433✔





4943



  STableMergeScanInfo* pInfo = pOperator->info;




29,147,433✔





4944



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




29,146,971✔





4945



  SReadHandle*         pHandle = &pInfo->base.readHandle;




29,126,522✔





4946



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




29,102,880✔





4947



  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




29,093,364✔





4948












4949



  {










4950



    int32_t numOfTables = 0;




29,104,503✔





4951



    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




29,108,632✔





4952



    QUERY_CHECK_CODE(code, lino, _end);




29,138,021✔





4953












4954



    int32_t i = pInfo->tableStartIndex + 1;




29,138,021✔





4955



    for (; i < numOfTables; ++i) {




134,200,685✔





4956



      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




111,276,279✔





4957



      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);




111,274,255✔





4958



      if (tableKeyInfo->groupId != pInfo->groupId) {




111,274,255✔





4959



        break;




6,211,208✔





4960



      }










4961



    }










4962



    pInfo->tableEndIndex = i - 1;




29,135,614✔





4963



  }










4964



  pInfo->bGroupProcessed = false;




29,162,201✔





4965



  int32_t tableStartIdx = pInfo->tableStartIndex;




29,155,122✔





4966



  int32_t tableEndIdx = pInfo->tableEndIndex;




29,148,256✔





4967












4968



  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;




29,153,328✔





4969



  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);




29,153,328✔





4970



  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,




58,271,616✔





4971



                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);




29,131,922✔





4972



  QUERY_CHECK_CODE(code, lino, _end);




29,127,398✔





4973



  if (pInfo->filesetDelimited) {




29,127,398✔





4974



    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);




29,128,498✔





4975



  }










4976



  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);




29,148,088✔





4977












4978



  code = startDurationForGroupTableMergeScan(pOperator);




29,078,427✔





4979



  QUERY_CHECK_CODE(code, lino, _end);




29,119,091✔





4980












4981



_end:




29,111,201✔





4982



  if (code != TSDB_CODE_SUCCESS) {




29,119,586✔





4983



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




7,890✔





4984



    pTaskInfo->code = code;




7,890✔





4985



    T_LONG_JMP(pTaskInfo->env, code);




7,890✔





4986



  }










4987



}




29,111,696✔





4988












4989



void stopGroupTableMergeScan(SOperatorInfo* pOperator) {




29,155,374✔





4990



  STableMergeScanInfo* pInfo = pOperator->info;




29,155,374✔





4991



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




29,156,395✔





4992



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




29,157,871✔





4993












4994



  stopDurationForGroupTableMergeScan(pOperator);




29,157,871✔





4995












4996



  if (pInfo->base.dataReader != NULL) {




29,152,409✔





4997



    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);




29,155,511✔





4998



    pInfo->base.dataReader = NULL;




29,110,193✔





4999



  }










5000



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




29,117,298✔





5001



    if (pInfo->nextDurationBlocks[i]) {




1,052✔





5002



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




1,052✔





5003



      pInfo->nextDurationBlocks[i] = NULL;




1,052✔





5004



    }










5005



    pInfo->numNextDurationBlocks = 0;




1,052✔





5006



    pInfo->nextDurationBlocksIdx = 0;




1,052✔





5007



  }










5008



  resetLimitInfoForNextGroup(&pInfo->limitInfo);




29,117,310✔





5009



  taosHashCleanup(pInfo->mSkipTables);




29,080,000✔





5010



  pInfo->mSkipTables = NULL;




29,085,610✔





5011



  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




29,088,415✔





5012



}




29,153,282✔





5013












5014



// all data produced by this function only belongs to one group










5015



// slimit/soffset does not need to be concerned here, since this function only deal with data within one group.










5016



SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,




68,574,342✔





5017



                                              SOperatorInfo* pOperator) {










5018



  STableMergeScanInfo* pInfo = pOperator->info;




68,574,342✔





5019



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




68,589,476✔





5020



  STupleHandle*        pTupleHandle = NULL;




68,576,239✔





5021












5022



  blockDataCleanup(pResBlock);




68,582,159✔





5023












5024



  while (1) {




×







5025



    while (1) {




2,147,483,647✔





5026



      pTupleHandle = NULL;




2,147,483,647✔





5027



      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);




2,147,483,647✔





5028



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5029



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







5030



        T_LONG_JMP(pOperator->pTaskInfo->env, code);




×







5031



      }










5032



      if (pTupleHandle == NULL) {




2,147,483,647✔





5033



        break;




52,596,311✔





5034



      }










5035












5036



      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);




2,147,483,647✔





5037



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5038



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







5039



        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5040



      }










5041












5042



      if (pResBlock->info.rows >= capacity) {




2,147,483,647✔





5043



        break;




15,998,645✔





5044



      }










5045



    }










5046












5047



    if (tsortIsClosed(pHandle)) {




68,594,956✔





5048



      terrno = TSDB_CODE_TSC_QUERY_CANCELLED;




×







5049



      T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5050



    }










5051












5052



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);




68,601,477✔





5053



    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,




68,608,190✔





5054



           pInfo->limitInfo.numOfOutputRows);










5055



    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {




68,614,035✔





5056



      break;










5057



    }










5058



  }










5059



  return (pResBlock->info.rows > 0) ? pResBlock : NULL;




68,614,035✔





5060



}










5061












5062



int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




62,050,196✔





5063



  if (pOperator->status == OP_EXEC_DONE) {




62,050,196✔





5064



    (*ppRes) = NULL;




42,176✔





5065



    return TSDB_CODE_SUCCESS;




42,176✔





5066



  }










5067












5068



  int32_t              code = TSDB_CODE_SUCCESS;




61,989,874✔





5069



  int32_t              lino = 0;




61,989,874✔





5070



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




61,989,874✔





5071



  STableMergeScanInfo* pInfo = pOperator->info;




62,005,320✔





5072












5073



  code = pOperator->fpSet._openFn(pOperator);




61,999,703✔





5074



  QUERY_CHECK_CODE(code, lino, _end);




61,974,142✔





5075












5076



  int64_t st = taosGetTimestampUs();




61,993,753✔





5077












5078



  int32_t tableListSize = 0;




61,993,753✔





5079



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




61,997,060✔





5080



  QUERY_CHECK_CODE(code, lino, _end);




61,988,985✔





5081












5082



  if (!pInfo->hasGroupId) {




61,988,985✔





5083



    pInfo->hasGroupId = true;




25,786,651✔





5084












5085



    if (tableListSize == 0) {




25,777,410✔





5086



      setOperatorCompleted(pOperator);




2,877,143✔





5087



      (*ppRes) = NULL;




2,875,258✔





5088



      return code;




2,875,258✔





5089



    }










5090



    pInfo->tableStartIndex = 0;




22,900,267✔





5091



    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




22,899,966✔





5092



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




22,908,054✔





5093



    pInfo->groupId = tmp->groupId;




22,908,054✔





5094



    startGroupTableMergeScan(pOperator);




22,916,353✔





5095



  }










5096












5097



  SSDataBlock* pBlock = NULL;




59,124,233✔





5098



  while (pInfo->tableStartIndex < tableListSize) {




68,574,496✔





5099



    if (isTaskKilled(pTaskInfo)) {




68,581,346✔





5100



      goto _end;




×







5101



    }










5102












5103



    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,




68,577,247✔





5104



                                              pOperator);










5105



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




68,612,520✔





5106



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,800,036✔





5107



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




1,800,036✔





5108



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




1,800,036✔





5109



    }










5110



    if (pBlock != NULL) {




68,611,161✔





5111



      pBlock->info.id.groupId = pInfo->groupId;




36,213,459✔





5112



      pOperator->resultInfo.totalRows += pBlock->info.rows;




36,214,109✔





5113



      pInfo->bGroupProcessed = true;




36,212,345✔





5114



      break;




36,211,712✔





5115



    } else {










5116



      if (pInfo->bNewFilesetEvent) {




32,397,702✔





5117



        stopDurationForGroupTableMergeScan(pOperator);




3,239,947✔





5118



        code = startDurationForGroupTableMergeScan(pOperator);




3,237,733✔





5119



        QUERY_CHECK_CODE(code, lino, _end);




3,239,055✔





5120



      } else {










5121



        // Data of this group are all dumped, let's try the next group










5122



        stopGroupTableMergeScan(pOperator);




29,157,755✔





5123



        if (pInfo->tableEndIndex >= tableListSize - 1) {




29,152,489✔





5124



          setOperatorCompleted(pOperator);




22,941,678✔





5125



          break;




22,940,401✔





5126



        }










5127












5128



        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




6,211,208✔





5129



        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




6,211,208✔





5130



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




6,211,208✔





5131



        pInfo->groupId = tmp->groupId;




6,211,208✔





5132



        startGroupTableMergeScan(pOperator);




6,211,208✔





5133



        resetLimitInfoForNextGroup(&pInfo->limitInfo);




6,209,906✔





5134



      }










5135



    }










5136



  }










5137












5138



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




59,147,461✔





5139












5140



_end:




59,145,985✔





5141



  if (code != TSDB_CODE_SUCCESS) {




59,147,269✔





5142



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5143



    pTaskInfo->code = code;




×







5144



    T_LONG_JMP(pTaskInfo->env, code);




×







5145



  } else {










5146



    (*ppRes) = pBlock;




59,147,269✔





5147



  }










5148












5149



  return code;




59,142,863✔





5150



}










5151












5152



static SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {




×







5153



  SSDataBlock* pRes = NULL;




×







5154



  int32_t      code = doTableMergeScanNext(pOperator, &pRes);




×







5155



  return pRes;




×







5156



}










5157












5158



void destroyTableMergeScanOperatorInfo(void* param) {




25,279,260✔





5159



  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;




25,279,260✔





5160












5161



  // start one reader variable










5162



  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {




25,279,260✔





5163



    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);




25,282,597✔





5164



    pTableScanInfo->base.dataReader = NULL;




25,273,284✔





5165



  }










5166












5167



  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {




25,269,454✔





5168



    if (pTableScanInfo->nextDurationBlocks[i] != NULL) {




×







5169



      blockDataDestroy(pTableScanInfo->nextDurationBlocks[i]);




×







5170



      pTableScanInfo->nextDurationBlocks[i] = NULL;




×







5171



    }










5172



  }










5173












5174



  tsortDestroySortHandle(pTableScanInfo->pSortHandle);




25,281,694✔





5175



  pTableScanInfo->pSortHandle = NULL;




25,274,332✔





5176



  taosHashCleanup(pTableScanInfo->mSkipTables);




25,275,313✔





5177



  pTableScanInfo->mSkipTables = NULL;




25,263,017✔





5178



  blockDataDestroy(pTableScanInfo->pSortInputBlock);




25,264,359✔





5179



  pTableScanInfo->pSortInputBlock = NULL;




25,278,507✔





5180



  // end one reader variable










5181












5182



  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);




25,278,034✔





5183












5184



  blockDataDestroy(pTableScanInfo->pResBlock);




25,269,387✔





5185



  pTableScanInfo->pResBlock = NULL;




25,283,429✔





5186












5187



  // remove it from the task->result list










5188



  blockDataDestroy(pTableScanInfo->pReaderBlock);




25,283,429✔





5189



  pTableScanInfo->pReaderBlock = NULL;




25,283,475✔





5190



  taosArrayDestroy(pTableScanInfo->pSortInfo);




25,285,078✔





5191












5192



  stopSubTablesTableMergeScan(pTableScanInfo);




25,273,350✔





5193












5194



  taosMemoryFreeClear(param);




25,266,470✔





5195



}




25,274,756✔





5196












5197



int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {




1,198,889✔





5198



  if (pOptr == NULL) {




1,198,889✔





5199



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));




×







5200



    return TSDB_CODE_INVALID_PARA;




×







5201



  }










5202



  // TODO: merge these two info into one struct










5203



  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));




1,198,889✔





5204



  if (!execInfo) {




1,196,286✔





5205



    return terrno;




×







5206



  }










5207



  STableMergeScanInfo* pInfo = pOptr->info;




1,196,286✔





5208



  execInfo->blockRecorder = pInfo->base.readRecorder;




1,195,907✔





5209



  execInfo->sortExecInfo = pInfo->sortExecInfo;




1,195,538✔





5210












5211



  *pOptrExplain = execInfo;




1,197,772✔





5212



  *len = sizeof(STableMergeScanExecInfo);




1,196,286✔





5213












5214



  return TSDB_CODE_SUCCESS;




1,195,548✔





5215



}










5216












5217



static int32_t resetTableMergeScanOperatorState(SOperatorInfo* pOper) {




2,452,900✔





5218



  int32_t         code = TSDB_CODE_SUCCESS;




2,452,900✔





5219



  STableMergeScanInfo*   pInfo = pOper->info;




2,452,900✔





5220



  pOper->status = OP_NOT_OPENED;




2,452,900✔





5221












5222



  pInfo->tableEndIndex = 0;




2,452,900✔





5223



  pInfo->tableStartIndex = 0;




2,452,900✔





5224



  pInfo->hasGroupId = false;




2,452,900✔





5225



  if (pInfo->base.readerAPI.tsdReaderClose) {




2,452,900✔





5226



    pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);




2,452,900✔





5227



  }










5228



  pInfo->base.dataReader = NULL;




2,452,900✔





5229



  pInfo->base.scanFlag = MAIN_SCAN;




2,452,900✔





5230












5231



  pInfo->base.limitInfo = (SLimitInfo){0};




2,452,900✔





5232



  pInfo->base.limitInfo.limit.limit = -1;




2,452,900✔





5233



  pInfo->base.limitInfo.slimit.limit = -1;




2,452,900✔





5234












5235



  tableListDestroy(pInfo->base.pTableListInfo);




2,452,900✔





5236



  pInfo->base.pTableListInfo = tableListCreate();




2,452,643✔





5237



  if (!pInfo->base.pTableListInfo) {




2,452,900✔





5238



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







5239



    return terrno;




×







5240



  }










5241



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




2,452,900✔





5242












5243



  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;




2,452,900✔





5244



  code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,




4,905,800✔





5245



                                  &pInfo->base.readHandle, pInfo->base.pTableListInfo, 










5246



                                  pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);




4,905,800✔





5247



  if (code) {




2,452,900✔





5248



    qError("%s failed to createScanTableListInfo, code:%s", __func__, tstrerror(code));




×







5249



    return code;




×







5250



  }










5251












5252



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




2,452,900✔





5253



  cleanupQueryTableDataCond(&pInfo->base.cond);




2,452,900✔





5254



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, false);




2,452,900✔





5255



  if (code) {




2,452,900✔





5256



    qError("%s failed to initQueryTableDataCond, code:%s", __func__, tstrerror(code));




×







5257



    return code;




×







5258



  }










5259












5260



  tsortDestroySortHandle(pInfo->pSortHandle);




2,452,900✔





5261



  pInfo->pSortHandle = NULL;




2,452,900✔





5262












5263



  taosHashCleanup(pInfo->mSkipTables);




2,452,900✔





5264



  pInfo->mSkipTables = NULL;




2,452,900✔





5265



  pOper->resultInfo.totalRows = 0;




2,452,900✔





5266



  










5267



  pInfo->bGroupProcessed = false;




2,452,900✔





5268



  pInfo->bNewFilesetEvent = false;




2,452,900✔





5269



  pInfo->bNextDurationBlockEvent = false;




2,452,900✔





5270



  pInfo->rtnNextDurationBlocks = false;




2,452,900✔





5271



  pInfo->nextDurationBlocksIdx = 0;




2,452,664✔





5272



  pInfo->bSortRowId = false;




2,452,664✔





5273












5274



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




2,452,664✔





5275



    if (pInfo->nextDurationBlocks[i] != NULL) {




×







5276



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




×







5277



      pInfo->nextDurationBlocks[i] = NULL;




×







5278



    }










5279



  }










5280



  pInfo->numNextDurationBlocks = 0;




2,452,664✔





5281












5282



  stopSubTablesTableMergeScan(pInfo);




2,452,664✔





5283



  return code;




2,452,675✔





5284



}










5285












5286



int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




25,229,385✔





5287



                                         STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










5288



                                         SOperatorInfo** pOptrInfo) {










5289



  QRY_PARAM_CHECK(pOptrInfo);




25,229,385✔





5290












5291



  int32_t              code = TSDB_CODE_SUCCESS;




25,236,862✔





5292



  int32_t              lino = 0;




25,236,862✔





5293



  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));




25,236,862✔





5294



  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




25,213,744✔





5295



  if (pInfo == NULL || pOperator == NULL) {




25,157,180✔





5296



    code = terrno;




1,257✔





5297



    goto _error;




×







5298



  }










5299












5300



  pOperator->pPhyNode = pTableScanNode;




25,155,923✔





5301



  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;




25,165,171✔





5302












5303



  int32_t numOfCols = 0;




25,183,993✔





5304



  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,




25,205,364✔





5305



                             &pInfo->base.matchInfo);










5306



  QUERY_CHECK_CODE(code, lino, _error);




25,164,748✔





5307












5308



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, false);




25,164,748✔





5309



  QUERY_CHECK_CODE(code, lino, _error);




25,090,021✔





5310












5311



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




25,090,021✔





5312



    SExprSupp* pSup = &pInfo->base.pseudoSup;




10,441,754✔





5313



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);




10,443,010✔





5314



    QUERY_CHECK_CODE(code, lino, _error);




10,450,523✔





5315












5316



    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,




10,450,523✔





5317



                                      &pTaskInfo->storageAPI.functionStore);










5318



    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);




10,423,674✔





5319



  }










5320












5321



  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};




25,103,862✔





5322












5323



  if (tsMetaEntryCache && readHandle->streamRtInfo == NULL) {




25,150,442✔





5324



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(tsMetaEntryCacheSize, -1, .5);




×







5325



    QUERY_CHECK_NULL(pInfo->base.metaCache.pTableMetaEntryCache, code, lino, _error, terrno);




×







5326



  }










5327












5328



  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;




25,150,442✔





5329



  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




25,195,460✔





5330



  pInfo->base.scanFlag = MAIN_SCAN;




25,056,305✔





5331



  pInfo->base.readHandle = *readHandle;




25,147,707✔





5332












5333



  pInfo->readIdx = -1;




25,112,887✔





5334












5335



  pInfo->base.limitInfo.limit.limit = -1;




25,091,568✔





5336



  pInfo->base.limitInfo.slimit.limit = -1;




25,167,231✔





5337



  pInfo->base.pTableListInfo = pTableListInfo;




25,114,196✔





5338












5339



  pInfo->sample.sampleRatio = pTableScanNode->ratio;




25,104,913✔





5340



  pInfo->sample.seed = taosGetTimestampSec();




25,102,778✔





5341












5342



  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,




25,195,587✔





5343



                            pTaskInfo->pStreamRuntimeInfo);




25,201,136✔





5344



  QUERY_CHECK_CODE(code, lino, _error);




25,145,302✔





5345












5346



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




25,145,302✔





5347












5348



  pInfo->mergeLimit = -1;




25,141,397✔





5349



  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;




25,134,412✔





5350



  if (hasLimit) {




25,127,530✔





5351



    pInfo->mergeLimit = pInfo->limitInfo.limit.offset != -1




4,306,332✔





5352



                            ? pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset




795,666✔





5353



                            : pInfo->limitInfo.limit.limit;




2,949,808✔





5354



    pInfo->mSkipTables = NULL;




2,152,758✔





5355



  }










5356












5357



  initResultSizeInfo(&pOperator->resultInfo, 1024);




25,131,453✔





5358



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




25,115,479✔





5359



  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);




25,219,454✔





5360



  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);




25,128,427✔





5361



  QUERY_CHECK_CODE(code, lino, _error);




25,257,754✔





5362



  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {




25,257,754✔





5363



    pInfo->bSortRowId = true;




5,026,866✔





5364



  } else {










5365



    pInfo->bSortRowId = false;




20,231,282✔





5366



  }










5367












5368



  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);




25,238,118✔





5369



  QUERY_CHECK_CODE(code, lino, _error);




25,218,944✔





5370












5371



  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo);




25,218,944✔





5372



  QUERY_CHECK_CODE(code, lino, _error);




25,170,418✔





5373












5374



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);




25,170,418✔





5375



  QUERY_CHECK_CODE(code, lino, _error);




25,209,315✔





5376












5377



  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;




25,209,315✔





5378












5379



  int32_t  rowSize = pInfo->pResBlock->info.rowSize;




25,244,901✔





5380



  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);




25,176,772✔





5381












5382



  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);




25,175,830✔





5383












5384



  // start one reader variable










5385



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);




25,236,168✔





5386



  QUERY_CHECK_CODE(code, lino, _error);




25,215,491✔





5387












5388



  if (!tsExperimental) {




25,215,491✔





5389



    pInfo->filesetDelimited = false;




×







5390



  } else {










5391



    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




25,215,491✔





5392



  }










5393



  // end one reader variable










5394



  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,




25,217,826✔





5395



                  pInfo, pTaskInfo);










5396



  pOperator->exprSupp.numOfExprs = numOfCols;




25,177,937✔





5397












5398



  pOperator->fpSet = createOperatorFpSet(




25,158,459✔





5399



      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,




25,194,186✔





5400



      destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn,










5401



      NULL);










5402



  setOperatorResetStateFn(pOperator, resetTableMergeScanOperatorState);     




25,165,982✔





5403



  pOperator->cost.openCost = 0;




25,227,203✔





5404












5405



  *pOptrInfo = pOperator;




25,236,037✔





5406



  return code;




25,153,115✔





5407












5408



_error:




×







5409



  if (code != TSDB_CODE_SUCCESS) {




×







5410



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5411



  }










5412



  pTaskInfo->code = code;




×







5413



  if (pInfo != NULL) {




×







5414



    pInfo->base.pTableListInfo = NULL;




×







5415



    destroyTableMergeScanOperatorInfo(pInfo);




×







5416



  }










5417



  if (pOperator != NULL) {




×







5418



    pOperator->info = NULL;




×







5419



    destroyOperator(pOperator);




×







5420



  }










5421



  return code;




×







5422



}










5423












5424



// ====================================================================================================================










5425



// TableCountScanOperator










5426



static void        destoryTableCountScanOperator(void* param);










5427



static int32_t     buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5428



                                                  SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI);










5429



static int32_t     buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5430



                                                  SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI);










5431



static int32_t     buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5432



                                             STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName);










5433



static int32_t     buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5434



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName);










5435



static int32_t     buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5436



                                          STableCountScanSupp* pSupp, SSDataBlock* pRes);










5437



static void        buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5438



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5439



                                               size_t perfdbTableNum);










5440



static void        buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,










5441



                                              size_t infodbTableNum, size_t perfdbTableNum);










5442



static const char* GROUP_TAG_DB_NAME = "db_name";










5443



static const char* GROUP_TAG_STABLE_NAME = "stable_name";










5444












5445



int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {




25,477✔





5446



  if (scanCols != NULL) {




25,477✔





5447



    SNode* pNode = NULL;




12,588✔





5448



    FOREACH(pNode, scanCols) {




30,077✔





5449



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




17,489✔





5450



        return TSDB_CODE_QRY_SYS_ERROR;




×







5451



      }










5452



      STargetNode* targetNode = (STargetNode*)pNode;




17,489✔





5453



      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {




17,489✔





5454



        return TSDB_CODE_QRY_SYS_ERROR;




×







5455



      }










5456



      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);




17,489✔





5457



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




17,489✔





5458



        supp->dbNameSlotId = targetNode->slotId;




9,627✔





5459



      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




7,862✔





5460



        supp->stbNameSlotId = targetNode->slotId;




7,862✔





5461



      }










5462



    }










5463



  }










5464



  return TSDB_CODE_SUCCESS;




25,477✔





5465



}










5466












5467



int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {




25,477✔





5468



  if (pseudoCols != NULL) {




25,477✔





5469



    SNode* pNode = NULL;




25,477✔





5470



    FOREACH(pNode, pseudoCols) {




50,954✔





5471



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




25,477✔





5472



        return TSDB_CODE_QRY_SYS_ERROR;




×







5473



      }










5474



      STargetNode* targetNode = (STargetNode*)pNode;




25,473✔





5475



      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {




25,473✔





5476



        return TSDB_CODE_QRY_SYS_ERROR;




×







5477



      }










5478



      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);




25,477✔





5479



      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {




25,477✔





5480



        supp->tbCountSlotId = targetNode->slotId;




25,477✔





5481



      }










5482



    }










5483



  }










5484



  return TSDB_CODE_SUCCESS;




25,477✔





5485



}










5486












5487



int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {




25,477✔





5488



  if (groupTags != NULL) {




25,477✔





5489



    SNode* pNode = NULL;




12,588✔





5490



    FOREACH(pNode, groupTags) {




30,077✔





5491



      if (nodeType(pNode) != QUERY_NODE_COLUMN) {




17,489✔





5492



        return TSDB_CODE_QRY_SYS_ERROR;




×







5493



      }










5494



      SColumnNode* colNode = (SColumnNode*)pNode;




17,489✔





5495



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




17,489✔





5496



        supp->groupByDbName = true;




9,627✔





5497



      }










5498



      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




17,489✔





5499



        supp->groupByStbName = true;




7,862✔





5500



      }










5501



    }










5502



  } else {










5503



    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);




12,889✔





5504



    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);




12,885✔





5505



  }










5506



  return TSDB_CODE_SUCCESS;




25,477✔





5507



}










5508












5509



int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,




25,477✔





5510



                              STableCountScanSupp* supp, SExecTaskInfo* taskInfo) {










5511



  int32_t code = 0;




25,477✔





5512



  code = tblCountScanGetInputs(groupTags, tableName, supp);




25,477✔





5513



  if (code != TSDB_CODE_SUCCESS) {




25,477✔





5514



    qError("%s get table count scan supp. get inputs error", GET_TASKID(taskInfo));




×







5515



    return code;




×







5516



  }










5517












5518



  supp->dbNameSlotId = -1;




25,477✔





5519



  supp->stbNameSlotId = -1;




25,477✔





5520



  supp->tbCountSlotId = -1;




25,477✔





5521












5522



  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);




25,477✔





5523



  if (code != TSDB_CODE_SUCCESS) {




25,477✔





5524



    qError("%s get table count scan supp. get group tags slot id error", GET_TASKID(taskInfo));




×







5525



    return code;




×







5526



  }










5527












5528



  code = tblCountScanGetCountSlotId(pseudoCols, supp);




25,477✔





5529



  if (code != TSDB_CODE_SUCCESS) {




25,477✔





5530



    qError("%s get table count scan supp. get count error", GET_TASKID(taskInfo));




×







5531



    return code;




×







5532



  }










5533



  return code;




25,477✔





5534



}










5535












5536



int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,




25,477✔





5537



                                         SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










5538



  QRY_PARAM_CHECK(pOptrInfo);




25,477✔





5539












5540



  int32_t                      code = TSDB_CODE_SUCCESS;




25,477✔





5541



  int32_t                      lino = 0;




25,477✔





5542



  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;




25,477✔





5543



  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));




25,477✔





5544



  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




25,477✔





5545



  if (!pInfo || !pOperator) {




25,477✔





5546



    code = terrno;




×







5547



    goto _error;




×







5548



  }










5549












5550



  pInfo->readHandle = *readHandle;




25,477✔





5551












5552



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




25,477✔





5553



  initResultSizeInfo(&pOperator->resultInfo, 1);




25,477✔





5554



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




25,477✔





5555



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




25,477✔





5556












5557



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




25,477✔





5558



  QUERY_CHECK_CODE(code, lino, _error);




25,477✔





5559












5560



  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,




25,477✔





5561



                               pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp,










5562



                               pTaskInfo);










5563



  QUERY_CHECK_CODE(code, lino, _error);




25,477✔





5564












5565



  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,




25,477✔





5566



                  pInfo, pTaskInfo);










5567



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,




25,473✔





5568



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










5569



  *pOptrInfo = pOperator;




25,473✔





5570



  return code;




25,477✔





5571












5572



_error:




×







5573



  if (pInfo != NULL) {




×







5574



    destoryTableCountScanOperator(pInfo);




×







5575



  }










5576



  if (pOperator != NULL) {




×







5577



    pOperator->info = NULL;




×







5578



    destroyOperator(pOperator);




×







5579



  }










5580



  pTaskInfo->code = code;




×







5581



  return code;




×







5582



}










5583












5584



int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,




32,929✔





5585



                                    SSDataBlock* pRes) {










5586



  int32_t code = TSDB_CODE_SUCCESS;




32,929✔





5587



  int32_t lino = 0;




32,929✔





5588



  if (pSupp->dbNameSlotId != -1) {




32,929✔





5589



    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




14,520✔





5590



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);




14,520✔





5591



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




14,520✔





5592












5593



    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




14,520✔





5594



    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);




14,520✔





5595












5596



    varDataSetLen(varDbName, strlen(dbName));




14,520✔





5597



    code = colDataSetVal(colInfoData, 0, varDbName, false);




14,520✔





5598



    QUERY_CHECK_CODE(code, lino, _end);




14,520✔





5599



  }










5600












5601



  if (pSupp->stbNameSlotId != -1) {




32,929✔





5602



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);




14,348✔





5603



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




14,348✔





5604



    if (strlen(stbName) != 0) {




14,348✔





5605



      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




10,524✔





5606



      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);




10,524✔





5607



      varDataSetLen(varStbName, strlen(stbName));




10,524✔





5608



      code = colDataSetVal(colInfoData, 0, varStbName, false);




10,524✔





5609



      QUERY_CHECK_CODE(code, lino, _end);




10,524✔





5610



    } else {










5611



      colDataSetNULL(colInfoData, 0);










5612



    }










5613



  }










5614












5615



  if (pSupp->tbCountSlotId != -1) {




32,929✔





5616



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);




32,754✔





5617



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




32,866✔





5618



    code = colDataSetVal(colInfoData, 0, (char*)&count, false);




32,866✔





5619



    QUERY_CHECK_CODE(code, lino, _end);




32,866✔





5620



  }










5621



  pRes->info.rows = 1;




33,041✔





5622












5623



_end:




32,898✔





5624



  if (code != TSDB_CODE_SUCCESS) {




32,898✔





5625



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5626



  }










5627



  return code;




32,754✔





5628



}










5629












5630



static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {




9,283✔





5631



  STableCountScanSupp* pSupp = &pInfo->supp;




9,283✔





5632



  SSDataBlock*         pRes = pInfo->pRes;




9,283✔





5633












5634



  size_t infodbTableNum;




9,283✔





5635



  getInfosDbMeta(NULL, &infodbTableNum);




9,283✔





5636



  infodbTableNum -= 1;




9,283✔





5637



  size_t perfdbTableNum;




9,283✔





5638



  getPerfDbMeta(NULL, &perfdbTableNum);




9,283✔





5639












5640



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




9,283✔





5641



    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);




7,740✔





5642



    return (pRes->info.rows > 0) ? pRes : NULL;




7,740✔





5643



  } else {










5644



    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);




1,543✔





5645



    return (pRes->info.rows > 0) ? pRes : NULL;




1,543✔





5646



  }










5647



}










5648












5649



static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,




1,543✔





5650



                                       size_t infodbTableNum, size_t perfdbTableNum) {










5651



  int32_t        code = TSDB_CODE_SUCCESS;




1,543✔





5652



  int32_t        lino = 0;




1,543✔





5653



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,543✔





5654



  if (strlen(pSupp->stbNameFilter) != 0) {




1,543✔





5655



    // sys dbs do not contain any stable, so the count is always 0










5656



    code = fillTableCountScanDataBlock(pSupp, "", "", 0, pRes);




525✔





5657



    QUERY_CHECK_CODE(code, lino, _end);




525✔





5658



  } else if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) {




1,018✔





5659



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




175✔





5660



    QUERY_CHECK_CODE(code, lino, _end);




175✔





5661



  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {




843✔





5662



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




×







5663



    QUERY_CHECK_CODE(code, lino, _end);




×







5664



  } else if (strlen(pSupp->dbNameFilter) == 0) {




843✔





5665



    code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes);




668✔





5666



    QUERY_CHECK_CODE(code, lino, _end);




668✔





5667



  } else {










5668



    // other dbs do not exist in sys dbs, so the count is always 0










5669



    code = fillTableCountScanDataBlock(pSupp, pSupp->dbNameFilter, pSupp->stbNameFilter, 0, pRes);




175✔





5670



    QUERY_CHECK_CODE(code, lino, _end);




175✔





5671



  }










5672












5673



_end:




175✔





5674



  if (code != TSDB_CODE_SUCCESS) {




1,543✔





5675



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5676



    pTaskInfo->code = code;




×







5677



    T_LONG_JMP(pTaskInfo->env, code);




×







5678



  }










5679



  setOperatorCompleted(pOperator);




1,543✔





5680



}




1,543✔





5681












5682



static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




7,740✔





5683



                                        STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5684



                                        size_t perfdbTableNum) {










5685



  int32_t        code = TSDB_CODE_SUCCESS;




7,740✔





5686



  int32_t        lino = 0;




7,740✔





5687



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




7,740✔





5688



  if (pInfo->currGrpIdx == 0) {




7,740✔





5689



    uint64_t groupId = 0;




2,580✔





5690



    if (pSupp->groupByDbName) {




2,580✔





5691



      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));




2,107✔





5692



    } else {










5693



      groupId = calcGroupId("", 0);




473✔





5694



    }










5695












5696



    pRes->info.id.groupId = groupId;




2,580✔





5697



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




2,580✔





5698



    QUERY_CHECK_CODE(code, lino, _end);




2,580✔





5699



  } else if (pInfo->currGrpIdx == 1) {




5,160✔





5700



    uint64_t groupId = 0;




2,580✔





5701



    if (pSupp->groupByDbName) {




2,580✔





5702



      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));




2,107✔





5703



    } else {










5704



      groupId = calcGroupId("", 0);




473✔





5705



    }










5706












5707



    pRes->info.id.groupId = groupId;




2,580✔





5708



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




2,580✔





5709



    QUERY_CHECK_CODE(code, lino, _end);




2,580✔





5710



  } else {










5711



    setOperatorCompleted(pOperator);




2,580✔





5712



  }










5713



  pInfo->currGrpIdx++;




7,740✔





5714












5715



_end:




7,740✔





5716



  if (code != TSDB_CODE_SUCCESS) {




7,740✔





5717



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5718



    pTaskInfo->code = code;




×







5719



    T_LONG_JMP(pTaskInfo->env, code);




×







5720



  }










5721



}




7,740✔





5722












5723



static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




58,375✔





5724



  int32_t                      code = TSDB_CODE_SUCCESS;




58,375✔





5725



  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;




58,375✔





5726



  STableCountScanOperatorInfo* pInfo = pOperator->info;




58,375✔





5727



  STableCountScanSupp*         pSupp = &pInfo->supp;




58,406✔





5728



  SSDataBlock*                 pRes = pInfo->pRes;




58,375✔





5729












5730



  blockDataCleanup(pRes);




58,406✔





5731



  QRY_PARAM_CHECK(ppRes);




58,406✔





5732












5733



  if (pOperator->status == OP_EXEC_DONE) {




58,406✔





5734



    return code;




16,649✔





5735



  }










5736












5737



  if (pInfo->readHandle.mnd != NULL) {




41,757✔





5738



    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);




9,283✔





5739



    return code;




9,283✔





5740



  }










5741












5742



  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);




32,474✔





5743



  if (code != TSDB_CODE_SUCCESS) {




32,267✔





5744



    qError("%s failed since %s", __func__, tstrerror(code));




×







5745



    pTaskInfo->code = code;




×







5746



    T_LONG_JMP(pTaskInfo->env, code);




×







5747



  }










5748



  if (pRes->info.rows > 0) {




32,267✔





5749



    *ppRes = pRes;




26,226✔





5750



  }










5751












5752



  return code;




32,442✔





5753



}










5754












5755



static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




32,474✔





5756



                                      STableCountScanSupp* pSupp, SSDataBlock* pRes) {










5757



  int32_t        code = TSDB_CODE_SUCCESS;




32,474✔





5758



  int32_t        lino = 0;




32,474✔





5759



  const char*    db = NULL;




32,474✔





5760



  int32_t        vgId = 0;




32,474✔





5761



  char           dbName[TSDB_DB_NAME_LEN] = {0};




32,474✔





5762



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




32,474✔





5763



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




32,474✔





5764












5765



  // get dbname










5766



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);




32,474✔





5767



  SName sn = {0};




32,474✔





5768












5769



  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);




32,474✔





5770



  QUERY_CHECK_CODE(code, lino, _end);




32,474✔





5771












5772



  code = tNameGetDbName(&sn, dbName);




32,474✔





5773



  QUERY_CHECK_CODE(code, lino, _end);




32,299✔





5774












5775



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




32,299✔





5776



    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);




21,128✔





5777



  } else {










5778



    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);




11,171✔





5779



  }










5780












5781



_end:




32,474✔





5782



  if (code != TSDB_CODE_SUCCESS) {




32,474✔





5783



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5784



    pTaskInfo->code = code;




×







5785



  }










5786












5787



  return code;




32,474✔





5788



}










5789












5790



static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




21,128✔





5791



                                           STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) {










5792



  int32_t        code = TSDB_CODE_SUCCESS;




21,128✔





5793



  int32_t        lino = 0;




21,128✔





5794



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




21,128✔





5795



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




21,128✔





5796












5797



  if (pSupp->groupByStbName) {




21,128✔





5798



    if (pInfo->stbUidList == NULL) {




17,368✔





5799



      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));




6,248✔





5800



      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);




6,248✔





5801



      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);




6,248✔





5802



      QUERY_CHECK_CODE(code, lino, _end);




6,248✔





5803



    }










5804












5805



    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {




17,368✔





5806



      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);




10,524✔





5807



      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);




10,524✔





5808



      QUERY_CHECK_CODE(code, lino, _end);




10,524✔





5809












5810



      pInfo->currGrpIdx++;




10,524✔





5811



    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {




6,844✔





5812



      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);




6,248✔





5813



      QUERY_CHECK_CODE(code, lino, _end);




6,248✔





5814












5815



      pInfo->currGrpIdx++;




6,248✔





5816



    } else {










5817



      setOperatorCompleted(pOperator);




596✔





5818



    }










5819



  } else {










5820



    uint64_t groupId = calcGroupId(dbName, strlen(dbName));




3,760✔





5821



    pRes->info.id.groupId = groupId;




3,760✔





5822












5823



    int64_t dbTableCount = 0;




3,760✔





5824



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);




3,760✔





5825



    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);




3,760✔





5826



    QUERY_CHECK_CODE(code, lino, _end);




3,760✔





5827



    setOperatorCompleted(pOperator);




3,760✔





5828



  }










5829












5830



_end:




21,128✔





5831



  if (code != TSDB_CODE_SUCCESS) {




21,128✔





5832



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5833



    pTaskInfo->code = code;




×







5834



  }










5835



  return code;




21,128✔





5836



}










5837












5838



static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




11,346✔





5839



                                         STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) {










5840



  int32_t        code = TSDB_CODE_SUCCESS;




11,346✔





5841



  int32_t        lino = 0;




11,346✔





5842



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




11,346✔





5843



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




11,346✔





5844












5845



  if (strlen(pSupp->dbNameFilter) != 0 && strcmp(dbName, pSupp->dbNameFilter) != 0) {




11,171✔





5846



    // db name not match, return count 0










5847



    code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




×







5848



    QUERY_CHECK_CODE(code, lino, _end);




×







5849



  } else if (strlen(pSupp->stbNameFilter) != 0) {




11,346✔





5850



    uint64_t uid = 0;




5,425✔





5851



    code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid);




5,425✔





5852



    if (code == TSDB_CODE_TDB_TABLE_NOT_EXIST) {




5,568✔





5853



      // table not exist, return count 0










5854



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




1,400✔





5855



      QUERY_CHECK_CODE(code, lino, _end);




1,575✔





5856



    } else {










5857



      QUERY_CHECK_CODE(code, lino, _end);




4,168✔





5858












5859



      int64_t numOfChildTables = 0;




4,168✔





5860



      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL, NULL);




4,137✔





5861



      QUERY_CHECK_CODE(code, lino, _end);




4,169✔





5862












5863



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes);




4,169✔





5864



      QUERY_CHECK_CODE(code, lino, _end);




4,025✔





5865



    }










5866



  } else {










5867



    int64_t tbNumVnode = 0;




5,746✔





5868



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);




5,746✔





5869



    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);




5,746✔





5870



    QUERY_CHECK_CODE(code, lino, _end);




5,746✔





5871



  }










5872












5873



_end:




11,346✔





5874



  if (code != TSDB_CODE_SUCCESS) {




11,346✔





5875



    pTaskInfo->code = code;




×







5876



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5877



  }










5878












5879



  setOperatorCompleted(pOperator);




11,346✔





5880



  return code;




11,346✔





5881



}










5882












5883



static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




6,248✔





5884



                                              SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) {










5885



  int32_t code = TSDB_CODE_SUCCESS;




6,248✔





5886



  int32_t lino = 0;




6,248✔





5887



  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




6,248✔





5888



  if (pSupp->groupByDbName) {




6,248✔





5889



    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");




3,760✔





5890



  }










5891












5892



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




6,248✔





5893



  pRes->info.id.groupId = groupId;




6,248✔





5894












5895



  int64_t numOfTables = 0;




6,248✔





5896



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);




6,248✔





5897












5898



  if (numOfTables != 0) {




6,248✔





5899



    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);




596✔





5900



  }










5901












5902



_end:




5,652✔





5903



  if (code != TSDB_CODE_SUCCESS) {




6,248✔





5904



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5905



  }










5906



  return code;




6,248✔





5907



}










5908












5909



static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




10,524✔





5910



                                              SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) {










5911



  int32_t code = TSDB_CODE_SUCCESS;




10,524✔





5912



  int32_t lino = 0;




10,524✔





5913



  char    stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




10,524✔





5914



  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);




10,524✔





5915



  QUERY_CHECK_CODE(code, lino, _end);




10,524✔





5916












5917



  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




10,524✔





5918



  if (pSupp->groupByDbName) {




10,524✔





5919



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));




6,248✔





5920



  } else {










5921



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));




4,127✔





5922



  }










5923












5924



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




10,524✔





5925



  pRes->info.id.groupId = groupId;




10,524✔





5926












5927



  int64_t ctbNum = 0;




10,524✔





5928



  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL, NULL);




10,524✔





5929



  QUERY_CHECK_CODE(code, lino, _end);




10,524✔





5930



  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);




10,524✔





5931



  QUERY_CHECK_CODE(code, lino, _end);




10,524✔





5932












5933



_end:




10,524✔





5934



  if (code != TSDB_CODE_SUCCESS) {




10,524✔





5935



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5936



  }










5937



  return code;




10,524✔





5938



}










5939












5940



static void destoryTableCountScanOperator(void* param) {




25,477✔





5941



  STableCountScanOperatorInfo* pTableCountScanInfo = param;




25,477✔





5942



  blockDataDestroy(pTableCountScanInfo->pRes);




25,477✔





5943












5944



  taosArrayDestroy(pTableCountScanInfo->stbUidList);




25,328✔





5945



  taosMemoryFreeClear(param);




25,477✔





5946



}




25,477✔



















    

  • 

    •