taosdata / TDengine / #4962

coverage: 66.872% (+0.07%) from 66.798%
#4962

push

travis-ci

web-flow 
docs: add support for recording STMT to CSV files (#34276)

* docs: add support for recording STMT to CSV files

* docs: update version for STMT recording feature in CSV files

205763 of 307696 relevant lines covered (66.87%)

127640448.9 hits per line

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

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









16



#include "executor.h"










17



#include "executorInt.h"










18



#include "filter.h"










19



#include "function.h"










20



#include "functionMgt.h"










21



#include "os.h"










22



#include "querynodes.h"










23



#include "streamexecutorInt.h"










24



#include "systable.h"










25



#include "tname.h"










26












27



#include "tdatablock.h"










28



#include "tmsg.h"










29



#include "ttime.h"










30












31



#include "operator.h"










32



#include "query.h"










33



#include "querytask.h"










34



#include "tcompare.h"










35



#include "thash.h"










36



#include "ttypes.h"










37












38



#include "function.h"










39



#include "storageapi.h"










40



#include "wal.h"










41












42



int32_t scanDebug = 0;










43












44



#define MULTI_READER_MAX_TABLE_NUM     5000










45



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










46



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










47



#define STREAM_SCAN_OP_NAME            "StreamScanOperator"










48



#define STREAM_SCAN_OP_STATE_NAME      "StreamScanFillHistoryState"










49



#define STREAM_SCAN_OP_CHECKPOINT_NAME "StreamScanOperator_Checkpoint"










50












51



typedef struct STableMergeScanExecInfo {










52



  SFileBlockLoadRecorder blockRecorder;










53



  SSortExecInfo          sortExecInfo;










54



} STableMergeScanExecInfo;










55












56



typedef struct STableMergeScanSortSourceParam {










57



  SOperatorInfo* pOperator;










58



  int32_t        readerIdx;










59



  uint64_t       uid;










60



  STsdbReader*   reader;










61



} STableMergeScanSortSourceParam;










62












63



typedef struct STableCountScanOperatorInfo {










64



  SReadHandle  readHandle;










65



  SSDataBlock* pRes;










66












67



  STableCountScanSupp supp;










68












69



  int32_t currGrpIdx;










70



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










71



} STableCountScanOperatorInfo;










72












73



static bool    processBlockWithProbability(const SSampleExecInfo* pInfo);










74



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










75












76



bool processBlockWithProbability(const SSampleExecInfo* pInfo) {




582,829,276✔





77



#if 0










78



  if (pInfo->sampleRatio == 1) {










79



    return true;










80



  }










81












82



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










83



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










84



#else










85



  return true;




582,829,276✔





86



#endif










87



}










88












89



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




67,457✔





90



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




67,457✔





91



    SWITCH_ORDER(pCtx[i].order);




×







92



  }










93



}




67,457✔





94












95



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




632,098,333✔





96



  int32_t     code = TSDB_CODE_SUCCESS;




632,098,333✔





97



  STimeWindow w = {0};




632,098,333✔





98












99



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










100



  if (pInterval->interval == 0) {




632,155,431✔





101



    *overlap = false;




593,790,030✔





102



    return code;




593,806,825✔





103



  }










104












105



  if (order == TSDB_ORDER_ASC) {




38,333,843✔





106



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




36,205,721✔





107



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




36,202,610✔





108



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




×







109



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







110



    }










111












112



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




36,198,994✔





113



      *overlap = true;




31,530,456✔





114



      return code;




31,530,433✔





115



    }










116












117



    while (1) {










118



      getNextTimeWindow(pInterval, &w, order);




4,670,963✔





119



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




4,672,511✔





120



        break;




4,405,235✔





121



      }










122












123



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




267,563✔





124



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




×







125



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







126



      }










127



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




267,563✔





128



        *overlap = true;




267,563✔





129



        return code;




267,563✔





130



      }










131



    }










132



  } else {










133



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




2,128,122✔





134



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




2,128,546✔





135



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




×







136



      return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







137



    }










138












139



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




2,127,497✔





140



      *overlap = true;




1,668,446✔





141



      return code;




1,668,876✔





142



    }










143












144



    while (1) {










145



      getNextTimeWindow(pInterval, &w, order);




460,100✔





146



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




459,475✔





147



        break;




457,514✔





148



      }










149












150



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




2,586✔





151



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




×







152



        return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







153



      }










154



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




2,586✔





155



        *overlap = true;




2,586✔





156



        return code;




2,586✔





157



      }










158



    }










159



  }










160












161



  *overlap = false;




4,862,749✔





162



  return code;




4,862,360✔





163



}










164












165



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










166



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




164,907,504✔





167



  if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {




164,907,504✔





168



    return NULL;




×







169



  }










170












171



  int64_t buf[2] = {0};




164,919,807✔





172



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




164,904,175✔





173












174



  STableScanInfo* pTableScanInfo = pOperator->info;




164,911,584✔





175












176



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




164,899,218✔





177



                                                               buf, GET_RES_WINDOW_KEY_LEN(sizeof(groupId)));










178












179



  if (p1 == NULL) {




164,923,246✔





180



    return NULL;




47,894,865✔





181



  }










182












183



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




117,028,381✔





184



  if (NULL == *pPage) {




117,019,285✔





185



    return NULL;




×







186



  }










187












188



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




117,019,875✔





189



}










190












191



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




12,776,633✔





192



  if (NULL == pTableScanInfo->pIgnoreTables) {




12,776,633✔





193



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




1,363,052✔





194



    pTableScanInfo->pIgnoreTables =




1,363,052✔





195



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




1,363,052✔





196



    if (NULL == pTableScanInfo->pIgnoreTables) {




1,363,052✔





197



      return terrno;




×







198



    }










199



  }










200












201



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




12,776,633✔





202



                                sizeof(pTableScanInfo->scanTimes));










203



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




12,775,406✔





204



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




×







205



    return tempRes;




×







206



  }










207



  return TSDB_CODE_SUCCESS;




12,775,406✔





208



}










209












210



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




694,523,573✔





211



  STableScanInfo* pTableScanInfo = pOperator->info;




694,523,573✔





212



  int32_t         code = TSDB_CODE_SUCCESS;




694,637,832✔





213












214



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




694,637,832✔





215



    return TSDB_CODE_SUCCESS;




529,747,346✔





216



  }










217












218



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




164,908,967✔





219












220



  SFilePage*  pPage = NULL;




164,929,132✔





221



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




164,925,285✔





222












223



  if (pRow == NULL) {




164,906,235✔





224



    return TSDB_CODE_SUCCESS;




47,895,342✔





225



  }










226












227



  bool notLoadBlock = true;




117,010,893✔





228



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




2,147,483,647✔





229



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




2,147,483,647✔





230












231



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




2,147,483,647✔





232












233



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




2,147,483,647✔





234



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




2,147,483,647✔





235



      notLoadBlock = false;




104,252,907✔





236



      break;




104,252,907✔





237



    }










238



  }










239












240



  // release buffer pages










241



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




116,866,539✔





242












243



  if (notLoadBlock) {




117,028,271✔





244



    *status = FUNC_DATA_REQUIRED_NOT_LOAD;




12,776,633✔





245



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




12,776,633✔





246



  }










247












248



  return code;




117,022,835✔





249



}










250












251



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




8,518,401✔





252



                                  int32_t numOfRows, bool* keep) {










253



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




8,518,401✔





254



    *keep = true;




×







255



    return TSDB_CODE_SUCCESS;




×







256



  }










257












258



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




8,519,131✔





259



}










260












261



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




146,468,314✔





262



                              bool* pLoad) {










263



  SStorageAPI* pAPI = &pTaskInfo->storageAPI;




146,468,314✔





264



  bool         allColumnsHaveAgg = true;




146,478,868✔





265



  bool         hasNullSMA = false;




146,484,449✔





266



  if (pLoad != NULL) {




146,475,869✔





267



    *pLoad = false;




146,457,605✔





268



  }










269












270



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




146,478,343✔





271



                                                               &hasNullSMA);










272



  if (code != TSDB_CODE_SUCCESS) {




146,471,140✔





273



    return code;




×







274



  }










275












276



  if (!allColumnsHaveAgg || hasNullSMA) {




146,471,140✔





277



    *pLoad = false;




132,267,148✔





278



  } else {










279



    *pLoad = true;




14,203,992✔





280



  }










281












282



  return code;




146,466,023✔





283



}










284












285



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




728,150,470✔





286



                                  int32_t rows) {










287



  int32_t    code = 0;




728,150,470✔





288



  SExprSupp* pSup = &pTableScanInfo->pseudoSup;




728,150,470✔





289



  if (pSup->numOfExprs > 0) {




728,259,910✔





290



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




339,182,818✔





291



                                  pTaskInfo, &pTableScanInfo->metaCache);










292



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










293



    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




339,122,029✔





294



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




×







295



      code = 0;




×







296



    }










297



  }










298












299



  return code;




728,160,765✔





300



}










301












302



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




1,190,541,103✔





303



  SLimit*     pLimit = &pLimitInfo->limit;




1,190,541,103✔





304



  const char* id = GET_TASKID(pTaskInfo);




1,190,592,083✔





305












306



  if (pLimitInfo->remainOffset > 0) {




1,190,649,262✔





307



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




5,294,037✔





308



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




2,657,579✔





309



      blockDataEmpty(pBlock);




2,657,579✔





310



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




2,657,579✔





311



      return false;




2,657,579✔





312



    } else {










313



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




2,636,458✔





314



      if (code != TSDB_CODE_SUCCESS) {




2,636,458✔





315



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




×







316



        pTaskInfo->code = code;




×







317



        T_LONG_JMP(pTaskInfo->env, code);




×







318



      }










319



      pLimitInfo->remainOffset = 0;




2,636,458✔





320



    }










321



  }










322












323



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




1,187,979,281✔





324



    // limit the output rows










325



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




25,643,080✔





326



    blockDataKeepFirstNRows(pBlock, keep);




25,643,567✔





327












328



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




25,643,562✔





329



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




25,643,567✔





330



    return true;




25,643,567✔





331



  }










332












333



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




1,162,241,090✔





334



  return false;




1,162,323,547✔





335



}










336












337



static bool isDynVtbScan(SOperatorInfo* pOperator) {




×







338



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




×







339



}










340












341



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




725,758,553✔





342



                             uint32_t* status) {










343



  int32_t        code = TSDB_CODE_SUCCESS;




725,758,553✔





344



  int32_t        lino = 0;




725,758,553✔





345



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




725,758,553✔





346



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




725,842,847✔





347



  bool           loadSMA = false;




725,805,231✔





348












349



  SFileBlockLoadRecorder* pCost = &pTableScanInfo->readRecorder;




725,805,231✔





350












351



  pCost->totalBlocks += 1;




725,868,051✔





352



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




725,789,429✔





353



  *status = pTableScanInfo->dataBlockLoadFlag;




725,844,425✔





354












355



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




725,794,011✔





356



    (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




93,609,799✔





357



  } else {










358



    bool overlap = false;




632,164,704✔





359



    int  ret =










360



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




632,210,786✔





361



    if (ret != TSDB_CODE_SUCCESS) {




632,000,467✔





362



      return ret;




×







363



    }










364



    if (overlap) {




632,000,467✔





365



      (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;




33,464,417✔





366



    }










367



  }










368












369



  SDataBlockInfo* pBlockInfo = &pBlock->info;




725,636,708✔





370



  taosMemoryFreeClear(pBlock->pBlockAgg);




725,776,739✔





371












372



  if (*status == FUNC_DATA_REQUIRED_FILTEROUT) {




725,842,942✔





373



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




×







374



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










375



    pCost->filterOutBlocks += 1;




×







376



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




×







377



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




×







378



    return TSDB_CODE_SUCCESS;




×







379



  } else if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




725,664,549✔





380



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




22,079,136✔





381



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










382



           pBlockInfo->id.uid);










383



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




22,083,319✔





384



    pCost->skipBlocks += 1;




22,080,878✔





385



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




22,079,822✔





386



    return code;




22,078,912✔





387



  } else if (*status == FUNC_DATA_REQUIRED_SMA_LOAD) {




703,574,223✔





388



    pCost->loadBlockStatis += 1;




52,856,026✔





389



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




52,850,434✔





390



    bool success = true;




52,850,434✔





391



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




52,852,715✔





392



    if (code) {




52,849,167✔





393



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




×







394



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




×







395



      QUERY_CHECK_CODE(code, lino, _end);




×







396



    }










397












398



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




52,841,633✔





399



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




5,683,985✔





400



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










401



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




5,684,528✔





402



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




5,685,696✔





403



      return code;




5,685,842✔





404



    } else {










405



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




47,157,648✔





406



      *status = FUNC_DATA_REQUIRED_DATA_LOAD;




47,164,424✔





407



    }










408



  }










409












410



  if (*status != FUNC_DATA_REQUIRED_DATA_LOAD) {




697,893,049✔





411



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




×







412



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




×







413



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







414



  }










415












416



  // try to filter data block according to sma info










417



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




697,898,871✔





418



    bool success = true;




93,623,137✔





419



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




93,628,109✔





420



    if (code) {




93,598,182✔





421



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




×







422



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




×







423



      QUERY_CHECK_CODE(code, lino, _end);




18,348✔





424



    }










425












426



    if (success) {




93,616,530✔





427



      size_t size = taosArrayGetSize(pBlock->pDataBlock);




8,518,401✔





428



      bool   keep = false;




8,518,985✔





429



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




8,518,985✔





430



      if (code) {




8,518,985✔





431



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




×







432



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




×







433



        QUERY_CHECK_CODE(code, lino, _end);




×







434



      }










435












436



      if (!keep) {




8,518,401✔





437



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




3,372,631✔





438



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










439



        pCost->filterOutBlocks += 1;




3,372,631✔





440



        (*status) = FUNC_DATA_REQUIRED_FILTEROUT;




3,372,631✔





441



        taosMemoryFreeClear(pBlock->pBlockAgg);




3,372,631✔





442












443



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




3,372,631✔





444



        return TSDB_CODE_SUCCESS;




3,372,631✔





445



      }










446



    }










447



  }










448












449



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










450



  taosMemoryFreeClear(pBlock->pBlockAgg);




694,616,610✔





451












452



  // try to filter data block according to current results










453



  code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status);




694,536,914✔





454



  if (code) {




694,576,039✔





455



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




×







456



    QUERY_CHECK_CODE(code, lino, _end);




×







457



  }










458












459



  if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) {




694,576,039✔





460



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




12,775,021✔





461



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










462



    pCost->skipBlocks += 1;




12,776,651✔





463



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




12,776,633✔





464












465



    STableScanInfo* p1 = pOperator->info;




12,776,633✔





466



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




12,776,633✔





467



      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;




3,134,207✔





468



    } else {










469



      *status = FUNC_DATA_REQUIRED_FILTEROUT;




9,642,426✔





470



    }










471



    return TSDB_CODE_SUCCESS;




12,776,633✔





472



  }










473












474



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




681,781,729✔





475



  pCost->loadBlocks += 1;




681,903,069✔





476












477



  SSDataBlock* p = NULL;




681,798,955✔





478



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




681,791,157✔





479



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




681,819,569✔





480



    return code;




×







481



  }










482












483



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




681,819,569✔





484



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




540,707,549✔





485



    // do nothing










486



  } else {










487



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










488



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




653,343,916✔





489



    if (code) {




653,429,262✔





490



      return code;




×







491



    }










492



  }










493












494



  // restore the previous value










495



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




681,785,057✔





496












497



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




681,848,506✔





498



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




90,227,655✔





499



    QUERY_CHECK_CODE(code, lino, _end);




90,208,115✔





500












501



    int64_t st = taosGetTimestampUs();




90,093,089✔





502



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




90,088,983✔





503



    pTableScanInfo->readRecorder.filterTime += el;




90,088,983✔





504












505



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




90,070,351✔





506



      pCost->filterOutBlocks += 1;




14,355,548✔





507



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




14,362,281✔





508



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










509



    } else {










510



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




75,709,962✔





511



    }










512



  }










513












514



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




681,684,821✔





515



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




681,724,409✔





516



    setOperatorCompleted(pOperator);




3,133,084✔





517



  }










518












519



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




681,724,438✔





520












521



_end:




681,846,506✔





522



  if (code != TSDB_CODE_SUCCESS) {




681,850,200✔





523



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




130,944✔





524



  }










525



  return code;




681,744,354✔





526



}










527












528



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




67,457✔





529



  SET_REVERSE_SCAN_FLAG(pTableScanInfo);




67,457✔





530












531



  switchCtxOrder(pCtx, numOfOutput);




67,457✔





532



  pTableScanInfo->cond.order = TSDB_ORDER_DESC;




67,457✔





533



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










534



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










535



}




67,457✔





536












537



typedef struct STableCachedVal {










538



  const char* pName;










539



  STag*       pTags;










540



} STableCachedVal;










541












542



static void freeTableCachedVal(void* param) {




×







543



  if (param == NULL) {




×







544



    return;




×







545



  }










546












547



  STableCachedVal* pVal = param;




×







548



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




×







549



  taosMemoryFree(pVal->pTags);




×







550



  taosMemoryFree(pVal);




×







551



}










552












553



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




×







554



  int32_t          code = TSDB_CODE_SUCCESS;




×







555



  int32_t          lino = 0;




×







556



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




×







557



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




×







558












559



  pVal->pTags = NULL;




×







560



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




×







561



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




×







562












563



  // only child table has tag value










564



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




×







565



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




×







566



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




×







567



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




×







568



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




×







569



  }










570












571



  (*ppResVal) = pVal;




×







572












573



_end:




×







574



  if (code != TSDB_CODE_SUCCESS) {




×







575



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




×







576



    freeTableCachedVal(pVal);




×







577



  }










578



  return code;




×







579



}










580












581



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










582



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




×







583



  (void)key;










584



  (void)keyLen;










585



  (void)ud;










586



  freeTableCachedVal(value);




×







587



}




×







588












589



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




×







590



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




×







591



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




×







592












593



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




×







594



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




×







595



  }










596



}




×







597












598



static void freeTableCachedValObj(STableCachedVal* pVal) {




×







599



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




×







600



  taosMemoryFree(pVal->pTags);




×







601



}




×







602












603



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




401,248,809✔





604



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










605



  int32_t          code = TSDB_CODE_SUCCESS;




401,248,809✔





606



  int32_t          lino = 0;




401,248,809✔





607



  bool             freeReader = false;




401,248,809✔





608



  LRUHandle*       h = NULL;




401,248,809✔





609



  STableCachedVal  val = {0};




401,248,809✔





610



  SMetaReader      mr = {0};




401,248,809✔





611



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




401,237,511✔





612



  int32_t          insertRet = TAOS_LRU_STATUS_OK;




401,265,295✔





613



  STableCachedVal* pVal = NULL;




401,265,295✔





614












615



  // currently only the tbname pseudo column










616



  if (numOfExpr <= 0) {




401,282,260✔





617



    return TSDB_CODE_SUCCESS;




295,783✔





618



  }










619












620



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










621












622



  // backup the rows










623



  int32_t backupRows = pBlock->info.rows;




400,986,477✔





624



  pBlock->info.rows = rows;




401,027,583✔





625












626



  // todo refactor: extract method










627



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










628












629



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










630



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




401,010,333✔





631



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




400,999,796✔





632



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




401,029,591✔





633



    if (code != TSDB_CODE_SUCCESS) {




400,862,014✔





634



      // when encounter the TSDB_CODE_PAR_TABLE_NOT_EXIST error, we proceed.










635



      if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







636



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




×







637



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










638












639



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










640



        doSetNullValue(pBlock, pExpr, numOfExpr);




×







641



      } else {










642



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




×







643



      }










644



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




×







645



      return code;




×







646



    }










647












648



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




400,862,014✔





649












650



    val.pName = mr.me.name;




400,988,283✔





651



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




400,988,283✔





652












653



    freeReader = true;




400,988,283✔





654



  } else {










655



    pCache->metaFetch += 1;




×







656












657



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




×







658



    if (h == NULL) {




×







659



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




×







660



      freeReader = true;




×







661



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




×







662



      if (code != TSDB_CODE_SUCCESS) {




×







663



        if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {




×







664



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




×







665



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










666



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










667



          doSetNullValue(pBlock, pExpr, numOfExpr);




×







668



        } else {










669



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




×







670



                 idStr);










671



        }










672



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




×







673



        return code;




×







674



      }










675












676



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




×







677












678



      code = createTableCacheVal(&mr, &pVal);




×







679



      QUERY_CHECK_CODE(code, lino, _end);




×







680












681



      val = *pVal;




×







682



    } else {










683



      pCache->cacheHit += 1;




×







684



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




×







685



      val = *pValTmp;




×







686












687



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




×







688



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




×







689



    }










690












691



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




×







692



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










693



  }










694












695



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




1,609,643,061✔





696



    const SExprInfo* pExpr1 = &pExpr[j];




1,208,635,441✔





697



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




1,208,629,322✔





698












699



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




1,208,766,254✔





700



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




1,208,675,784✔





701












702



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




1,208,652,023✔





703












704



    // this is to handle the tbname










705



    if (fmIsScanPseudoColumnFunc(functionId)) {




1,208,763,286✔





706



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




136,089,700✔





707



      if (fType == FUNCTION_TYPE_TBNAME) {




136,095,024✔





708



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




136,095,024✔





709



        QUERY_CHECK_CODE(code, lino, _end);




136,084,265✔





710



      } else if (fType == FUNCTION_TYPE_VGID) {




×







711



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




×







712



        QUERY_CHECK_CODE(code, lino, _end);




×







713



      } else if (fType == FUNCTION_TYPE_VGVER) {




×







714



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




×







715



        QUERY_CHECK_CODE(code, lino, _end);




×







716



      }










717



    } else {  // these are tags










718



      STagVal tagVal = {0};




1,072,513,877✔





719



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




1,072,500,557✔





720



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




1,072,642,828✔





721












722



      char* data = NULL;




1,072,660,682✔





723



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




1,072,660,682✔





724



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




1,067,484,033✔





725



      } else {










726



        data = (char*)p;




5,199,109✔





727



      }










728












729



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




1,072,534,346✔





730



      if (isNullVal) {




1,072,600,475✔





731



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




4,711,735✔





732



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




1,067,888,740✔





733



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




1,067,352,124✔





734



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




1,067,443,556✔





735



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




386,113,660✔





736



          if (tmp != NULL) {




386,140,691✔





737



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




386,140,691✔





738



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




386,148,523✔





739



                   pBlock->info.id.uid);










740



            taosMemoryFree(tmp);




386,178,194✔





741



          }










742



          taosMemoryFree(data);




386,172,452✔





743



        }










744



        QUERY_CHECK_CODE(code, lino, _end);




1,067,415,870✔





745



      } else {  // todo opt for json tag










746



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




3,027,708✔





747



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




2,539,960✔





748



          QUERY_CHECK_CODE(code, lino, _end);




2,540,334✔





749



        }










750



      }










751



    }










752



  }










753












754



  // restore the rows










755



  pBlock->info.rows = backupRows;




401,007,620✔





756












757



_end:




401,037,931✔





758












759



  if (NULL != pVal) {




400,976,672✔





760



    insertRet =




×







761



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




×







762



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










763



    if (insertRet != TAOS_LRU_STATUS_OK) {




×







764



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




×







765



    }










766



  }










767












768



  if (freeReader) {




400,976,672✔





769



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




400,981,503✔





770



  }










771



  if (code != TSDB_CODE_SUCCESS) {




401,007,957✔





772



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




×







773



  }










774



  return code;




400,995,164✔





775



}










776












777



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




136,078,129✔





778



                         const char* name) {










779



  int32_t                     code = TSDB_CODE_SUCCESS;




136,078,129✔





780



  int32_t                     lino = 0;




136,078,129✔





781



  struct SScalarFuncExecFuncs fpSet = {0};




136,078,129✔





782



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




136,084,929✔





783



  QUERY_CHECK_CODE(code, lino, _end);




136,085,263✔





784












785



  size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE;




136,085,263✔





786



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




136,085,263✔





787



  STR_TO_VARSTR(buf, name)




136,082,556✔





788












789



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




136,070,587✔





790












791



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




136,070,948✔





792



  QUERY_CHECK_CODE(code, lino, _end);




136,078,710✔





793












794



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




136,078,710✔





795



  QUERY_CHECK_CODE(code, lino, _end);




136,085,715✔





796












797



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




136,085,715✔





798



  SScalarParam param = {.columnData = pColInfoData};




136,084,935✔





799












800



  if (fpSet.process != NULL) {




136,070,205✔





801



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




136,070,205✔





802



    QUERY_CHECK_CODE(code, lino, _end);




136,091,903✔





803



  } else {










804



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




×







805



  }










806












807



  colDataDestroy(&infoData);




136,091,903✔





808












809



_end:




136,085,289✔





810



  if (code != TSDB_CODE_SUCCESS) {




136,088,042✔





811



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




×







812



  }










813



  return code;




136,088,042✔





814



}










815












816



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




×







817



  int32_t                     code = TSDB_CODE_SUCCESS;




×







818



  int32_t                     lino = 0;




×







819



  struct SScalarFuncExecFuncs fpSet = {0};




×







820



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







821



  QUERY_CHECK_CODE(code, lino, _end);




×







822












823



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




×







824












825



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




×







826



  QUERY_CHECK_CODE(code, lino, _end);




×







827












828



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




×







829



  QUERY_CHECK_CODE(code, lino, _end);




×







830












831



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




×







832



  SScalarParam param = {.columnData = pColInfoData};




×







833












834



  if (fpSet.process != NULL) {




×







835



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




×







836



    QUERY_CHECK_CODE(code, lino, _end);




×







837



  } else {










838



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




×







839



  }










840












841



_end:




×







842



  colDataDestroy(&infoData);




×







843



  if (code != TSDB_CODE_SUCCESS) {




×







844



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




×







845



  }










846



  return code;




×







847



}










848












849



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




×







850



  int32_t                     code = TSDB_CODE_SUCCESS;




×







851



  int32_t                     lino = 0;




×







852



  struct SScalarFuncExecFuncs fpSet = {0};




×







853



  code = fmGetScalarFuncExecFuncs(functionId, &fpSet);




×







854



  QUERY_CHECK_CODE(code, lino, _end);




×







855












856



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




×







857












858



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




×







859



  QUERY_CHECK_CODE(code, lino, _end);




×







860












861



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




×







862



  QUERY_CHECK_CODE(code, lino, _end);




×







863












864



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




×







865



  SScalarParam param = {.columnData = pColInfoData};




×







866












867



  if (fpSet.process != NULL) {




×







868



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




×







869



    QUERY_CHECK_CODE(code, lino, _end);




×







870



  } else {










871



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




×







872



  }










873












874



_end:




×







875



  colDataDestroy(&infoData);




×







876



  if (code != TSDB_CODE_SUCCESS) {




×







877



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




×







878



  }










879



  return code;




×







880



}










881












882



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




177,024,575✔





883



  int32_t code = TSDB_CODE_SUCCESS;




177,024,575✔





884



  int32_t lino = 0;




177,024,575✔





885



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




177,024,575✔





886



  QUERY_CHECK_CODE(code, lino, _end);




177,040,886✔





887












888



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




177,040,886✔





889



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




177,034,495✔





890



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




177,023,928✔





891



  taosMemoryFreeClear(pInfo->pResBlock->pBlockAgg);




176,991,560✔





892












893



  if (!pInfo->needCountEmptyTable) {




177,086,649✔





894



    pInfo->countState = TABLE_COUNT_STATE_END;




160,249,986✔





895



  } else {










896



    pInfo->countState = TABLE_COUNT_STATE_SCAN;




16,786,224✔





897



  }










898












899



_end:




176,992,030✔





900



  if (code != TSDB_CODE_SUCCESS) {




176,992,030✔





901



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




×







902



  }










903



  return code;




177,013,573✔





904



}










905












906



void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) {




603,830,413✔





907



  if (pInfo->countState == TABLE_COUNT_STATE_END) {




603,830,413✔





908



    return;




486,927,065✔





909



  }










910



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




116,948,445✔





911



    pInfo->countState = TABLE_COUNT_STATE_PROCESSED;




223,010✔





912



  } else {










913



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




116,722,971✔





914



    if (code != TSDB_CODE_SUCCESS) {




116,728,781✔





915



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




52,185,674✔





916



    }










917



  }










918



}










919












920



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




46,976,899✔





921



                                         const STableKeyInfo* tbInfo) {










922



  blockDataEmpty(pBlock);




46,976,899✔





923



  pBlock->info.rows = 1;




46,980,995✔





924



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




46,980,995✔





925



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




46,979,971✔





926



  pBlock->info.blankFill = true;




46,979,459✔





927












928



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










929



  int32_t col_num = blockDataGetNumOfCols(pBlock);




46,976,899✔





930



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




194,243,159✔





931



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




147,265,236✔





932



    colDataSetNULL(pColInfoData, 0);










933



  }










934












935



  // set tag/tbname










936



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




46,977,923✔





937












938



  return pBlock;




46,977,923✔





939



}










940












941



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




45,132,870✔





942



  STableScanInfo* pTableScanInfo = pOperator->info;




45,132,870✔





943



  SSDataBlock*    pBlock =










944



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




45,144,134✔





945












946



  pOperator->resultInfo.totalRows++;




45,141,062✔





947



  return pBlock;




45,148,230✔





948



}










949












950



/**










951



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










952



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










953



*/










954



static int32_t prepareTableScan(SOperatorInfo* pOperator) {




760,153,286✔





955



  int32_t code = TSDB_CODE_SUCCESS;




760,153,286✔





956



  int32_t lino = 0;




760,153,286✔





957












958



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




760,153,286✔





959



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




760,197,509✔





960



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




760,317,210✔





961



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




32,465,452✔





962



         NOTIFY_TYPE_SCAN_PARAM &&




3,006,508✔





963



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




3,006,508✔





964



    STableScanOperatorParam* pNotify =




3,006,508✔





965



      (STableScanOperatorParam*)pGetParam->value;










966












967



    STableScanInfo* pTableScanInfo = pOperator->info;




3,006,508✔





968



    SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




3,006,508✔





969



    SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




3,006,508✔





970



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




3,006,508✔





971



                                             pNotify->notifyTs);










972



    QUERY_CHECK_CODE(code, lino, _end);




3,006,508✔





973












974



    if (!pGetParam->reUse) {




3,006,508✔





975



      freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




95,996✔





976



    } else {










977



      /**










978



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










979



        the parent operator after getting next block.










980



      */










981



      pGetParam->reUse = false;




2,910,512✔





982



    }










983



    /**










984



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










985



    */










986



    pOperator->pOperatorGetParam = NULL;




3,006,508✔





987



  }










988












989



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




760,314,570✔





990



_end:




85,504,085✔





991



  if (code != TSDB_CODE_SUCCESS) {




760,313,107✔





992



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




×







993



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










994



  }










995



  return code;




760,311,895✔





996



}










997












998



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




721,255,683✔





999



  int32_t         code = TSDB_CODE_SUCCESS;




721,255,683✔





1000



  int32_t         lino = 0;




721,255,683✔





1001



  STableScanInfo* pTableScanInfo = pOperator->info;




721,255,683✔





1002



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




721,291,749✔





1003



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




721,265,634✔





1004



  SSDataBlock*    pBlock = pTableScanInfo->pResBlock;




721,335,019✔





1005



  bool            hasNext = false;




721,232,794✔





1006



  int64_t         st = taosGetTimestampUs();




721,225,563✔





1007












1008



  QRY_PARAM_CHECK(ppRes);




721,225,563✔





1009



  pBlock->info.dataLoad = false;




721,250,666✔





1010












1011



  while (true) {




20,863,646✔





1012



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




741,962,383✔





1013



    if (code != TSDB_CODE_SUCCESS) {




742,048,594✔





1014



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




29✔





1015



      QUERY_CHECK_CODE(code, lino, _end);




22✔





1016



    }










1017












1018



    if (!hasNext) {




742,033,708✔





1019



      break;




159,233,035✔





1020



    }










1021












1022



    if (isTaskKilled(pTaskInfo)) {




582,800,673✔





1023



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




18,543✔





1024



      code = pTaskInfo->code;




18,543✔





1025



      QUERY_CHECK_CODE(code, lino, _end);




18,543✔





1026



    }










1027












1028



    if (pOperator->status == OP_EXEC_DONE) {




582,913,091✔





1029



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




30,072✔





1030



      break;




30,072✔





1031



    }










1032












1033



    // process this data block based on the probabilities










1034



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




582,878,138✔





1035



    if (!processThisBlock) {




582,868,026✔





1036



      continue;




×







1037



    }










1038












1039



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




582,868,026✔





1040



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




582,898,944✔





1041



    }










1042












1043



    uint32_t status = 0;




582,900,560✔





1044



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




582,916,949✔





1045



    QUERY_CHECK_CODE(code, lino, _end);




582,807,128✔





1046












1047



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




582,693,080✔





1048



      break;




3,133,834✔





1049



    }










1050












1051



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










1052



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




579,559,246✔





1053



      continue;




20,863,646✔





1054



    }










1055












1056



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




558,725,992✔





1057



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




558,733,115✔





1058












1059



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




558,736,294✔





1060



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




558,753,154✔





1061












1062



    (*ppRes) = pBlock;




558,778,537✔





1063



    return code;




558,715,221✔





1064



  }










1065












1066



_end:




162,547,624✔





1067



  if (code != TSDB_CODE_SUCCESS) {




162,554,370✔





1068



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




148,986✔





1069



    pTaskInfo->code = code;




148,986✔





1070



    T_LONG_JMP(pTaskInfo->env, code);




132,591✔





1071



  }










1072



  return code;




162,405,384✔





1073



}










1074












1075



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




769,071,969✔





1076



  int32_t         code = TSDB_CODE_SUCCESS;




769,071,969✔





1077



  int32_t         lino = 0;




769,071,969✔





1078



  STableScanInfo* pTableScanInfo = pOperator->info;




769,071,969✔





1079



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




769,103,680✔





1080



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




769,061,479✔





1081












1082



  QRY_PARAM_CHECK(pBlock);




769,085,859✔





1083












1084



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










1085



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




769,042,885✔





1086



    return code;




2,785,828✔





1087



  }










1088












1089



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










1090



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




914,973,475✔





1091



    SSDataBlock* p = NULL;




633,313,362✔





1092



    code = doTableScanImplNext(pOperator, &p);




633,230,768✔





1093



    QUERY_CHECK_CODE(code, lino, _end);




633,144,679✔





1094












1095



    if (p != NULL) {




633,144,679✔





1096



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




484,440,346✔





1097



      *pBlock = p;




484,471,186✔





1098



      return code;




484,398,551✔





1099



    }










1100












1101



    pTableScanInfo->scanTimes += 1;




148,704,333✔





1102



    taosHashClear(pTableScanInfo->pIgnoreTables);




148,717,555✔





1103












1104



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




148,720,701✔





1105



      setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




86,024✔





1106



      pTableScanInfo->base.scanFlag = MAIN_SCAN;




86,024✔





1107



      pTableScanInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




86,024✔





1108



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




86,024✔





1109












1110



      // do prepare for the next round table scan operation










1111



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




86,024✔





1112



      QUERY_CHECK_CODE(code, lino, _end);




79,947✔





1113



    }










1114



  }










1115












1116



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




281,669,540✔





1117



  if (pTableScanInfo->scanTimes < total) {




281,676,940✔





1118



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




87,954,378✔





1119



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




67,457✔





1120



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




67,457✔





1121



      QUERY_CHECK_CODE(code, lino, _end);




67,457✔





1122



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




67,457✔





1123



    }










1124












1125



    while (pTableScanInfo->scanTimes < total) {




101,644,860✔





1126



      SSDataBlock* p = NULL;




87,956,985✔





1127



      code = doTableScanImplNext(pOperator, &p);




87,936,118✔





1128



      QUERY_CHECK_CODE(code, lino, _end);




87,894,621✔





1129












1130



      if (p != NULL) {




87,894,621✔





1131



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




74,207,338✔





1132



        *pBlock = p;




74,234,910✔





1133



        return code;




74,228,663✔





1134



      }










1135












1136



      pTableScanInfo->scanTimes += 1;




13,687,283✔





1137



      taosHashClear(pTableScanInfo->pIgnoreTables);




13,689,429✔





1138












1139



      if (pTableScanInfo->scanTimes < total) {




13,683,719✔





1140



        setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);




×







1141



        pTableScanInfo->base.scanFlag = MAIN_SCAN;




×







1142












1143



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




×







1144



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




×







1145



        QUERY_CHECK_CODE(code, lino, _end);




4,418✔





1146



      }










1147



    }










1148



  }










1149












1150



  if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) {




207,400,450✔





1151



    STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo;




61,273,730✔





1152



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




61,272,706✔





1153



      if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) {




116,278✔





1154



        pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;




2,984✔





1155



        STableKeyInfo* pStart =










1156



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




2,984✔





1157












1158



        if (NULL == pStart) {




2,984✔





1159



          return code;




×







1160



        }










1161












1162



        *pBlock = getBlockForEmptyTable(pOperator, pStart);




2,984✔





1163



        return code;




2,984✔





1164



      }










1165



    } else {  // group by tag + no sort










1166



      int32_t numOfTables = 0;




61,156,428✔





1167



      code = tableListGetSize(pTableListInfo, &numOfTables);




61,155,916✔





1168



      QUERY_CHECK_CODE(code, lino, _end);




61,158,485✔





1169












1170



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




61,158,485✔





1171



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










1172



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




60,340,656✔





1173



        if (pIte != NULL) {




60,340,138✔





1174



          size_t        keySize = 0;




45,144,734✔





1175



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




45,145,246✔





1176



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




45,145,246✔





1177



          taosHashCancelIterate(pTableListInfo->remainGroups, pIte);




45,145,246✔





1178



          markGroupProcessed(pTableScanInfo, *pGroupId);




45,143,710✔





1179



          *pBlock = getBlockForEmptyTable(pOperator, &info);




45,139,614✔





1180












1181



          return code;




45,141,662✔





1182



        }










1183



      }










1184



    }










1185



    pTableScanInfo->countState = TABLE_COUNT_STATE_END;




16,126,018✔





1186



  }










1187












1188



_end:




146,139,725✔





1189



  if (code != TSDB_CODE_SUCCESS) {




162,255,873✔





1190



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




×







1191



    pTaskInfo->code = code;




×







1192



  }










1193












1194



  return code;




162,255,873✔





1195



}










1196












1197



static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {




975,599✔





1198



  STableScanInfo*          pInfo = pOperator->info;




975,599✔





1199



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




975,599✔





1200



  int32_t                  code = 0;




975,599✔





1201



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




975,599✔





1202



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




975,599✔





1203



  int32_t                  num = taosArrayGetSize(pParam->pUidList);




975,599✔





1204



  if (num <= 0) {




975,599✔





1205



    qError("empty table scan uid list");




×







1206



    return TSDB_CODE_INVALID_PARA;




×







1207



  }










1208












1209



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




975,599✔





1210



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










1211



         pOperator->status);










1212












1213



  if (pParam->tableSeq) {




975,599✔





1214



    pListInfo->oneTableForEachGroup = true;




708,672✔





1215



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




708,672✔





1216



      taosHashClear(pListInfo->map);




×







1217



      taosArrayClear(pListInfo->pTableList);




×







1218



      pOperator->status = OP_EXEC_DONE;




×







1219



    }










1220



  } else {










1221



    pListInfo->oneTableForEachGroup = false;




266,927✔





1222



    pListInfo->numOfOuputGroups = 1;




266,927✔





1223



  }










1224



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




975,599✔





1225



    // do nothing










1226



  } else {










1227



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




704,172✔





1228



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




704,172✔





1229



  }










1230












1231



  STableKeyInfo info = {.groupId = 0};




975,599✔





1232



  int32_t       tableIdx = 0;




975,599✔





1233



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




9,059,569✔





1234



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




8,083,970✔





1235



    if (!pUid) {




8,081,922✔





1236



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




×







1237



      return terrno;




×







1238



    }










1239












1240



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




8,081,922✔





1241



      if (TSDB_CODE_DUP_KEY == terrno) {




6,760,211✔





1242



        continue;




6,760,211✔





1243



      }










1244



      return terrno;




×







1245



    }










1246












1247



    info.uid = *pUid;




1,325,295✔





1248



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




1,325,295✔





1249



    if (p == NULL) {




1,324,912✔





1250



      return terrno;




×







1251



    }










1252












1253



    tableIdx++;




1,324,912✔





1254



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




1,324,912✔





1255



  }










1256












1257



  return code;




975,599✔





1258



}










1259












1260



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




162,433,975✔





1261



                            STableKeyInfo** pList) {










1262



  const char* idStr = GET_TASKID(pTaskInfo);




162,433,975✔





1263



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




162,469,640✔





1264



  if (code) {




162,302,946✔





1265



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




×







1266



    return code;




×







1267



  }










1268












1269



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




162,302,946✔





1270



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




×







1271



    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;




×







1272



  }










1273












1274



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




324,803,092✔





1275



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




162,391,899✔





1276



  if (code) {




162,374,159✔





1277



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




2,255✔





1278



  }










1279












1280



  return code;




162,395,959✔





1281



}










1282












1283



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




308,179,130✔





1284



  SColIdPair* node1 = (SColIdPair*)elem1;




308,179,130✔





1285



  SColIdPair* node2 = (SColIdPair*)elem2;




308,179,130✔





1286












1287



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




308,179,130✔





1288



    return 0;




109,090✔





1289



  }










1290












1291



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




308,158,153✔





1292



}










1293












1294



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




413,825,094✔





1295



  SColIdSlotIdPair* node1 = (SColIdSlotIdPair*)elem1;




413,825,094✔





1296



  SColIdSlotIdPair* node2 = (SColIdSlotIdPair*)elem2;




413,825,094✔





1297












1298



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




413,825,094✔





1299



    return 0;




166,642✔





1300



  }










1301












1302



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




413,737,291✔





1303



}










1304












1305



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




×







1306



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




×







1307



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




×







1308












1309



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




×







1310



    return 0;




×







1311



  }










1312












1313



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




×







1314



}










1315












1316



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




96,490,532✔





1317



  if (pList == NULL) {




96,490,532✔





1318



    return NULL;




×







1319



  }










1320












1321



  int32_t left = 0;




96,490,532✔





1322



  int32_t right = taosArrayGetSize(pList) - 1;




96,490,532✔





1323



  while (left <= right) {




299,070,140✔





1324



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




299,070,140✔





1325



    SColMatchItem* pItem = taosArrayGet(pList, mid);




299,070,140✔





1326



    if (pItem->colId == colId) {




299,070,140✔





1327



      // return the first matched item in sorted order










1328



      while (mid > 0) {




96,490,532✔





1329



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




72,390,914✔





1330



        if (pPrev->colId != colId) {




72,390,914✔





1331



          break;




72,390,914✔





1332



        }










1333



        mid--;




×







1334



      }










1335



      return taosArrayGet(pList, mid);




96,490,532✔





1336



    }










1337












1338



    if (pItem->colId < colId) {




202,579,608✔





1339



      left = mid + 1;




95,151,788✔





1340



    } else {










1341



      right = mid - 1;




107,427,820✔





1342



    }










1343



  }










1344












1345



  return NULL;




×







1346



}










1347












1348



static bool isNewScanParam(STableScanOperatorParam* pParam) {




41,168,291✔





1349



  return pParam->isNewParam;




41,168,291✔





1350



}










1351












1352



static int32_t createVTableScanInfoFromBatchParam(SOperatorInfo* pOperator) {




18,501,007✔





1353



  int32_t                  code = 0;




18,501,007✔





1354



  int32_t                  lino = 0;




18,501,007✔





1355



  STableScanInfo*          pInfo = pOperator->info;




18,501,007✔





1356



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




18,504,136✔





1357



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




18,503,479✔





1358



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




18,504,367✔





1359



  SMetaReader              orgTable = {0};




18,505,192✔





1360



  SMetaReader              superTable = {0};




18,518,356✔





1361



  SSchemaWrapper*          schema = NULL;




18,508,884✔





1362



  SArray*                  pColArray = NULL;




18,508,884✔





1363



  SArray*                  pBlockColArray = NULL;




18,508,884✔





1364



  int32_t                  num = 0;




18,508,884✔





1365



  STableKeyInfo*           pList = NULL;




18,509,567✔





1366



  SOrgTbInfo*              pOrgTbInfo;










1367



  bool                     isNewTable;










1368












1369



  cleanupQueryTableDataCond(&pInfo->base.cond);




18,510,313✔





1370












1371



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




18,507,033✔





1372



  if (pGetParam &&




18,512,489✔





1373



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




4,371,401✔





1374



    STableScanOperatorParam* pParam =




4,378,247✔





1375



      (STableScanOperatorParam*)pGetParam->value;










1376



    pInfo->pBatchColMap = pParam->pBatchTbInfo;




4,375,699✔





1377



    pParam->pBatchTbInfo = NULL;




4,382,235✔





1378



    pInfo->cachedTimeWindow = pParam->window;




4,362,486✔





1379



    pInfo->currentBatchIdx = 0;




4,373,087✔





1380



    pInfo->lastBatchIdx = -1;




4,375,390✔





1381



    pInfo->cachedTagList = pParam->pTagList;




4,375,212✔





1382



    pParam->pTagList = NULL;




4,368,621✔





1383



    pInfo->cachedGroupId = pParam->groupid;




4,381,578✔





1384












1385



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




4,370,577✔





1386



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










1387



    taosHashClear(pInfo->pIgnoreTables);




4,370,577✔





1388












1389



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




4,378,594✔





1390



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




4,176,846✔





1391



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




52,698,778✔





1392



        SqlFunctionCtx ctx = pSup->pCtx[i];




48,538,484✔





1393



        ctx.skipDynDataCheck = false;




48,523,193✔





1394



      }










1395



    }










1396



  }










1397












1398



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




18,507,313✔





1399



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




18,517,069✔





1400












1401



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




18,517,069✔





1402



    isNewTable = false;




11,283,046✔





1403



  } else {










1404



    isNewTable = true;




7,234,152✔





1405



    pInfo->lastBatchIdx = pInfo->currentBatchIdx;




7,234,152✔





1406



  }










1407












1408



  if (isNewTable) {




18,514,058✔





1409



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




7,231,012✔





1410



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




7,237,496✔





1411



    pAPI->metaReaderFn.readerReleaseLock(&orgTable);




7,217,355✔





1412



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




7,228,514✔





1413



    QUERY_CHECK_CODE(code, lino, _return);




7,203,231✔





1414



    switch (orgTable.me.type) {




7,203,231✔





1415



      case TSDB_CHILD_TABLE:




283,665✔





1416



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




283,665✔





1417



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




283,665✔





1418



        pAPI->metaReaderFn.readerReleaseLock(&superTable);




283,665✔





1419



        QUERY_CHECK_CODE(code, lino, _return);




283,665✔





1420



        schema = &superTable.me.stbEntry.schemaRow;




283,665✔





1421



        break;




283,665✔





1422



      case TSDB_NORMAL_TABLE:




6,936,202✔





1423



        schema = &orgTable.me.ntbEntry.schemaRow;




6,936,202✔





1424



        break;




6,936,202✔





1425



      default:




130✔





1426



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




130✔





1427



        return TSDB_CODE_INVALID_PARA;




×







1428



        break;










1429



    }










1430












1431



    pListInfo->oneTableForEachGroup = true;




7,219,867✔





1432



    taosHashClear(pListInfo->map);




7,219,494✔





1433



    taosArrayClear(pListInfo->pTableList);




7,239,195✔





1434












1435



    uint64_t      pUid = orgTable.me.uid;




7,237,046✔





1436



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




7,237,046✔





1437



    int32_t       tableIdx = 0;




7,237,419✔





1438



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




7,237,046✔





1439



    QUERY_CHECK_CODE(code, lino, _return);




7,239,195✔





1440



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




14,476,898✔





1441



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




7,237,703✔





1442












1443



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




7,237,703✔





1444



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




7,232,762✔





1445



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




7,232,762✔





1446



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




7,232,336✔





1447












1448



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










1449



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




7,232,336✔





1450



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




7,234,408✔





1451












1452



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




27,698,471✔





1453



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




20,463,228✔





1454



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




162,999,218✔





1455



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




162,858,533✔





1456



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




20,468,850✔





1457



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




20,461,745✔





1458



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




20,461,745✔





1459



                 pPair.vtbColId, GET_TASKID(pTaskInfo));










1460



          break;




20,452,056✔





1461



        }










1462



      }










1463



    }










1464












1465



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




34,940,716✔





1466



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




27,697,148✔





1467



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




166,504,362✔





1468



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




166,307,603✔





1469



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




166,349,392✔





1470



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




27,702,912✔





1471



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




27,710,336✔





1472



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




27,710,336✔





1473



                 colIdSlotIdPair.vtbSlotId, GET_TASKID(pTaskInfo));










1474



          break;




27,695,424✔





1475



        }










1476



      }










1477



    }










1478












1479



    taosArraySort(pColArray, compareColIdPair);




7,234,586✔





1480



    taosArraySort(pBlockColArray, compareColIdSlotIdPair);




7,234,293✔





1481



    if (pInfo->pBlockColMap) {




7,235,039✔





1482



      taosArrayDestroy(pInfo->pBlockColMap);




5,109,420✔





1483



      pInfo->pBlockColMap = NULL;




5,105,211✔





1484



    }










1485



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




7,228,502✔





1486



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




7,234,808✔





1487












1488












1489



    taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




7,213,873✔





1490



    taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




7,223,768✔





1491












1492



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




7,233,713✔





1493



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




6,514,905✔





1494



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




80,790,839✔





1495



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




74,305,340✔





1496



        bool           needScan = false;




74,302,288✔





1497



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




149,637,402✔





1498



          SFunctParam pParam = ctx->param[j];




75,321,885✔





1499



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




361,606,203✔





1500



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




304,233,503✔





1501



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




304,904,054✔





1502



              needScan |= true;




18,742,388✔





1503



              break;




18,742,388✔





1504



            }










1505



          }










1506



        }










1507



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




74,309,407✔





1508



        if (!needScan) {




74,331,948✔





1509



          ctx->skipDynDataCheck = true;




55,594,566✔





1510



        } else {










1511



          ctx->skipDynDataCheck = false;




18,737,382✔





1512



        }










1513



      }










1514



    }










1515












1516












1517



  } else {










1518



    pColArray = pInfo->lastColArray;




11,283,046✔





1519



    pBlockColArray = pInfo->lastBlockColArray;




11,283,046✔





1520



  }










1521












1522



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




18,517,766✔





1523



  QUERY_CHECK_CODE(code, lino, _return);




18,516,682✔





1524












1525



  if (pInfo->pResBlock) {




18,516,682✔





1526



    blockDataDestroy(pInfo->pResBlock);




14,133,417✔





1527



    pInfo->pResBlock = NULL;




14,131,541✔





1528



  }










1529












1530



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




18,512,774✔





1531



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










1532



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










1533



         isNewTable, pInfo->base.orgCond.order,










1534



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










1535



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










1536



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










1537












1538



  if (isNewTable) {




18,508,014✔





1539



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




7,225,341✔





1540



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




6,492,103✔





1541



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




6,496,670✔





1542



    } else {










1543



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




743,738✔





1544



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




716,806✔





1545



    }










1546



  } else {










1547



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




11,282,673✔





1548



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




1,501,366✔





1549



    else {










1550



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




9,780,188✔





1551



    }










1552



  }










1553












1554



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




18,501,411✔





1555



  pInfo->currentGroupId = 0;




18,507,852✔





1556



  pInfo->ignoreTag = true;




18,491,399✔





1557












1558



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




18,486,290✔





1559



  QUERY_CHECK_CODE(code, lino, _return);




18,506,802✔





1560












1561



  if (isNewTable) {




18,506,802✔





1562



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




7,223,756✔





1563



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




5,107,824✔





1564



    }










1565



    pInfo->base.dataReader = NULL;




7,206,215✔





1566












1567



    taosRLockLatch(&pTaskInfo->lock);




7,208,237✔





1568



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




7,225,340✔





1569



    taosRUnLockLatch(&pTaskInfo->lock);




7,196,708✔





1570



    QUERY_CHECK_CODE(code, lino, _return);




7,226,379✔





1571












1572



    pInfo->newReader = true;




7,226,379✔





1573



    if (pInfo->lastColArray) {




7,216,457✔





1574



      taosArrayDestroy(pInfo->lastColArray);




2,849,793✔





1575



      pInfo->lastColArray = NULL;




2,850,744✔





1576



    }










1577



    if (pInfo->lastBlockColArray) {




7,213,947✔





1578



      taosArrayDestroy(pInfo->lastBlockColArray);




2,850,166✔





1579



      pInfo->lastBlockColArray = NULL;




2,849,588✔





1580



    }










1581



    pInfo->lastColArray = pColArray;




7,222,800✔





1582



    pInfo->lastBlockColArray = pBlockColArray;




7,209,730✔





1583



  } else {










1584



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




11,283,046✔





1585



    QUERY_CHECK_CODE(code, lino, _return);




11,283,046✔





1586












1587



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




11,283,046✔





1588



    pInfo->newReader = false;




11,282,673✔





1589



    pInfo->scanTimes = 0;




11,282,673✔





1590



  }










1591












1592



  pOperator->status = OP_OPENED;




18,478,905✔





1593












1594



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




18,493,354✔





1595



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




×







1596



  }










1597












1598



  pInfo->currentGroupId = -1;




18,488,995✔





1599



_return:




18,433,113✔





1600



  if (code) {




18,446,747✔





1601



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




×







1602



  }










1603



  pAPI->metaReaderFn.clearReader(&superTable);




18,446,747✔





1604



  pAPI->metaReaderFn.clearReader(&orgTable);




18,483,588✔





1605



  return code;




18,486,706✔





1606



}










1607












1608



static int32_t createVTableScanInfoFromParam(SOperatorInfo* pOperator) {




24,099,618✔





1609



  int32_t                  code = 0;




24,099,618✔





1610



  int32_t                  lino = 0;




24,099,618✔





1611



  STableScanInfo*          pInfo = pOperator->info;




24,099,618✔





1612



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




24,099,618✔





1613



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




24,099,618✔





1614



  STableListInfo*          pListInfo = pInfo->base.pTableListInfo;




24,099,618✔





1615



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




24,099,618✔





1616



  SMetaReader              orgTable = {0};




24,099,618✔





1617



  SMetaReader              superTable = {0};




24,099,618✔





1618



  SSchemaWrapper*          schema = NULL;




24,099,618✔





1619



  SArray*                  pColArray = NULL;




24,099,618✔





1620



  SArray*                  pBlockColArray = NULL;




24,099,618✔





1621



  int32_t                  num = 0;




24,099,618✔





1622



  STableKeyInfo*           pList = NULL;




24,099,618✔





1623



  SOrgTbInfo*              pOrgTbInfo;










1624



  SArray*                  pMatchList = NULL;




24,099,618✔





1625












1626



  cleanupQueryTableDataCond(&pInfo->base.cond);




24,099,618✔





1627












1628



  pOrgTbInfo = pParam->pOrgTbInfo;




24,099,618✔





1629












1630



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




24,099,618✔





1631












1632



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




24,099,618✔





1633



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




24,099,618✔





1634



  pAPI->metaReaderFn.readerReleaseLock(&orgTable);




24,099,618✔





1635



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




24,099,618✔





1636



  QUERY_CHECK_CODE(code, lino, _return);




24,099,618✔





1637



  switch (orgTable.me.type) {




24,099,618✔





1638



    case TSDB_CHILD_TABLE:




6,558,796✔





1639



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




6,558,796✔





1640



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




6,558,796✔





1641



      pAPI->metaReaderFn.readerReleaseLock(&superTable);




6,558,796✔





1642



      QUERY_CHECK_CODE(code, lino, _return);




6,558,796✔





1643



      schema = &superTable.me.stbEntry.schemaRow;




6,558,796✔





1644



      break;




6,558,796✔





1645



    case TSDB_NORMAL_TABLE:




17,540,822✔





1646



      schema = &orgTable.me.ntbEntry.schemaRow;




17,540,822✔





1647



      break;




17,540,822✔





1648



    default:




×







1649



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




×







1650



      return TSDB_CODE_INVALID_PARA;




×







1651



      break;










1652



  }










1653












1654



  pListInfo->oneTableForEachGroup = true;




24,099,618✔





1655



  taosHashClear(pListInfo->map);




24,099,618✔





1656



  taosArrayClear(pListInfo->pTableList);




24,099,618✔





1657












1658



  uint64_t      pUid = orgTable.me.uid;




24,099,618✔





1659



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




24,099,618✔





1660



  int32_t       tableIdx = 0;




24,099,618✔





1661



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




24,099,618✔





1662



  QUERY_CHECK_CODE(code, lino, _return);




24,099,618✔





1663



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




48,199,236✔





1664



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




24,099,618✔





1665












1666



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




24,099,618✔





1667



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




24,099,618✔





1668



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




24,099,618✔





1669



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




24,099,618✔





1670



  if (pInfo->pBlockColMap) {




24,099,618✔





1671



    taosArrayDestroy(pInfo->pBlockColMap);




21,606,197✔





1672



    pInfo->pBlockColMap = NULL;




21,606,197✔





1673



  }










1674



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




24,099,618✔





1675



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




24,099,618✔





1676












1677



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










1678



  SColIdPair tsPair = {.vtbColId = PRIMARYKEY_TIMESTAMP_COL_ID,




24,099,618✔





1679



                       .orgColId = PRIMARYKEY_TIMESTAMP_COL_ID,










1680



                       .type.type = TSDB_DATA_TYPE_TIMESTAMP,










1681



                       .type.bytes = 8};










1682



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




24,099,618✔





1683












1684



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




96,490,532✔





1685



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




72,390,914✔





1686



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




610,542,294✔





1687



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




610,542,294✔





1688



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




72,390,914✔





1689



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




72,390,914✔





1690



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




72,390,914✔





1691



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




72,390,914✔





1692



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




72,390,914✔





1693



        break;




72,390,914✔





1694



      }










1695



    }










1696



  }










1697












1698



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




24,099,618✔





1699



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




24,099,618✔





1700



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




×







1701



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




×







1702



      taosArraySort(pMatchList, compareColMatchItemByColId);




×







1703



    } else {










1704



      pMatchList = pInfo->base.matchInfo.pList;




24,099,618✔





1705



    }










1706



  }










1707












1708



  // skip ts pair










1709



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




120,589,522✔





1710



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




96,490,532✔





1711



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




96,490,532✔





1712



    if (pItem) {




96,490,532✔





1713



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




96,490,532✔





1714



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




628✔





1715



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










1716



        code = TSDB_CODE_VTABLE_COLUMN_TYPE_MISMATCH;




628✔





1717



        goto _return;




628✔





1718



      }










1719



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




96,489,904✔





1720



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




96,489,904✔





1721



      if (i > 0) {




96,489,904✔





1722



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




144,780,572✔





1723



      }










1724



    }










1725



  }










1726












1727



  taosArraySort(pColArray, compareColIdPair);




24,098,990✔





1728



  taosArraySort(pBlockColArray, compareColIdSlotIdPair);




24,098,990✔





1729



  taosArraySort(pInfo->pBlockColMap, compareColIdSlotIdPair);




24,098,990✔





1730












1731



  taosArrayRemoveDuplicate(pColArray, compareColIdPair, NULL);




24,098,990✔





1732



  taosArrayRemoveDuplicate(pBlockColArray, compareColIdSlotIdPair, NULL);




24,098,990✔





1733












1734



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




24,098,990✔





1735



  QUERY_CHECK_CODE(code, lino, _return);




24,098,990✔





1736












1737



  if (pInfo->pResBlock) {




24,098,990✔





1738



    blockDataDestroy(pInfo->pResBlock);




17,071,611✔





1739



    pInfo->pResBlock = NULL;




17,071,611✔





1740



  }










1741












1742



  if (isNewScanParam(pParam)) {




24,098,990✔





1743



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




7,035,481✔





1744



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




7,035,481✔





1745



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




7,035,481✔





1746



    } else {










1747



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




×







1748



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




×







1749



    }










1750



  } else {










1751



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




17,063,509✔





1752



  }










1753



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




24,098,990✔





1754



  pInfo->currentGroupId = 0;




24,098,990✔





1755



  pInfo->ignoreTag = true;




24,098,990✔





1756












1757



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




24,098,990✔





1758



  QUERY_CHECK_CODE(code, lino, _return);




24,098,990✔





1759












1760



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




24,098,990✔





1761



  if (reader) {




24,098,990✔





1762



    if (isNewScanParam(pParam)) {




17,069,301✔





1763



      pAPI->tsdReader.tsdReaderClose(*reader);




5,792✔





1764



      pInfo->base.dataReader = NULL;




5,792✔





1765












1766



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




5,792✔





1767



      QUERY_CHECK_CODE(code, lino, _return);




5,792✔





1768












1769



      taosRLockLatch(&pTaskInfo->lock);




5,792✔





1770



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




5,792✔





1771



      taosRUnLockLatch(&pTaskInfo->lock);




5,792✔





1772



      QUERY_CHECK_CODE(code, lino, _return);




5,792✔





1773












1774



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




5,792✔





1775



      QUERY_CHECK_CODE(code, lino, _return);




5,792✔





1776



      pInfo->newReader = true;




5,792✔





1777



    } else {










1778



      pInfo->base.dataReader = *reader;




17,063,509✔





1779



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




17,063,509✔





1780



      QUERY_CHECK_CODE(code, lino, _return);




17,063,509✔





1781












1782



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




17,063,509✔





1783



      pInfo->newReader = false;




17,063,509✔





1784



      pInfo->scanTimes = 0;




17,063,509✔





1785



    }










1786



  } else {










1787



    pInfo->base.dataReader = NULL;




7,029,689✔





1788












1789



    taosRLockLatch(&pTaskInfo->lock);




7,029,689✔





1790



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




7,029,689✔





1791



    taosRUnLockLatch(&pTaskInfo->lock);




7,029,689✔





1792



    QUERY_CHECK_CODE(code, lino, _return);




7,029,689✔





1793












1794



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




7,029,689✔





1795



    QUERY_CHECK_CODE(code, lino, _return);




7,029,689✔





1796



    pInfo->newReader = true;




7,029,689✔





1797



  }










1798



  pOperator->status = OP_OPENED;




24,098,990✔





1799












1800



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




24,098,990✔





1801



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




×







1802



  }










1803












1804



  pInfo->currentGroupId = -1;




24,098,990✔





1805



_return:




24,099,618✔





1806



  if (code) {




24,099,618✔





1807



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




628✔





1808



  }










1809



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




24,099,618✔





1810



    taosArrayDestroy(pMatchList);




×







1811



  }










1812



  taosArrayDestroy(pColArray);




24,099,618✔





1813



  taosArrayDestroy(pBlockColArray);




24,099,618✔





1814



  pAPI->metaReaderFn.clearReader(&superTable);




24,099,618✔





1815



  pAPI->metaReaderFn.clearReader(&orgTable);




24,099,618✔





1816



  return code;




24,099,618✔





1817



}










1818












1819



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




159,356,987✔





1820



  int32_t         code = TSDB_CODE_SUCCESS;




159,356,987✔





1821



  int32_t         lino = 0;




159,356,987✔





1822



  STableScanInfo* pInfo = pOperator->info;




159,356,987✔





1823



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




159,364,220✔





1824



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




159,358,500✔





1825



  int32_t         numOfTables = 0;




159,370,901✔





1826












1827



  QRY_PARAM_CHECK(pResult);




159,309,438✔





1828












1829



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




159,299,775✔





1830



  QUERY_CHECK_CODE(code, lino, _end);




159,326,803✔





1831












1832



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




159,326,803✔





1833



    setOperatorCompleted(pOperator);




144,738,185✔





1834



    if (pOperator->dynamicTask) {




144,735,652✔





1835



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




974,092✔





1836



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




974,475✔





1837



    }










1838



    return code;




144,749,306✔





1839



  }










1840












1841



  // reset value for the next group data output










1842



  pOperator->status = OP_OPENED;




14,543,136✔





1843



  resetLimitInfoForNextGroup(&pInfo->base.limitInfo);




14,601,157✔





1844












1845



  int32_t        num = 0;




14,593,223✔





1846



  STableKeyInfo* pList = NULL;




14,593,596✔





1847



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




14,579,208✔





1848



  QUERY_CHECK_CODE(code, lino, _end);




14,612,602✔





1849












1850



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




14,612,602✔





1851



  QUERY_CHECK_CODE(code, lino, _end);




14,606,165✔





1852












1853



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




14,606,165✔





1854



  QUERY_CHECK_CODE(code, lino, _end);




14,590,480✔





1855



  pInfo->scanTimes = 0;




14,590,480✔





1856












1857



  code = doGroupedTableScan(pOperator, pResult);




14,587,659✔





1858



  QUERY_CHECK_CODE(code, lino, _end);




14,631,151✔





1859












1860



  if (*pResult != NULL) {




14,631,151✔





1861



    if (pOperator->dynamicTask) {




11,805,267✔





1862



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




11,552,045✔





1863



    }










1864



    return code;




11,805,267✔





1865



  }










1866












1867



_end:




2,826,257✔





1868



  if (code != TSDB_CODE_SUCCESS) {




2,826,194✔





1869



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




×







1870



    pTaskInfo->code = code;




×







1871



  }










1872



  return code;




2,826,194✔





1873



}










1874












1875



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




714,468,361✔





1876



  int32_t         code = TSDB_CODE_SUCCESS;




714,468,361✔





1877



  int32_t         lino = 0;




714,468,361✔





1878



  STableScanInfo* pInfo = pOperator->info;




714,468,361✔





1879



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




714,477,664✔





1880



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




714,432,471✔





1881



  int32_t         num = 0;




714,438,808✔





1882



  STableKeyInfo*  pList = NULL;




714,424,675✔





1883



  SSDataBlock*    pResult = NULL;




714,462,398✔





1884



  const char*     idStr = GET_TASKID(pTaskInfo);




714,478,652✔





1885












1886



  QRY_PARAM_CHECK(pResBlock);




714,437,042✔





1887












1888



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




714,418,109✔





1889



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




148,189,580✔





1890



      setOperatorCompleted(pOperator);




×







1891



      return code;




×







1892



    }










1893












1894



    taosRLockLatch(&pTaskInfo->lock);




148,167,045✔





1895



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




148,195,794✔





1896



    taosRUnLockLatch(&pTaskInfo->lock);




148,136,602✔





1897



    QUERY_CHECK_CODE(code, lino, _end);




148,194,223✔





1898












1899



    if (pInfo->filesetDelimited) {




148,191,968✔





1900



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




267,280✔





1901



    }










1902












1903



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




148,190,969✔





1904



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




×







1905



    }










1906



  }










1907












1908



  code = doGroupedTableScan(pOperator, &pResult);




714,412,421✔





1909



  QUERY_CHECK_CODE(code, lino, _end);




714,162,487✔





1910












1911



  if (pResult != NULL) {




714,162,487✔





1912



    if (pOperator->dynamicTask) {




569,301,405✔





1913



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




2,045,295✔





1914



    }










1915












1916



    *pResBlock = pResult;




569,302,730✔





1917



    return code;




569,180,244✔





1918



  }










1919












1920



  while (true) {










1921



    code = startNextGroupScan(pOperator, &pResult);




144,939,994✔





1922



    QUERY_CHECK_CODE(code, lino, _end);




145,092,828✔





1923












1924



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




145,092,828✔





1925



      *pResBlock = pResult;




144,995,752✔





1926



      return code;




145,004,235✔





1927



    }










1928



  }










1929












1930



_end:




2,255✔





1931



  if (code != TSDB_CODE_SUCCESS) {




2,255✔





1932



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




2,255✔





1933



    pTaskInfo->code = code;




2,255✔





1934



  }










1935












1936



  return code;




2,255✔





1937



}










1938












1939



static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {




24,098,990✔





1940



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




24,098,990✔





1941



}










1942












1943



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




975,599✔





1944



  int32_t                  code = TSDB_CODE_SUCCESS;




975,599✔





1945



  int32_t                  lino = 0;




975,599✔





1946



  STableScanInfo*          pInfo = pOperator->info;




975,599✔





1947



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




975,599✔





1948



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




975,599✔





1949



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




975,599✔





1950












1951



  code = createTableListInfoFromParam(pOperator);




975,599✔





1952



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




975,599✔





1953



  pOperator->pOperatorGetParam = NULL;




975,599✔





1954



  QUERY_CHECK_CODE(code, lino, _end);




975,599✔





1955












1956



  if (pOperator->status == OP_EXEC_DONE) {




975,599✔





1957



    pInfo->currentGroupId = -1;




23,166✔





1958



    pOperator->status = OP_OPENED;




23,166✔





1959



    SSDataBlock* result = NULL;




23,166✔





1960












1961



    while (true) {










1962



      code = startNextGroupScan(pOperator, &result);




23,166✔





1963



      QUERY_CHECK_CODE(code, lino, _end);




23,166✔





1964












1965



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




23,166✔





1966



        (*ppRes) = result;




23,166✔





1967



        return code;




23,166✔





1968



      }










1969



    }










1970



  }










1971



_end:




952,433✔





1972



  if (code) {




952,433✔





1973



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




×







1974



  }










1975



  return code;




952,433✔





1976



}










1977












1978



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




17,072,749✔





1979



  int32_t      code = TSDB_CODE_SUCCESS;




17,072,749✔





1980



  int32_t      lino = 0;




17,072,749✔





1981



  bool         found = false;




17,072,749✔





1982












1983



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




17,072,749✔





1984



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




17,072,749✔





1985












1986



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




85,104,168✔





1987



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




68,031,419✔





1988



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




68,031,419✔





1989



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




195,007,090✔





1990



      SColIdSlotIdPair* pColPair = taosArrayGet(pColMap, j);




177,937,336✔





1991



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




177,937,336✔





1992



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




177,937,336✔





1993



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




50,961,665✔





1994



        found = true;




50,961,665✔





1995



        break;




50,961,665✔





1996



      }










1997



    }










1998



    if (!found) {




68,031,419✔





1999



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




17,069,754✔





2000



        pSrcCol->info.slotId = -1;




17,069,754✔





2001



      } else {










2002



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




×







2003



               (int32_t)taosArrayGetSize(pColMap));










2004



        code = TSDB_CODE_QRY_VSTB_SLOTID_NOT_FOUND;




×







2005



      }










2006



    }










2007



  }










2008












2009



  return code;




17,072,749✔





2010



_return:




×







2011



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




×







2012



  return code;




×







2013



}










2014












2015



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




24,099,618✔





2016



  int32_t                  code = TSDB_CODE_SUCCESS;




24,099,618✔





2017



  int32_t                  lino = 0;




24,099,618✔





2018



  STableScanInfo*          pInfo = pOperator->info;




24,099,618✔





2019



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




24,099,618✔





2020



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




24,099,618✔





2021



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




24,099,618✔





2022












2023



  QRY_PARAM_CHECK(ppRes);




24,099,618✔





2024



  qTrace("%s call", __FUNCTION__);




24,099,618✔





2025












2026



  code = createVTableScanInfoFromParam(pOperator);




24,099,618✔





2027



  freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




24,099,618✔





2028



  pOperator->pOperatorGetParam = NULL;




24,099,618✔





2029












2030



  QUERY_CHECK_CODE(code, lino, _end);




24,099,618✔





2031












2032



  SSDataBlock* result = NULL;




24,098,990✔





2033



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




24,098,990✔





2034



    (*ppRes) = result;




18,244✔





2035



    return code;




18,244✔





2036



  }










2037












2038



  if (pInfo->newReader) {




24,080,746✔





2039



    code = startNextGroupScan(pOperator, &result);




7,035,481✔





2040



    QUERY_CHECK_CODE(code, lino, _end);




7,035,481✔





2041



  } else {










2042



    code = doGroupedTableScan(pOperator, &result);




17,045,265✔





2043



    QUERY_CHECK_CODE(code, lino, _end);




17,045,265✔





2044



  }










2045












2046



  if (result) {




24,080,746✔





2047



    SSDataBlock* res = NULL;




17,072,749✔





2048



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




17,072,749✔





2049



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




17,072,749✔





2050



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




17,072,749✔





2051












2052



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




17,072,749✔





2053



    QUERY_CHECK_CODE(code, lino, _end);




17,072,749✔





2054



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










2055



    //QUERY_CHECK_CODE(code, lino, _end);










2056












2057



    //pInfo->pResBlock = res;










2058



    //blockDataDestroy(result);










2059



    (*ppRes) = result;




17,072,749✔





2060



  } else {










2061



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




7,007,997✔





2062



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




7,007,997✔





2063












2064



    blockDataDestroy(pInfo->pResBlock);




7,007,997✔





2065



    pInfo->pResBlock = NULL;




7,007,997✔





2066












2067



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




7,007,997✔





2068



    if (reader) {




7,007,997✔





2069



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




7,007,997✔





2070



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




7,007,997✔





2071



        pInfo->base.dataReader = NULL;




7,007,997✔





2072



      }










2073



      if (pAPI->tsdReader.tsdReaderClose) {




7,007,997✔





2074



        pAPI->tsdReader.tsdReaderClose(*reader);




7,007,997✔





2075



      }










2076



    }










2077












2078



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




7,007,997✔





2079



    QUERY_CHECK_CODE(code, lino, _end);




7,007,997✔





2080



  }










2081



_end:




24,081,374✔





2082



  if (code) {




24,081,374✔





2083



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




628✔





2084



  }










2085



  return code;




24,081,374✔





2086



}










2087












2088



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




3,238,558✔





2089



  int32_t                  code = TSDB_CODE_SUCCESS;




3,238,558✔





2090



  int32_t                  lino = 0;




3,238,558✔





2091



  STableScanInfo*          pInfo = pOperator->info;




3,238,558✔





2092



  int32_t                  index = 0;




3,238,558✔





2093



  char*                    tagVal = NULL;




3,238,558✔





2094












2095



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




22,675,532✔





2096



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




19,436,974✔





2097



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




19,436,974✔





2098












2099



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




19,436,228✔





2100



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




19,436,228✔





2101












2102



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




2,147,483,647✔





2103



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




2,147,483,647✔





2104



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




2,147,483,647✔





2105



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




2,147,483,647✔





2106












2107



        varDataSetLen(tagVal, pTagVal->nData);




2,147,483,647✔





2108



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




2,147,483,647✔





2109



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




2,147,483,647✔





2110



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2111



        taosMemoryFreeClear(tagVal);




2,147,483,647✔





2112



      } else {










2113



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




2,147,483,647✔





2114



        QUERY_CHECK_CODE(code, lino, _end);




2,147,483,647✔





2115



      }










2116



    }










2117



    index++;




19,436,974✔





2118



  }










2119



  return code;




3,238,558✔





2120



_end:




×







2121



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




×







2122



  taosMemoryFreeClear(tagVal);




×







2123



  return code;




×







2124



}










2125












2126



static void clearVstbBatchDynamicTableScanInfo(STableScanInfo* pInfo) {




4,386,586✔





2127



  if (pInfo->pBatchColMap) {




4,386,586✔





2128



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




11,623,916✔





2129



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




7,237,703✔





2130



      taosArrayDestroy(pOrgTbInfo->colMap);




7,237,703✔





2131



    }










2132



    taosArrayDestroy(pInfo->pBatchColMap);




4,385,467✔





2133



    pInfo->pBatchColMap = NULL;




4,383,975✔





2134



  }










2135



  if (pInfo->cachedTagList) {




4,385,467✔





2136



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




13,743,666✔





2137



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




11,713,298✔





2138



      if (IS_VAR_DATA_TYPE(pTagVal->type)) {




11,714,790✔





2139



        taosMemoryFreeClear(pTagVal->pData);




5,139,358✔





2140



      }










2141



    }










2142



    taosArrayDestroy(pInfo->cachedTagList);




2,033,352✔





2143



    pInfo->cachedTagList = NULL;




2,030,741✔





2144



  }










2145



  if (pInfo->lastColArray) {




4,385,467✔





2146



    taosArrayDestroy(pInfo->lastColArray);




4,386,959✔





2147



    pInfo->lastColArray = NULL;




4,387,332✔





2148



  }










2149



  if (pInfo->lastBlockColArray) {




4,386,586✔





2150



    taosArrayDestroy(pInfo->lastBlockColArray);




4,386,959✔





2151



    pInfo->lastBlockColArray = NULL;




4,384,348✔





2152



  }










2153












2154



  blockDataDestroy(pInfo->pResBlock);




4,385,467✔





2155



  pInfo->pResBlock = NULL;




4,386,586✔





2156



}




4,386,586✔





2157












2158



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




15,659,103✔





2159



  int32_t                  code = TSDB_CODE_SUCCESS;




15,659,103✔





2160



  int32_t                  lino = 0;




15,659,103✔





2161



  STableScanInfo*          pInfo = pOperator->info;




15,659,103✔





2162



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




15,658,294✔





2163



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




15,662,386✔





2164



  SSDataBlock*             result = NULL;




15,663,274✔





2165












2166



  QRY_PARAM_CHECK(ppRes);




15,658,860✔





2167



  qTrace("%s call", __FUNCTION__);




15,659,464✔





2168












2169



  while (!result) {




29,793,006✔





2170



    code = createVTableScanInfoFromBatchParam(pOperator);




18,510,475✔





2171



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




18,490,201✔





2172



    pOperator->pOperatorGetParam = NULL;




18,454,706✔





2173



    QUERY_CHECK_CODE(code, lino, _end);




18,463,247✔





2174












2175



    if (pInfo->newReader) {




18,463,247✔





2176



      code = startNextGroupScan(pOperator, &result);




7,196,737✔





2177



      QUERY_CHECK_CODE(code, lino, _end);




7,235,233✔





2178



    } else {










2179



      code = doGroupedTableScan(pOperator, &result);




11,271,607✔





2180



      QUERY_CHECK_CODE(code, lino, _end);




11,281,785✔





2181



    }










2182



    if (!result) {




18,517,018✔





2183



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




7,236,699✔





2184



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










2185



      pInfo->currentBatchIdx++;




7,236,699✔





2186



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




7,229,403✔





2187



        // all batch scan finished










2188



        break;




4,388,078✔





2189



      }










2190



    }










2191



  }










2192












2193



  if (result) {




15,670,609✔





2194



    SSDataBlock* res = NULL;




11,282,531✔





2195



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




11,282,531✔





2196



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




11,280,166✔





2197



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




11,282,531✔





2198












2199



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




11,280,755✔





2200



    QUERY_CHECK_CODE(code, lino, _end);




11,283,046✔





2201












2202



    if (pInfo->cachedTagList) {




11,283,046✔





2203



      code = setTagValFromTagList(pOperator, res);




3,238,558✔





2204



      QUERY_CHECK_CODE(code, lino, _end);




3,238,558✔





2205



    }










2206












2207



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




11,283,046✔





2208



    pInfo->pResBlock = res;




11,283,046✔





2209



    blockDataDestroy(result);




11,283,046✔





2210



    (*ppRes) = res;




11,282,673✔





2211












2212



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




11,282,673✔





2213



  } else {










2214



    clearVstbBatchDynamicTableScanInfo(pInfo);




4,388,078✔





2215



    setOperatorCompleted(pOperator);




4,386,586✔





2216



  }










2217












2218



_end:




15,670,378✔





2219



  return code;




15,669,632✔





2220



}










2221












2222



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




40,740,214✔





2223



  int32_t                  code = TSDB_CODE_SUCCESS;




40,740,214✔





2224



  int32_t                  lino = 0;




40,740,214✔





2225



  STableScanInfo*          pInfo = pOperator->info;




40,740,214✔





2226



  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;




40,742,789✔





2227



  SStorageAPI*             pAPI = &pTaskInfo->storageAPI;




40,736,999✔





2228












2229



  QRY_PARAM_CHECK(ppRes);




40,735,586✔





2230



  qTrace("%s call", __FUNCTION__);




40,739,973✔





2231












2232



  pOperator->dynamicTask = true;




40,740,356✔





2233












2234



  switch (type) {




40,731,105✔





2235



    case DYN_TYPE_VSTB_WIN_SCAN:




975,599✔





2236



    case DYN_TYPE_STB_JOIN: {










2237



      code = doStbJoinDynamicTableScanNext(pOperator, ppRes);




975,599✔





2238



      QUERY_CHECK_CODE(code, lino, _end);




975,599✔





2239



      break;




975,599✔





2240



    }










2241



    case DYN_TYPE_VSTB_SINGLE_SCAN: {




24,099,618✔





2242



      code = doVstbSingleDynamicTableScanNext(pOperator, ppRes);




24,099,618✔





2243



      QUERY_CHECK_CODE(code, lino, _end);




24,099,618✔





2244



      break;




24,098,990✔





2245



    }










2246



    case DYN_TYPE_VSTB_BATCH_SCAN:




15,655,888✔





2247



      code = doVstbBatchDynamicTableScanNext(pOperator, ppRes);




15,655,888✔





2248



      QUERY_CHECK_CODE(code, lino, _end);




15,670,378✔





2249



      break;




15,670,378✔





2250



    default:




×







2251



      code = TSDB_CODE_INVALID_PARA;




×







2252



      QUERY_CHECK_CODE(code, lino, _end);




×







2253



      break;




×







2254



  }










2255












2256



_end:




40,745,595✔





2257



  return code;




40,745,595✔





2258



}










2259












2260



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




760,164,598✔





2261



  int32_t         code = TSDB_CODE_SUCCESS;




760,164,598✔





2262



  int32_t         lino = 0;




760,164,598✔





2263



  STableScanInfo* pInfo = pOperator->info;




760,164,598✔





2264



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




760,272,814✔





2265



  SStorageAPI*    pAPI = &pTaskInfo->storageAPI;




760,267,667✔





2266



  QRY_PARAM_CHECK(ppRes);




760,227,238✔





2267



  qTrace("%s call", __FUNCTION__);




760,231,053✔





2268












2269



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




760,232,585✔





2270



  QUERY_CHECK_CODE(code, lino, _end);




760,317,192✔





2271












2272



  SOperatorParam* pGetParam = pOperator->pOperatorGetParam;




760,317,192✔





2273



  if (pGetParam || pInfo->pBatchColMap) {




760,314,267✔





2274



    ETableScanDynType type = pGetParam ?




40,736,842✔





2275



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




40,735,492✔





2276



      DYN_TYPE_VSTB_BATCH_SCAN;










2277












2278



    code = doDynamicTableScanNext(pOperator, type, ppRes);




40,736,842✔





2279



    QUERY_CHECK_CODE(code, lino, _end);




40,744,849✔





2280












2281



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




40,744,221✔





2282



      return code;




39,792,907✔





2283



    }










2284



  }










2285












2286



  // scan table one by one sequentially










2287



  if (pInfo->scanMode == TABLE_SCAN__TABLE_ORDER) {




720,532,727✔





2288



    int32_t       numOfTables = 0;




6,062,856✔





2289



    STableKeyInfo tInfo = {0};




6,062,856✔





2290



    pInfo->countState = TABLE_COUNT_STATE_END;




6,062,856✔





2291












2292



    while (1) {




5,655,031✔





2293



      SSDataBlock* result = NULL;




11,717,887✔





2294



      code = doGroupedTableScan(pOperator, &result);




11,717,257✔





2295



      QUERY_CHECK_CODE(code, lino, _end);




11,718,505✔





2296












2297



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




11,718,505✔





2298



        (*ppRes) = result;




6,016,859✔





2299



        return code;




6,019,691✔





2300



      }










2301












2302



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










2303



      pInfo->currentTable++;




5,701,329✔





2304












2305



      taosRLockLatch(&pTaskInfo->lock);




5,701,329✔





2306



      numOfTables = 0;




5,701,643✔





2307



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




5,701,643✔





2308



      if (code != TSDB_CODE_SUCCESS) {




5,701,958✔





2309



        taosRUnLockLatch(&pTaskInfo->lock);




×







2310



        TSDB_CHECK_CODE(code, lino, _end);




×







2311



      }










2312












2313



      if (pInfo->currentTable >= numOfTables) {




5,701,958✔





2314



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




43,165✔





2315



        taosRUnLockLatch(&pTaskInfo->lock);




43,165✔





2316



        (*ppRes) = NULL;




43,165✔





2317



        return code;




43,165✔





2318



      }










2319












2320



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




5,655,331✔





2321



      if (!tmp) {




5,655,333✔





2322



        taosRUnLockLatch(&pTaskInfo->lock);




×







2323



        (*ppRes) = NULL;




×







2324



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




×







2325



      }










2326












2327



      tInfo = *tmp;




5,655,333✔





2328



      taosRUnLockLatch(&pTaskInfo->lock);




5,655,021✔





2329












2330



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




5,658,479✔





2331



      QUERY_CHECK_CODE(code, lino, _end);




5,657,534✔





2332



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




5,657,534✔





2333



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










2334












2335



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




5,662,255✔





2336



      QUERY_CHECK_CODE(code, lino, _end);




5,654,703✔





2337



      pInfo->scanTimes = 0;




5,654,703✔





2338



    }










2339



  } else {  // scan table group by group sequentially










2340



    code = groupSeqTableScan(pOperator, ppRes);




714,377,136✔





2341



    QUERY_CHECK_CODE(code, lino, _end);




714,184,962✔





2342



  }










2343












2344



_end:




714,182,707✔





2345



  if (code != TSDB_CODE_SUCCESS) {




714,174,416✔





2346



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




2,883✔





2347



    pTaskInfo->code = code;




2,883✔





2348



    T_LONG_JMP(pTaskInfo->env, code);




2,883✔





2349



  }










2350












2351



  return code;




714,171,533✔





2352



}










2353












2354



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




1,847,268✔





2355



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




1,847,268✔





2356



  if (!pRecorder) {




1,847,268✔





2357



    return terrno;




×







2358



  }










2359



  STableScanInfo* pTableScanInfo = pOptr->info;




1,847,268✔





2360



  *pRecorder = pTableScanInfo->base.readRecorder;




1,847,268✔





2361



  *pOptrExplain = pRecorder;




1,847,268✔





2362



  *len = sizeof(SFileBlockLoadRecorder);




1,847,268✔





2363



  return 0;




1,847,268✔





2364



}










2365












2366



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




182,605,464✔





2367



  cleanupQueryTableDataCond(&pBase->cond);




182,605,464✔





2368



  cleanupQueryTableDataCond(&pBase->orgCond);




182,591,507✔





2369












2370



  if (pAPI->tsdReaderClose) {




182,608,073✔





2371



    pAPI->tsdReaderClose(pBase->dataReader);




182,614,637✔





2372



  }










2373



  pBase->dataReader = NULL;




182,540,237✔





2374












2375



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




182,560,106✔





2376



    taosArrayDestroy(pBase->matchInfo.pList);




182,579,528✔





2377



  }










2378












2379



  tableListDestroy(pBase->pTableListInfo);




182,529,375✔





2380



  taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);




182,589,452✔





2381



  cleanupExprSupp(&pBase->pseudoSup);




182,568,619✔





2382



}




182,600,363✔





2383












2384



static void cleanReaderForVTable(STableScanInfo* pInfo){




5,494,461✔





2385



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




5,494,461✔





2386



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




5,494,834✔





2387



    while (pIter != NULL) {




5,516,179✔





2388



      void **reader = pIter;




21,692✔





2389



      if (*reader) {




21,692✔





2390



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




21,692✔





2391



          pInfo->base.dataReader = NULL;




19,382✔





2392



        }










2393



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




21,692✔





2394



      }










2395



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




21,692✔





2396



    }










2397



  }










2398



}




5,494,487✔





2399












2400



static void destroyTableScanOperatorInfo(void* param) {




158,724,177✔





2401



  STableScanInfo* pTableScanInfo = (STableScanInfo*)param;




158,724,177✔





2402



  blockDataDestroy(pTableScanInfo->pResBlock);




158,724,177✔





2403



  blockDataDestroy(pTableScanInfo->pOrgBlock);




158,710,172✔





2404



  taosHashCleanup(pTableScanInfo->pIgnoreTables);




158,714,500✔





2405



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




158,702,841✔





2406



    cleanReaderForVTable(pTableScanInfo);




5,495,002✔





2407



    taosHashCleanup(pTableScanInfo->readerCache);




5,494,487✔





2408



  }










2409



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




158,704,788✔





2410



  taosArrayDestroy(pTableScanInfo->pBlockColMap);




158,704,079✔





2411



  taosMemoryFreeClear(param);




158,716,881✔





2412



}




158,703,591✔





2413












2414



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




158,648,121✔





2415



  if (pBlock && dataRequireFlag == FUNC_DATA_REQUIRED_NOT_LOAD) {




158,648,121✔





2416



    int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);




7,387,373✔





2417



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




18,737,079✔





2418



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




11,358,697✔





2419



      if (pCol) {




11,358,666✔





2420



        pCol->info.noData = true;




11,358,666✔





2421



      }










2422



    }










2423



  }










2424



}




158,639,130✔





2425












2426



static int32_t resetTableScanOperatorState(SOperatorInfo* pOper) {




379,301✔





2427



  int32_t         code = TSDB_CODE_SUCCESS;




379,301✔





2428



  STableScanInfo*   pInfo = pOper->info;




379,301✔





2429



  pOper->status = OP_NOT_OPENED;




379,301✔





2430












2431



  pInfo->scanTimes = 0;




379,301✔





2432



  pInfo->currentGroupId = -1;




379,301✔





2433



  pInfo->tableEndIndex = -1;




379,072✔





2434



  pInfo->tableStartIndex = 0;




379,072✔





2435



  pInfo->currentTable = 0;




379,301✔





2436



  pInfo->scanMode = 0;




379,301✔





2437



  pInfo->countState = 0;




379,301✔





2438



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




379,072✔





2439












2440



  if (!pInfo->virtualStableScan) {




379,301✔





2441



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










2442



  //   cleanReaderForVTable(pInfo);










2443



  //   taosHashClear(pInfo->readerCache);










2444



  //   pInfo->readerCache = false;










2445



  // } else {










2446



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




162,028✔





2447



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




162,028✔





2448



    }










2449



    pInfo->base.dataReader = NULL;




162,486✔





2450



  }










2451



  tableListDestroy(pInfo->base.pTableListInfo);




379,301✔





2452



  pInfo->base.pTableListInfo = tableListCreate();




379,301✔





2453



  if (!pInfo->base.pTableListInfo) {




379,301✔





2454



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




×







2455



    return terrno;




×







2456



  }










2457



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




379,301✔





2458












2459



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




379,301✔





2460



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




379,301✔





2461



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




321,670✔





2462



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










2463



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




321,670✔





2464



    if (code) {




161,241✔





2465



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




×







2466



      return code;




×







2467



    }










2468



  }










2469












2470



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




379,301✔





2471



  cleanupQueryTableDataCond(&pInfo->base.cond);




379,301✔





2472



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




379,301✔





2473



  if (code) {




379,301✔





2474



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




×







2475



    return code;




×







2476



  }










2477



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




379,301✔





2478



    cleanupQueryTableDataCond(&pInfo->base.orgCond);




217,044✔





2479



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




217,044✔





2480



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




217,044✔





2481



  } 










2482












2483



  pOper->resultInfo.totalRows = 0;




379,301✔





2484



  blockDataEmpty(pInfo->pResBlock);




379,301✔





2485



  blockDataEmpty(pInfo->pOrgBlock);




379,301✔





2486



  taosHashClear(pInfo->pIgnoreTables);




379,301✔





2487



  taosArrayDestroy(pInfo->pBlockColMap);




379,301✔





2488



  pInfo->pBlockColMap = NULL;




379,301✔





2489



  return code;




379,301✔





2490



}










2491












2492



int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




158,715,557✔





2493



                                    STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










2494



                                    SOperatorInfo** pOptrInfo) {










2495



  QRY_PARAM_CHECK(pOptrInfo);




158,715,557✔





2496












2497



  int32_t         code = TSDB_CODE_SUCCESS;




158,724,843✔





2498



  int32_t         lino = 0;




158,724,843✔





2499



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




158,724,843✔





2500



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




158,696,355✔





2501



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




158,688,917✔





2502



    code = terrno;




501✔





2503



    goto _error;




×







2504



  }










2505












2506



  pOperator->pPhyNode = pTableScanNode;




158,688,416✔





2507



  SScanPhysiNode*     pScanNode = &pTableScanNode->scan;




158,695,050✔





2508



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




158,700,290✔





2509












2510



  int32_t numOfCols = 0;




158,697,650✔





2511



  code =










2512



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




158,707,237✔





2513



  QUERY_CHECK_CODE(code, lino, _error);




158,658,050✔





2514












2515



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




158,658,050✔





2516



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




158,627,727✔





2517



  QUERY_CHECK_CODE(code, lino, _error);




158,601,982✔





2518












2519



  if (pScanNode->pScanPseudoCols != NULL) {




158,601,982✔





2520



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




50,398,743✔





2521



    pSup->pExprInfo = NULL;




50,396,739✔





2522



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




50,386,947✔





2523



    QUERY_CHECK_CODE(code, lino, _error);




50,369,795✔





2524












2525



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




50,369,795✔





2526



                                      &pTaskInfo->storageAPI.functionStore);










2527



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




50,366,054✔





2528



  }










2529












2530



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




158,634,106✔





2531



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




158,521,688✔





2532












2533



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




158,644,174✔





2534



  pInfo->base.readHandle = *readHandle;




158,480,156✔





2535



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




158,519,896✔





2536












2537



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




158,669,004✔





2538



  pInfo->sample.seed = taosGetTimestampSec();




158,537,951✔





2539












2540



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




158,608,298✔





2541



  initResultSizeInfo(&pOperator->resultInfo, 4096);




158,575,914✔





2542



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




158,613,523✔





2543



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




158,651,934✔





2544



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




158,648,648✔





2545












2546



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




158,554,092✔





2547



  QUERY_CHECK_CODE(code, lino, _error);




158,664,012✔





2548












2549



  pInfo->virtualStableScan = pScanNode->virtualStableScan;




158,664,012✔





2550



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




158,630,798✔





2551



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




5,492,078✔





2552



    pInfo->pResBlock = NULL;




5,493,098✔





2553



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




5,488,075✔





2554



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




5,491,109✔





2555



  }










2556












2557



  if (pInfo->virtualStableScan) {




158,622,852✔





2558



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




5,492,480✔





2559



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




5,495,580✔





2560



  }










2561












2562



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




158,595,799✔





2563



                            pTaskInfo->pStreamRuntimeInfo);




158,646,529✔





2564



  QUERY_CHECK_CODE(code, lino, _error);




158,536,570✔





2565












2566



  pInfo->currentGroupId = -1;




158,514,058✔





2567












2568



  pInfo->tableEndIndex = -1;




158,534,125✔





2569



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




158,525,688✔





2570



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




158,643,630✔





2571












2572



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




158,529,477✔





2573



                  pTaskInfo);










2574



  pOperator->exprSupp.numOfExprs = numOfCols;




158,441,845✔





2575












2576



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




158,476,373✔





2577



  pInfo->ignoreTag = false;




158,540,744✔





2578












2579



  pInfo->lastBatchIdx = -1;




158,643,990✔





2580



  pInfo->currentBatchIdx = 0;




158,550,214✔





2581



  pInfo->base.pTableListInfo = pTableListInfo;




158,466,365✔





2582



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




158,477,811✔





2583



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




×







2584



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




×







2585



      code = terrno;




×







2586



      QUERY_CHECK_CODE(code, lino, _error);




×







2587



    }










2588












2589



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




×







2590



  }










2591












2592



  pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




158,477,811✔





2593












2594



  pOperator->fpSet = createOperatorFpSet(prepareTableScan, doTableScanNext,




158,603,572✔





2595



                                         NULL, destroyTableScanOperatorInfo,










2596



                                         optrDefaultBufFn,










2597



                                         getTableScannerExecInfo,










2598



                                         optrDefaultGetNextExtFn, NULL);










2599












2600



  setOperatorResetStateFn(pOperator, resetTableScanOperatorState); 




158,518,182✔





2601



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










2602



  pOperator->cost.openCost = 0;




158,538,855✔





2603



  *pOptrInfo = pOperator;




158,570,267✔





2604



  return TSDB_CODE_SUCCESS;




158,405,796✔





2605












2606



_error:




22,512✔





2607



  if (pInfo != NULL) {




22,512✔





2608



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




22,512✔





2609



    destroyTableScanOperatorInfo(pInfo);




22,512✔





2610



  }










2611












2612



  if (pOperator != NULL) {




22,512✔





2613



    pOperator->info = NULL;




22,512✔





2614



    destroyOperator(pOperator);




22,512✔





2615



  }










2616



  pTaskInfo->code = code;




22,512✔





2617



  return code;




22,512✔





2618



}










2619












2620



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




×







2621



  QRY_PARAM_CHECK(pOptrInfo);




×







2622












2623



  int32_t         code = 0;




×







2624



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




×







2625



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




×







2626



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




×







2627



    code = terrno;




×







2628



    goto _end;




×







2629



  }










2630












2631



  pInfo->base.dataReader = pReadHandle;




×







2632



  //  pInfo->prevGroupId       = -1;










2633












2634



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




×







2635



                  pInfo, pTaskInfo);










2636



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




×







2637



                                         optrDefaultGetNextExtFn, NULL);










2638



  *pOptrInfo = pOperator;




×







2639



  return code;




×







2640












2641



_end:




×







2642



  if (pInfo != NULL) {




×







2643



    taosMemoryFree(pInfo);




×







2644



  }










2645












2646



  if (pOperator != NULL) {




×







2647



    taosMemoryFree(pOperator);




×







2648



  }










2649












2650



  pTaskInfo->code = code;




×







2651



  return code;




×







2652



}










2653












2654



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




14,118✔





2655



  int32_t code = TSDB_CODE_SUCCESS;




14,118✔





2656



  int32_t lino = 0;




14,118✔





2657



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




14,118✔





2658



    return code;




1,675✔





2659



  }










2660



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




12,443✔





2661



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




12,443✔





2662



  bool hasUnqualified = false;




12,443✔





2663












2664



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




12,443✔





2665



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




12,443✔





2666












2667



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




12,443✔





2668



         VALUE_GET_TRIVIAL_DATUM(&offset->primaryKey));










2669



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




12,443✔





2670



                        TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);










2671












2672



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




12,443✔





2673



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




12,443✔





2674



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




44,814,097✔





2675



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




44,801,654✔





2676



    void*    data = colDataGetData(pColPk, i);




44,801,654✔





2677



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




44,804,078✔





2678



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




2,424✔





2679



        QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY, lino, _end);




×







2680



      }










2681



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




2,424✔





2682



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




2,424✔





2683



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




2,424✔





2684



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




2,424✔





2685



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




2,424✔





2686



      taosMemoryFree(tmq);




2,424✔





2687



    } else {










2688



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




44,799,230✔





2689



    }










2690












2691



    if (!p[i]) {




44,801,654✔





2692



      hasUnqualified = true;




15,921,758✔





2693



    }










2694



  }










2695












2696



  if (hasUnqualified) {




12,443✔





2697



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




4,190✔





2698



    QUERY_CHECK_CODE(code, lino, _end);




4,190✔





2699



  }










2700












2701



_end:




12,443✔





2702



  taosMemoryFree(p);




12,443✔





2703



  if (code != TSDB_CODE_SUCCESS) {




12,443✔





2704



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




×







2705



  }










2706



  return code;




12,443✔





2707



}










2708












2709



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




1,414,465,799✔





2710



  int32_t p1 = *(int32_t*)param1;




1,414,465,799✔





2711



  int32_t p2 = *(int32_t*)param2;




1,414,287,195✔





2712












2713



  if (p1 == p2) {




1,414,512,724✔





2714



    return 0;




×







2715



  } else {










2716



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




1,414,512,724✔





2717



  }










2718



}










2719












2720



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




98,633,618✔





2721



  int32_t         code = TSDB_CODE_SUCCESS;




98,633,618✔





2722



  int32_t         lino = 0;




98,633,618✔





2723



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




98,633,618✔





2724



  SOperatorInfo*  pOperator = pInfo->pStreamScanOp;




98,631,847✔





2725



  SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;




98,637,095✔





2726



  const char*     id = GET_TASKID(pTaskInfo);




98,637,791✔





2727



  SArray* pColList = NULL;




98,638,142✔





2728












2729



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




98,638,142✔





2730



  QUERY_CHECK_CODE(code, lino, _end);




98,636,750✔





2731












2732



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




98,636,750✔





2733



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




98,636,054✔





2734



  pBlockInfo->type = STREAM_NORMAL;




98,637,443✔





2735



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




98,637,791✔





2736












2737



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




98,638,139✔





2738



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




98,637,464✔





2739












2740



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




98,636,759✔





2741



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




98,635,734✔





2742












2743



  // todo extract method










2744



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




532,042,987✔





2745



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




433,386,748✔





2746



    if (!pColMatchInfo->needOutput) {




433,376,433✔





2747



      continue;




650✔





2748



    }










2749












2750



    bool colExists = false;




433,380,253✔





2751



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




1,370,044,014✔





2752



      SColumnInfoData* pResCol = NULL;




1,369,741,637✔





2753



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




1,369,664,479✔





2754



      QUERY_CHECK_CODE(code, lino, _end);




1,369,646,674✔





2755












2756



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




1,369,646,674✔





2757



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




433,350,407✔





2758



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




433,423,550✔





2759



        QUERY_CHECK_CODE(code, lino, _end);




433,271,516✔





2760












2761



        colExists = true;




433,271,516✔





2762



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




433,271,516✔





2763



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




433,415,922✔





2764



        break;




433,415,922✔





2765



      }










2766



    }










2767












2768



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










2769



    if (!colExists) {




433,406,603✔





2770



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




×







2771



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




×







2772



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




×







2773



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




×







2774



    }










2775



  }










2776












2777



  // currently only the tbname pseudo column










2778



  if (pInfo->numOfPseudoExpr > 0) {




98,634,659✔





2779



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




123,291,754✔





2780



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




61,646,129✔





2781



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










2782



    if (code) {




61,646,489✔





2783



      QUERY_CHECK_CODE(code, lino, _end);




×







2784



    }










2785












2786



    // reset the error code.










2787



    terrno = 0;




61,646,489✔





2788












2789



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




259,777,252✔





2790



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




198,119,987✔





2791



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




198,132,851✔





2792



    }










2793



  }










2794












2795



  taosArraySort(pColList, colIdComparFn);




98,622,077✔





2796












2797



  int32_t i = 0, j = 0;




98,636,806✔





2798



  while (i < taosArrayGetSize(pColList)) {




730,032,568✔





2799



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




631,390,098✔





2800



    if (slot1 > j) {




631,395,762✔





2801



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




×







2802



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




×







2803



      j += 1;




×







2804



    } else {










2805



      i += 1;




631,395,762✔





2806



      j += 1;




631,395,762✔





2807



    }










2808



  }










2809












2810



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




98,633,575✔





2811



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




650✔





2812



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




650✔





2813



    j += 1;




650✔





2814



  }










2815












2816



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




98,634,351✔





2817



  QUERY_CHECK_CODE(code, lino, _end);




98,632,509✔





2818












2819



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




98,632,509✔





2820



  QUERY_CHECK_CODE(code, lino, _end);




98,630,400✔





2821












2822



_end:




98,630,400✔





2823



  taosArrayDestroy(pColList);




98,261,384✔





2824



  if (code != TSDB_CODE_SUCCESS) {




98,634,884✔





2825



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




×







2826



  }










2827



  return code;




98,625,892✔





2828



}










2829












2830



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




6,753,964✔





2831



  int32_t code = TSDB_CODE_SUCCESS;




6,753,964✔





2832



  int32_t lino = 0;




6,753,964✔





2833



  SValue  val = {0};




6,753,964✔





2834



  if (hasPrimaryKey) {




6,755,440✔





2835



    code = doBlockDataPrimaryKeyFilter(pBlock, offset);




14,118✔





2836



    if (code != TSDB_CODE_SUCCESS) {




14,118✔





2837



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




×







2838



      return code;




×







2839



    }










2840



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




14,118✔





2841












2842



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




14,118✔





2843



      return code;




3,887✔





2844



    }










2845



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




10,231✔





2846



    val.type = pColPk->info.type;




10,231✔





2847



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




10,231✔





2848



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




646✔





2849



        return TSDB_CODE_BLOB_NOT_SUPPORT_PRIMARY_KEY;




×







2850



      }










2851



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




646✔





2852



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




646✔





2853



      val.nData = varDataLen(tmp);




646✔





2854



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




646✔





2855



    } else {










2856



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




9,585✔





2857



    }










2858



  }










2859



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




6,751,553✔





2860












2861



_end:




6,751,238✔





2862



  if (code != TSDB_CODE_SUCCESS) {




6,751,238✔





2863



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




×







2864



  }










2865



  return code;




6,750,638✔





2866



}










2867












2868



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




125,763,635✔





2869



  int32_t        code = TSDB_CODE_SUCCESS;




125,763,635✔





2870



  int32_t        lino = 0;




125,763,635✔





2871



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




125,763,635✔





2872



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




125,767,745✔





2873












2874



  SStreamScanInfo* pInfo = pOperator->info;




125,764,637✔





2875



  const char*      id = GET_TASKID(pTaskInfo);




125,767,296✔





2876












2877



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




125,766,856✔





2878












2879



  if (isTaskKilled(pTaskInfo)) {




125,758,940✔





2880



    (*ppRes) = NULL;




×







2881



    return pTaskInfo->code;




×







2882



  }










2883












2884



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




125,769,103✔





2885



    while (1) {




3,887✔





2886



      SSDataBlock* pResult = NULL;




6,062,856✔





2887



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




6,062,856✔





2888



      QUERY_CHECK_CODE(code, lino, _end);




6,062,856✔





2889












2890



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




6,062,856✔





2891



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




6,019,691✔





2892



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




6,019,691✔





2893



        QUERY_CHECK_CODE(code, lino, _end);




6,019,061✔





2894



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




6,019,061✔





2895



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




6,020,006✔





2896



          (*ppRes) = pResult;




6,015,804✔





2897



          return code;




6,015,804✔





2898



        }










2899



      } else {










2900



        break;










2901



      }










2902



    }










2903












2904



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




43,165✔





2905



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




43,165✔





2906












2907



    pTSInfo->base.dataReader = NULL;




43,165✔





2908



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




43,165✔





2909



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




43,165✔





2910



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




43,165✔





2911



      (*ppRes) = NULL;




10,879✔





2912



      return code;




10,879✔





2913



    }










2914












2915



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




32,286✔





2916



  }










2917












2918



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




119,742,072✔





2919



    while (1) {




778,210✔





2920



      bool hasResult =










2921



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




120,519,934✔





2922












2923



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




120,483,480✔





2924



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




120,508,616✔





2925












2926



      // curVersion move to next










2927



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




120,515,127✔





2928












2929



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










2930



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




120,510,366✔





2931












2932



      if (hasResult) {




120,503,338✔





2933



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




98,621,207✔





2934



               pTaskInfo->streamInfo.currentOffset.version);










2935



        blockDataCleanup(pInfo->pRes);




98,618,877✔





2936



        code = setBlockIntoRes(pInfo, pRes);




98,634,662✔





2937



        QUERY_CHECK_CODE(code, lino, _end);




98,625,261✔





2938



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




98,625,261✔





2939



               pTaskInfo->streamInfo.currentOffset.version);










2940



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




98,628,644✔





2941



          (*ppRes) = pInfo->pRes;




97,860,289✔





2942



          return code;




97,859,245✔





2943



        }










2944



      } else {










2945



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




21,882,131✔





2946



        (*ppRes) = NULL;




21,882,131✔





2947



        return code;




21,882,131✔





2948



      }










2949



    }










2950



  } else {










2951



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




×







2952



    (*ppRes) = NULL;




×







2953



    return code;




×







2954



  }










2955












2956



_end:




×







2957



  if (code != TSDB_CODE_SUCCESS) {




×







2958



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




×







2959



    pTaskInfo->code = code;




×







2960



    T_LONG_JMP(pTaskInfo->env, code);




×







2961



  }










2962



  (*ppRes) = NULL;




×







2963



  return code;




×







2964



}










2965












2966



static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) {




×







2967



  SSDataBlock* pRes = NULL;




×







2968



  int32_t      code = doQueueScanNext(pOperator, &pRes);




×







2969



  return pRes;




×







2970



}










2971












2972



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




331,138✔





2973



  int32_t code = TSDB_CODE_SUCCESS;




331,138✔





2974



  int32_t lino = 0;




331,138✔





2975



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




331,138✔





2976



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




332,168✔





2977












2978



  // Transfer the Array of STableKeyInfo into uid list.










2979



  int32_t size = 0;




332,168✔





2980



  code = tableListGetSize(pTableListInfo, &size);




332,168✔





2981



  QUERY_CHECK_CODE(code, lino, _end);




332,168✔





2982



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




9,731,594✔





2983



    STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i);




9,399,741✔





2984



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




9,398,163✔





2985



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




9,398,163✔





2986



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




9,399,426✔





2987



  }










2988












2989



  (*ppArrayRes) = tableIdList;




331,853✔





2990












2991



_end:




332,168✔





2992



  if (code != TSDB_CODE_SUCCESS) {




331,819✔





2993



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




×







2994



  }










2995



  return code;




331,819✔





2996



}










2997












2998



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




1,523,717✔





2999



  int32_t        code = TSDB_CODE_SUCCESS;




1,523,717✔





3000



  int32_t        lino = 0;




1,523,717✔





3001



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,523,717✔





3002



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,523,717✔





3003












3004



  SStreamRawScanInfo* pInfo = pOperator->info;




1,523,717✔





3005



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




1,523,717✔





3006



  pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL;




1,523,717✔





3007












3008



  qDebug("tmqsnap doRawScan called");




1,523,717✔





3009



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




1,523,717✔





3010



    bool hasNext = false;




1,518,747✔





3011



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




1,518,747✔





3012



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




1,517,875✔





3013



      if (code != TSDB_CODE_SUCCESS) {




1,515,430✔





3014



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




×







3015



        QUERY_CHECK_CODE(code, lino, _end);




×







3016



      }










3017



    }










3018












3019



    if (pInfo->dataReader && hasNext) {




1,516,302✔





3020



      if (isTaskKilled(pTaskInfo)) {




736,664✔





3021



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




×







3022



        return code;




×







3023



      }










3024












3025



      SSDataBlock* pBlock = NULL;




737,564✔





3026



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




737,264✔





3027



      QUERY_CHECK_CODE(code, lino, _end);




735,764✔





3028












3029



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




735,764✔





3030



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




737,264✔





3031



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




736,364✔





3032



        QUERY_CHECK_CODE(code, lino, _end);




735,464✔





3033



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




735,464✔





3034



        (*ppRes) = pBlock;




737,264✔





3035



        return code;




737,564✔





3036



      }










3037



    }










3038












3039



    SMetaTableInfo mtInfo = {0};




779,938✔





3040



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




780,883✔





3041



    QUERY_CHECK_CODE(code, lino, _end);




779,983✔





3042



    if (code != 0) {




779,983✔





3043



      destroyMetaTableInfo(&mtInfo);










3044



      QUERY_CHECK_CODE(code, lino, _end);




×







3045



    }










3046



    STqOffsetVal offset = {0};




779,983✔





3047



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




779,383✔





3048



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




11,143✔





3049



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




11,143✔





3050



    } else {










3051



      SValue val = {0};




770,040✔





3052



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




770,040✔





3053



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




768,840✔





3054



    }










3055



    destroyMetaTableInfo(&mtInfo);










3056



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




781,183✔





3057



    QUERY_CHECK_CODE(code, lino, _end);




781,183✔





3058



    (*ppRes) = NULL;




781,183✔





3059



    return code;




781,183✔





3060



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




4,970✔





3061



    SSnapContext* sContext = pInfo->sContext;




4,970✔





3062



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




41,784✔





3063



      void*   data = NULL;




41,784✔





3064



      int32_t dataLen = 0;




41,784✔





3065



      int16_t type = 0;




41,784✔





3066



      int64_t uid = 0;




41,784✔





3067



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




41,784✔





3068



        qError("tmqsnap getTableInfoFromSnapshot error");




×







3069



        taosMemoryFreeClear(data);




×







3070



        break;




×







3071



      }










3072












3073



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




41,784✔





3074



        STqOffsetVal offset = {0};




4,970✔





3075



        SValue       val = {0};




4,970✔





3076



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




×







3077



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




4,970✔





3078



        QUERY_CHECK_CODE(code, lino, _end);




4,970✔





3079



        break;




4,970✔





3080



      } else {










3081



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




36,814✔





3082



        SMqMetaRsp tmpMetaRsp = {0};




36,814✔





3083



        tmpMetaRsp.resMsgType = type;




36,814✔





3084



        tmpMetaRsp.metaRspLen = dataLen;




36,814✔





3085



        tmpMetaRsp.metaRsp = data;




36,814✔





3086



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




36,814✔





3087



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




4,414✔





3088



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




4,414✔





3089












3090



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




4,414✔





3091



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




4,414✔





3092



        }










3093



        int32_t  tempRes = TSDB_CODE_SUCCESS;




36,814✔





3094



        uint32_t len = 0;




36,814✔





3095



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




36,814✔





3096



        if (TSDB_CODE_SUCCESS != tempRes) {




36,814✔





3097



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3098



          taosMemoryFreeClear(data);




×







3099



          break;




×







3100



        }










3101












3102



        int32_t tLen = sizeof(SMqRspHead) + len;




36,814✔





3103



        void*   tBuf = taosMemoryCalloc(1, tLen);




36,814✔





3104



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




36,814✔





3105












3106



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




36,814✔





3107



        SEncoder encoder = {0};




36,814✔





3108



        tEncoderInit(&encoder, metaBuff, len);




36,814✔





3109



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




36,814✔





3110



        if (tempLen < 0) {




36,814✔





3111



          qError("tmqsnap tEncodeMqMetaRsp error");




×







3112



          tEncoderClear(&encoder);




×







3113



          taosMemoryFreeClear(tBuf);




×







3114



          taosMemoryFreeClear(data);




×







3115



          break;




×







3116



        }










3117



        taosMemoryFreeClear(data);




36,814✔





3118



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




36,814✔





3119



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




36,814✔





3120












3121



        tmp = taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaLen, &tLen);




36,814✔





3122



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




36,814✔





3123



      }










3124



    }










3125












3126



    (*ppRes) = NULL;




4,970✔





3127



    return code;




4,970✔





3128



  }










3129












3130



_end:




×







3131



  if (code != TSDB_CODE_SUCCESS) {




×







3132



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3133



    pTaskInfo->code = code;




×







3134



    T_LONG_JMP(pTaskInfo->env, code);




×







3135



  }










3136












3137



  (*ppRes) = NULL;




×







3138



  return code;




×







3139



}










3140












3141



static void destroyTmqRawScanOperatorInfo(void* param) {




123,198✔





3142



  SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;




123,198✔





3143



  pRawScan->pAPI->tsdReader.tsdReaderClose(pRawScan->dataReader);




123,198✔





3144



  pRawScan->pAPI->snapshotFn.destroySnapshot(pRawScan->sContext);




123,198✔





3145



  tableListDestroy(pRawScan->pTableListInfo);




123,198✔





3146



  taosMemoryFree(pRawScan);




123,198✔





3147



}




123,198✔





3148












3149



// for subscribing db or stb (not including column),










3150



// if this scan is used, meta data can be return










3151



// and schemas are decided when scanning










3152



int32_t createTmqRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {




122,857✔





3153



  // create operator










3154



  // create tb reader










3155



  // create meta reader










3156



  // create tq reader










3157












3158



  QRY_PARAM_CHECK(pOptrInfo);




122,857✔





3159



  int32_t code = TSDB_CODE_SUCCESS;




123,198✔





3160



  int32_t lino = 0;




123,198✔





3161












3162



  SStreamRawScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamRawScanInfo));




123,198✔





3163



  SOperatorInfo*      pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




123,198✔





3164



  if (pInfo == NULL || pOperator == NULL) {




123,198✔





3165



    code = terrno;




×







3166



    lino = __LINE__;




×







3167



    goto _end;




×







3168



  }










3169












3170



  pInfo->pTableListInfo = tableListCreate();




123,198✔





3171



  QUERY_CHECK_NULL(pInfo->pTableListInfo, code, lino, _end, terrno);




123,198✔





3172



  pInfo->vnode = pHandle->vnode;




123,198✔





3173



  pInfo->pAPI = &pTaskInfo->storageAPI;




123,198✔





3174












3175



  pInfo->sContext = pHandle->sContext;




123,198✔





3176



  pHandle->sContext = NULL;  // transfer the ownership




123,198✔





3177



  setOperatorInfo(pOperator, "RawScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false, OP_NOT_OPENED, pInfo,




123,198✔





3178



                  pTaskInfo);










3179












3180



  pOperator->fpSet = createOperatorFpSet(NULL, doRawScanNext, NULL, destroyTmqRawScanOperatorInfo, optrDefaultBufFn,




123,198✔





3181



                                         NULL, optrDefaultGetNextExtFn, NULL);










3182



  *pOptrInfo = pOperator;




123,198✔





3183



  return code;




123,198✔





3184












3185



_end:




×







3186



  if (code != TSDB_CODE_SUCCESS) {




×







3187



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3188



  }










3189



  taosMemoryFree(pInfo);




×







3190



  taosMemoryFree(pOperator);




×







3191



  pTaskInfo->code = code;




×







3192



  return code;




×







3193



}










3194












3195



void destroyTmqScanOperatorInfo(void* param) {




332,168✔





3196



  if (param == NULL) {




332,168✔





3197



    return;




×







3198



  }










3199












3200



  SStreamScanInfo* pStreamScan = (SStreamScanInfo*)param;




332,168✔





3201



  if (pStreamScan->pTableScanOp && pStreamScan->pTableScanOp->info) {




332,168✔





3202



    destroyOperator(pStreamScan->pTableScanOp);




332,168✔





3203



  }










3204












3205



  if (pStreamScan->tqReader != NULL && pStreamScan->readerFn.tqReaderClose != NULL) {




331,855✔





3206



    pStreamScan->readerFn.tqReaderClose(pStreamScan->tqReader);




331,867✔





3207



  }










3208



  if (pStreamScan->pVtableMergeHandles) {




332,469✔





3209



    taosHashCleanup(pStreamScan->pVtableMergeHandles);




×







3210



    pStreamScan->pVtableMergeHandles = NULL;




×







3211



  }










3212



  if (pStreamScan->pVtableMergeBuf) {




332,168✔





3213



    destroyDiskbasedBuf(pStreamScan->pVtableMergeBuf);




×







3214



    pStreamScan->pVtableMergeBuf = NULL;




×







3215



  }










3216



  if (pStreamScan->pVtableReadyHandles) {




332,168✔





3217



    taosArrayDestroy(pStreamScan->pVtableReadyHandles);




×







3218



    pStreamScan->pVtableReadyHandles = NULL;




×







3219



  }










3220



  if (pStreamScan->pTableListInfo) {




332,168✔





3221



    tableListDestroy(pStreamScan->pTableListInfo);




×







3222



    pStreamScan->pTableListInfo = NULL;




×







3223



  }










3224



  if (pStreamScan->matchInfo.pList) {




332,168✔





3225



    taosArrayDestroy(pStreamScan->matchInfo.pList);




331,854✔





3226



  }










3227



  if (pStreamScan->pPseudoExpr) {




332,482✔





3228



    destroyExprInfo(pStreamScan->pPseudoExpr, pStreamScan->numOfPseudoExpr);




192,372✔





3229



    taosMemoryFree(pStreamScan->pPseudoExpr);




192,372✔





3230



  }










3231












3232



  cleanupExprSupp(&pStreamScan->tbnameCalSup);




332,168✔





3233



  cleanupExprSupp(&pStreamScan->tagCalSup);




332,168✔





3234












3235



  blockDataDestroy(pStreamScan->pRes);




332,168✔





3236



  blockDataDestroy(pStreamScan->pUpdateRes);




332,168✔





3237



  blockDataDestroy(pStreamScan->pDeleteDataRes);




332,168✔





3238



  blockDataDestroy(pStreamScan->pUpdateDataRes);




332,168✔





3239



  blockDataDestroy(pStreamScan->pCreateTbRes);




332,168✔





3240



  taosArrayDestroy(pStreamScan->pBlockLists);




332,168✔





3241



  blockDataDestroy(pStreamScan->pCheckpointRes);




332,168✔





3242












3243



  taosMemoryFree(pStreamScan);




332,168✔





3244



}










3245












3246



int32_t addPrimaryKeyCol(SSDataBlock* pBlock, uint8_t type, int32_t bytes) {




×







3247



  int32_t code = TSDB_CODE_SUCCESS;




×







3248



  int32_t lino = 0;




×







3249



  pBlock->info.rowSize += bytes;




×







3250



  SColumnInfoData infoData = {0};




×







3251



  infoData.info.type = type;




×







3252



  infoData.info.bytes = bytes;




×







3253



  void* tmp = taosArrayPush(pBlock->pDataBlock, &infoData);




×







3254



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




×







3255












3256



_end:




×







3257



  if (code != TSDB_CODE_SUCCESS) {




×







3258



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3259



  }










3260



  return code;




×







3261



}










3262












3263



 int32_t createTmqScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode,




331,867✔





3264



                                                  SNode* pTagCond, STableListInfo* pTableListInfo,










3265



                                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










3266



  QRY_PARAM_CHECK(pOptrInfo);




331,867✔





3267












3268



  int32_t          code = TSDB_CODE_SUCCESS;




332,168✔





3269



  int32_t          lino = 0;




332,168✔





3270



  SArray*          pColIds = NULL;




332,168✔





3271



  SStreamScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamScanInfo));




332,168✔





3272



  SOperatorInfo*   pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




332,168✔





3273



  SStorageAPI*     pAPI = &pTaskInfo->storageAPI;




332,168✔





3274



  const char*      idstr = pTaskInfo->id.str;




332,168✔





3275












3276



  if (pInfo == NULL || pOperator == NULL) {




332,168✔





3277



    code = terrno;




×







3278



    goto _error;




×







3279



  }










3280












3281



  SScanPhysiNode*     pScanPhyNode = &pTableScanNode->scan;




332,168✔





3282



  SDataBlockDescNode* pDescNode = pScanPhyNode->node.pOutputDataBlockDesc;




332,168✔





3283












3284



  pInfo->pTagCond = pTagCond;




332,168✔





3285



  pInfo->pGroupTags = pTableScanNode->pGroupTags;




332,168✔





3286












3287



  int32_t numOfCols = 0;




332,168✔





3288



  code = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




332,168✔





3289



  if (code != TSDB_CODE_SUCCESS) {




332,168✔





3290



    goto _error;




×







3291



  }










3292












3293



  SDataType pkType = {0};




332,168✔





3294



  pInfo->primaryKeyIndex = -1;




332,168✔





3295



  pInfo->basic.primaryPkIndex = -1;




332,168✔





3296



  int32_t numOfOutput = taosArrayGetSize(pInfo->matchInfo.pList);




332,168✔





3297



  pColIds = taosArrayInit(numOfOutput, sizeof(int16_t));




332,168✔





3298



  QUERY_CHECK_NULL(pColIds, code, lino, _error, terrno);




332,168✔





3299












3300



  for (int32_t i = 0; i < numOfOutput; ++i) {




2,081,764✔





3301



    SColMatchItem* id = taosArrayGet(pInfo->matchInfo.pList, i);




1,749,596✔





3302



    QUERY_CHECK_NULL(id, code, lino, _error, terrno);




1,749,596✔





3303












3304



    int16_t colId = id->colId;




1,749,596✔





3305



    void*   tmp = taosArrayPush(pColIds, &colId);




1,749,933✔





3306



    QUERY_CHECK_NULL(tmp, code, lino, _error, terrno);




1,749,933✔





3307












3308



    if (id->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




1,749,933✔





3309



      pInfo->primaryTsIndex = id->dstSlotId;




332,168✔





3310



    }










3311



    if (id->isPk) {




1,749,933✔





3312



      pInfo->primaryKeyIndex = id->dstSlotId;




1,547✔





3313



      pInfo->basic.primaryPkIndex = id->dstSlotId;




1,547✔





3314



      pkType = id->dataType;




1,547✔





3315



    }










3316



  }










3317












3318



  pInfo->pPartTbnameSup = NULL;




332,168✔





3319



  if (pTableScanNode->pSubtable != NULL) {




332,168✔





3320



    SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo));




×







3321



    if (pSubTableExpr == NULL) {




×







3322



      code = terrno;




×







3323



      goto _error;




×







3324



    }










3325












3326



    pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;




×







3327



    code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);




×







3328



    QUERY_CHECK_CODE(code, lino, _error);




×







3329












3330



    if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) {




×







3331



      goto _error;




×







3332



    }










3333



  }










3334












3335



  if (pTableScanNode->pTags != NULL) {




332,168✔





3336



    int32_t    numOfTags;




×







3337



    SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags);




×







3338



    if (pTagExpr == NULL) {




×







3339



      goto _error;




×







3340



    }










3341



    code = initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore);




×







3342



    if (code != 0) {




×







3343



      goto _error;




×







3344



    }










3345



  }










3346












3347



  pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData));




332,168✔





3348



  TSDB_CHECK_NULL(pInfo->pBlockLists, code, lino, _error, terrno);




332,168✔





3349












3350



  if (pHandle->vnode) {




332,168✔





3351



    SOperatorInfo* pTableScanOp = NULL;




332,168✔





3352



    code = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo, &pTableScanOp);




332,168✔





3353



    if (pTableScanOp == NULL || code != 0) {




331,819✔





3354



      qError("createTableScanOperatorInfo error, code:%d", pTaskInfo->code);




×







3355



      goto _error;




×







3356



    }










3357












3358



    STableScanInfo* pTSInfo = (STableScanInfo*)pTableScanOp->info;




331,819✔





3359



    if (pHandle->version > 0) {




332,168✔





3360



      pTSInfo->base.cond.endVersion = pHandle->version;




332,168✔





3361



    }










3362












3363



    STableKeyInfo* pList = NULL;




331,470✔





3364



    int32_t        num = 0;




331,819✔





3365



    code = tableListGetGroupList(pTableListInfo, 0, &pList, &num);




332,168✔





3366



    QUERY_CHECK_CODE(code, lino, _error);




331,819✔





3367












3368



    if (pHandle->initTableReader) {




331,819✔





3369



      pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER;




331,819✔





3370



      pTSInfo->base.dataReader = NULL;




332,168✔





3371



    }










3372












3373



    if (pHandle->initTqReader) {




331,487✔





3374



      pInfo->tqReader = pAPI->tqReaderFn.tqReaderOpen(pHandle->vnode);




331,819✔





3375



      QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, terrno);




331,836✔





3376



    } else {










3377



      pInfo->tqReader = pHandle->tqReader;




×







3378



      QUERY_CHECK_NULL(pInfo->tqReader, code, lino, _error, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




×







3379



    }










3380












3381



    pInfo->pUpdateInfo = NULL;




332,168✔





3382



    pInfo->pTableScanOp = pTableScanOp;




332,168✔





3383



    if (pInfo->pTableScanOp->pTaskInfo->streamInfo.pState) {




331,836✔





3384



      pAPI->stateStore.streamStateSetNumber(pInfo->pTableScanOp->pTaskInfo->streamInfo.pState, -1,




×







3385



                                            pInfo->primaryTsIndex);










3386



    }










3387












3388



    pInfo->readHandle = *pHandle;




331,836✔





3389



    pTaskInfo->streamInfo.snapshotVer = pHandle->version;




331,836✔





3390



    pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup);




331,487✔





3391



    QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, terrno);




331,836✔





3392



    pInfo->hasPart = false;




331,487✔





3393












3394



    code = blockDataEnsureCapacity(pInfo->pCreateTbRes, 8);




331,819✔





3395



    QUERY_CHECK_CODE(code, lino, _error);




332,168✔





3396












3397



    // set the extract column id to streamHandle










3398



    code = pAPI->tqReaderFn.tqReaderSetColIdList(pInfo->tqReader, pColIds, idstr);




332,168✔





3399



    QUERY_CHECK_CODE(code, lino, _error);




331,836✔





3400












3401



    SArray* tableIdList = NULL;




331,836✔





3402



    code = extractTableIdList(((STableScanInfo*)(pInfo->pTableScanOp->info))->base.pTableListInfo, &tableIdList);




331,836✔





3403



    QUERY_CHECK_CODE(code, lino, _error);




331,819✔





3404



    code = pAPI->tqReaderFn.tqReaderSetQueryTableList(pInfo->tqReader, tableIdList, idstr);




331,819✔





3405



    QUERY_CHECK_CODE(code, lino, _error);




332,168✔





3406



    taosArrayDestroy(tableIdList);




332,168✔





3407



    memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond));




332,168✔





3408



  } else {










3409



    taosArrayDestroy(pColIds);




×







3410



    tableListDestroy(pTableListInfo);




×







3411



  }










3412












3413



  // clear the local variable to avoid repeatly free










3414



  pColIds = NULL;




332,168✔





3415












3416



  // create the pseduo columns info










3417



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




332,168✔





3418



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pInfo->pPseudoExpr, &pInfo->numOfPseudoExpr);




192,372✔





3419



    QUERY_CHECK_CODE(code, lino, _error);




192,372✔





3420



  }










3421












3422



  code = filterInitFromNode((SNode*)pScanPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0, NULL);




332,168✔





3423



  QUERY_CHECK_CODE(code, lino, _error);




332,168✔





3424












3425



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




332,168✔





3426



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




332,168✔





3427



  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateRes);




332,168✔





3428



  QUERY_CHECK_CODE(code, lino, _error);




332,168✔





3429












3430



  pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;




332,168✔





3431



  pInfo->windowSup = (SWindowSupporter){.pStreamAggSup = NULL, .gap = -1, .parentType = QUERY_NODE_PHYSICAL_PLAN};




332,168✔





3432



  pInfo->groupId = 0;




332,168✔





3433



  pInfo->igCheckGroupId = false;




332,168✔





3434



  pInfo->pStreamScanOp = pOperator;




332,168✔





3435



  pInfo->deleteDataIndex = 0;




332,168✔





3436



  code = createSpecialDataBlock(STREAM_DELETE_DATA, &pInfo->pDeleteDataRes);




331,831✔





3437



  QUERY_CHECK_CODE(code, lino, _error);




331,822✔





3438












3439



  pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX};




331,822✔





3440



  code = createSpecialDataBlock(STREAM_CLEAR, &pInfo->pUpdateDataRes);




332,168✔





3441



  QUERY_CHECK_CODE(code, lino, _error);




332,168✔





3442












3443



  pInfo->assignBlockUid = pTableScanNode->assignBlockUid;




332,168✔





3444



  pInfo->partitionSup.needCalc = false;




332,168✔





3445



  pInfo->igCheckUpdate = pTableScanNode->igCheckUpdate;




332,168✔





3446



  pInfo->igExpired = pTableScanNode->igExpired;




331,831✔





3447



  pInfo->twAggSup.maxTs = INT64_MIN;




332,168✔





3448



  pInfo->pState = pTaskInfo->streamInfo.pState;




331,831✔





3449



  pInfo->stateStore = pTaskInfo->storageAPI.stateStore;




331,831✔





3450



  pInfo->readerFn = pTaskInfo->storageAPI.tqReaderFn;




332,168✔





3451



  pInfo->pFillSup = NULL;




331,831✔





3452



  pInfo->useGetResultRange = false;




332,168✔





3453



  pInfo->pRangeScanRes = NULL;




332,168✔





3454












3455



  code = createSpecialDataBlock(STREAM_CHECKPOINT, &pInfo->pCheckpointRes);




331,831✔





3456



  QUERY_CHECK_CODE(code, lino, _error);




332,168✔





3457












3458



  setOperatorInfo(pOperator, STREAM_SCAN_OP_NAME, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, false, OP_NOT_OPENED, pInfo,




332,168✔





3459



                  pTaskInfo);










3460



  pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);




332,168✔





3461












3462



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doQueueScanNext, NULL, destroyTmqScanOperatorInfo, optrDefaultBufFn,




331,850✔





3463



                                         NULL, optrDefaultGetNextExtFn, NULL);










3464












3465



  *pOptrInfo = pOperator;




331,850✔





3466



  return code;




331,850✔





3467












3468



_error:




337✔





3469



  if (pColIds != NULL) {




×







3470



    taosArrayDestroy(pColIds);




×







3471



  }










3472












3473



  if (pInfo != NULL && pInfo->pTableScanOp != NULL) {




×







3474



    STableScanInfo* p = (STableScanInfo*)pInfo->pTableScanOp->info;




×







3475



    if (p != NULL) {




×







3476



      p->base.pTableListInfo = NULL;




×







3477



    }










3478



    destroyTmqScanOperatorInfo(pInfo);




×







3479



  }










3480












3481



  if (pOperator != NULL) {




×







3482



    pOperator->info = NULL;




×







3483



    destroyOperator(pOperator);




×







3484



  }










3485



  pTaskInfo->code = code;




×







3486



  return code;




×







3487



}










3488












3489



static int32_t doTagScanOneTable(SOperatorInfo* pOperator, SSDataBlock* pRes, SMetaReader* mr, SStorageAPI* pAPI) {




9,670,902✔





3490



  int32_t        code = TSDB_CODE_SUCCESS;




9,670,902✔





3491



  int32_t        lino = 0;




9,670,902✔





3492



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,670,902✔





3493



  STagScanInfo*  pInfo = pOperator->info;




9,675,398✔





3494



  SExprInfo*     pExprInfo = &pOperator->exprSupp.pExprInfo[0];




9,676,662✔





3495



  int32_t        count = pRes->info.rows;




9,674,140✔





3496












3497



  STableKeyInfo* item = tableListGetInfo(pInfo->pTableListInfo, pInfo->curPos);




9,675,632✔





3498



  if (!item) {




9,672,361✔





3499



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3500



           GET_TASKID(pTaskInfo));










3501



    tDecoderClear(&(*mr).coder);




×







3502



    goto _end;




×







3503



  }










3504












3505



  code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid);




9,672,361✔





3506



  tDecoderClear(&(*mr).coder);




9,676,545✔





3507



  if (code != TSDB_CODE_SUCCESS) {




9,677,177✔





3508



    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno),




×







3509



           GET_TASKID(pTaskInfo));










3510



    goto _end;




×







3511



  }










3512












3513



  char str[512];




9,677,081✔





3514



  for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




44,047,016✔





3515



    SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




34,369,839✔





3516












3517



    // refactor later










3518



    if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) {




34,368,692✔





3519



      STR_TO_VARSTR(str, (*mr).me.name);




3,957,480✔





3520



      code = colDataSetVal(pDst, (count), str, false);




3,955,821✔





3521



      QUERY_CHECK_CODE(code, lino, _end);




3,956,851✔





3522



    } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) {




30,413,734✔





3523



      code = colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false);




5,662,874✔





3524



      QUERY_CHECK_CODE(code, lino, _end);




5,662,501✔





3525



    } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) {




24,753,950✔





3526



      code = colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false);




15,434✔





3527



      QUERY_CHECK_CODE(code, lino, _end);




15,434✔





3528



    } else {  // it is a tag value










3529



      STagVal val = {0};




24,737,628✔





3530



      val.cid = pExprInfo[j].base.pParam[0].pCol->colId;




24,738,889✔





3531



      const char* p = pAPI->metaFn.extractTagVal((*mr).me.ctbEntry.pTags, pDst->info.type, &val);




24,739,404✔





3532












3533



      char* data = NULL;




24,737,859✔





3534



      if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {




24,737,859✔





3535



        data = tTagValToData((const STagVal*)p, false);




24,736,473✔





3536



      } else {










3537



        data = (char*)p;




1,386✔





3538



      }










3539












3540



      code = colDataSetVal(pDst, (count), data,




24,736,083✔





3541



                           (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data)));




24,736,083✔





3542



      QUERY_CHECK_CODE(code, lino, _end);




24,738,143✔





3543












3544



      if ((pDst->info.type != TSDB_DATA_TYPE_JSON) && (p != NULL) && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) &&




24,738,143✔





3545



          (data != NULL)) {










3546



        taosMemoryFree(data);




8,798,769✔





3547



      }










3548



    }










3549



  }










3550












3551



_end:




9,677,976✔





3552



  if (code != TSDB_CODE_SUCCESS) {




9,675,515✔





3553



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3554



    pTaskInfo->code = code;




×







3555



  } else {










3556



    pRes->info.rows++;




9,675,515✔





3557



  }










3558












3559



  return code;




9,675,515✔





3560



}










3561












3562



static void tagScanFreeUidTag(void* p) {




7,228,646✔





3563



  STUidTagInfo* pInfo = p;




7,228,646✔





3564



  if (pInfo->pTagVal != NULL) {




7,228,646✔





3565



    taosMemoryFree(pInfo->pTagVal);




7,231,352✔





3566



  }










3567



}




7,227,141✔





3568












3569



static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SScalarParam* pParam) {




1,610,961✔





3570



  SColumnInfoData* pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData));




1,610,961✔





3571



  if (pColumnData == NULL) {




1,610,441✔





3572



    return terrno;




×







3573



  }










3574












3575



  pColumnData->info.type = pType->type;




1,610,441✔





3576



  pColumnData->info.bytes = pType->bytes;




1,611,092✔





3577



  pColumnData->info.scale = pType->scale;




1,609,126✔





3578



  pColumnData->info.precision = pType->precision;




1,611,092✔





3579












3580



  int32_t code = colInfoDataEnsureCapacity(pColumnData, numOfRows, true);




1,609,627✔





3581



  if (code != TSDB_CODE_SUCCESS) {




1,608,765✔





3582



    terrno = code;




×







3583



    taosMemoryFree(pColumnData);




×







3584



    return terrno;




×







3585



  }










3586












3587



  pParam->columnData = pColumnData;




1,608,765✔





3588



  pParam->colAlloced = true;




1,610,441✔





3589



  return TSDB_CODE_SUCCESS;




1,610,441✔





3590



}










3591












3592



static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {




9,787,974✔





3593



  int32_t                code = TSDB_CODE_SUCCESS;




9,787,974✔





3594



  int32_t                lino = 0;




9,787,974✔





3595



  STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext;




9,787,974✔





3596



  SColumnNode*           pSColumnNode = NULL;




9,787,974✔





3597



  if (QUERY_NODE_COLUMN == nodeType((*pNode))) {




9,787,473✔





3598



    pSColumnNode = *(SColumnNode**)pNode;




2,758,762✔





3599



  } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) {




7,032,069✔





3600



    SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode);




508✔





3601



    if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) {




508✔





3602



      pSColumnNode = NULL;




×







3603



      pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode);




×







3604



      if (NULL == pSColumnNode) {




×







3605



        return DEAL_RES_ERROR;




×







3606



      }










3607



      pSColumnNode->colId = -1;




×







3608



      pSColumnNode->colType = COLUMN_TYPE_TBNAME;




×







3609



      pSColumnNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




×







3610



      pSColumnNode->node.resType.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;




×







3611



      nodesDestroyNode(*pNode);




×







3612



      *pNode = (SNode*)pSColumnNode;




×







3613



    } else {










3614



      return DEAL_RES_CONTINUE;




508✔





3615



    }










3616



  } else {










3617



    return DEAL_RES_CONTINUE;




7,031,542✔





3618



  }










3619












3620



  void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));




2,761,251✔





3621



  if (!data) {




2,757,415✔





3622



    code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));




1,611,639✔





3623



    if (code == TSDB_CODE_DUP_KEY) {




1,614,974✔





3624



      code = TSDB_CODE_SUCCESS;




×







3625



    }










3626



    QUERY_CHECK_CODE(code, lino, _end);




1,614,974✔





3627



    pSColumnNode->slotId = pCtx->index++;




1,614,974✔





3628



    SColumnInfo cInfo = {.colId = pSColumnNode->colId,




1,614,623✔





3629



                         .type = pSColumnNode->node.resType.type,




1,611,504✔





3630



                         .bytes = pSColumnNode->node.resType.bytes};




1,612,005✔





3631



    void*       tmp = taosArrayPush(pCtx->cInfoList, &cInfo);




1,610,522✔





3632



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,615,475✔





3633



  } else {










3634



    SColumnNode* col = *(SColumnNode**)data;




1,145,776✔





3635



    pSColumnNode->slotId = col->slotId;




1,145,776✔





3636



  }










3637












3638



_end:




2,758,746✔





3639



  if (code != TSDB_CODE_SUCCESS) {




2,759,397✔





3640



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3641



    return DEAL_RES_ERROR;




×







3642



  }










3643



  return DEAL_RES_CONTINUE;




2,759,397✔





3644



}










3645












3646



static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode,




1,611,944✔





3647



                                      SStorageAPI* pAPI, STagScanInfo* pInfo, void* pStreamRuntimeInfo) {










3648



  int32_t code = TSDB_CODE_SUCCESS;




1,611,944✔





3649



  int32_t lino = 0;




1,611,944✔





3650



  int32_t numOfTables = taosArrayGetSize(aUidTags);




1,611,944✔





3651



  SArray* pBlockList = NULL;




1,611,944✔





3652












3653



  SSDataBlock* pResBlock = createTagValBlockForFilter(pInfo->filterCtx.cInfoList, numOfTables, aUidTags, pVnode, pAPI);




1,611,944✔





3654



  QUERY_CHECK_NULL(pResBlock, code, lino, _end, terrno);




1,610,460✔





3655












3656



  pBlockList = taosArrayInit(1, POINTER_BYTES);




1,610,460✔





3657



  QUERY_CHECK_NULL(pBlockList, code, lino, _end, terrno);




1,610,441✔





3658












3659



  void* tmp = taosArrayPush(pBlockList, &pResBlock);




1,610,961✔





3660



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,610,961✔





3661












3662



  SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)};




1,610,961✔





3663












3664



  SScalarParam output = {0};




1,611,443✔





3665



  code = tagScanCreateResultData(&type, numOfTables, &output);




1,611,443✔





3666



  QUERY_CHECK_CODE(code, lino, _end);




1,609,579✔





3667












3668



  gTaskScalarExtra.pStreamInfo = (void*)pStreamRuntimeInfo;




1,609,579✔





3669



  gTaskScalarExtra.pStreamRange = NULL;




1,609,579✔





3670



  code = scalarCalculate(pTagCond, pBlockList, &output, &gTaskScalarExtra);




1,609,598✔





3671



  QUERY_CHECK_CODE(code, lino, _end);




1,605,771✔





3672












3673



  bool* result = (bool*)output.columnData->pData;




1,605,771✔





3674



  for (int32_t i = 0; i < numOfTables; ++i) {




4,023,200✔





3675



    if (result[i]) {




2,411,339✔





3676



      void* tmp = taosArrayPush(aFilterIdxs, &i);




2,247,175✔





3677



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




2,247,175✔





3678



    }










3679



  }










3680












3681



  colDataDestroy(output.columnData);




1,609,763✔





3682



  taosMemoryFreeClear(output.columnData);




1,607,891✔





3683












3684



_end:




1,605,990✔





3685



  blockDataDestroy(pResBlock);




1,606,901✔





3686



  taosArrayDestroy(pBlockList);




1,604,598✔





3687



  if (code != TSDB_CODE_SUCCESS) {




1,600,348✔





3688



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3689



  }










3690



  return code;




1,600,348✔





3691



}










3692












3693



static int32_t tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo,




29,518,266✔





3694



                                         SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex,










3695



                                         const SStorageAPI* pAPI, void* pVnode) {










3696



  int32_t code = TSDB_CODE_SUCCESS;




29,518,266✔





3697



  int32_t lino = 0;




29,518,266✔





3698



  if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) {




29,518,266✔





3699



    if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) {  // tbname




14,027,377✔





3700



      char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};




×







3701



      STR_TO_VARSTR(str, "ctbidx");




×







3702












3703



      code = colDataSetVal(pColInfo, rowIndex, str, false);




×







3704



      QUERY_CHECK_CODE(code, lino, _end);




×







3705



    } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) {




14,022,439✔





3706



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false);




7,007,308✔





3707



      QUERY_CHECK_CODE(code, lino, _end);




7,010,712✔





3708



    } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) {




7,013,939✔





3709



      code = colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false);




7,007,180✔





3710



      QUERY_CHECK_CODE(code, lino, _end);




7,013,427✔





3711



    }










3712



  } else {










3713



    STagVal tagVal = {0};




15,481,139✔





3714



    tagVal.cid = pExprInfo->base.pParam[0].pCol->colId;




15,484,896✔





3715



    if (pUidTagInfo->pTagVal == NULL) {




15,491,016✔





3716



      colDataSetNULL(pColInfo, rowIndex);




×







3717



    } else {










3718



      const char* p = pAPI->metaFn.extractTagVal(pUidTagInfo->pTagVal, pColInfo->info.type, &tagVal);




15,485,261✔





3719












3720



      if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {




15,489,351✔





3721



        colDataSetNULL(pColInfo, rowIndex);




6,311✔





3722



      } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {




15,484,524✔





3723



        code = colDataSetVal(pColInfo, rowIndex, p, false);




×







3724



        QUERY_CHECK_CODE(code, lino, _end);




×







3725



      } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {




19,224,953✔





3726



        if (IS_STR_DATA_BLOB(pColInfo->info.type)) {




3,751,016✔





3727



          QUERY_CHECK_CODE(code = TSDB_CODE_BLOB_NOT_SUPPORT_TAG, lino, _end);




×







3728



        }










3729



        char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);




3,753,635✔





3730



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




3,751,819✔





3731












3732



        varDataSetLen(tmp, tagVal.nData);




3,751,819✔





3733



        memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);




3,752,186✔





3734



        code = colDataSetVal(pColInfo, rowIndex, tmp, false);




3,748,603✔





3735



        taosMemoryFree(tmp);




3,754,119✔





3736



        QUERY_CHECK_CODE(code, lino, _end);




3,751,435✔





3737



      } else {










3738



        code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false);




11,717,152✔





3739



        QUERY_CHECK_CODE(code, lino, _end);




11,726,466✔





3740



      }










3741



    }










3742



  }










3743












3744



_end:




29,513,973✔





3745



  if (code != TSDB_CODE_SUCCESS) {




29,513,973✔





3746



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3747



  }










3748



  return code;




29,503,563✔





3749



}










3750












3751



static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags,




4,623,053✔





3752



                                      SArray* aFilterIdxs, bool ignoreFilterIdx, SStorageAPI* pAPI) {










3753



  int32_t       code = TSDB_CODE_SUCCESS;




4,623,053✔





3754



  int32_t       lino = 0;




4,623,053✔





3755



  STagScanInfo* pInfo = pOperator->info;




4,623,053✔





3756



  SExprInfo*    pExprInfo = &pOperator->exprSupp.pExprInfo[0];




4,624,692✔





3757



  if (!ignoreFilterIdx) {




4,623,089✔





3758



    size_t szTables = taosArrayGetSize(aFilterIdxs);




1,606,167✔





3759



    for (int i = 0; i < szTables; ++i) {




3,847,422✔





3760



      int32_t       idx = *(int32_t*)taosArrayGet(aFilterIdxs, i);




2,238,070✔





3761



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx);




2,237,439✔





3762



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




2,237,524✔





3763



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




12,815,513✔





3764



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




10,566,674✔





3765



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




10,579,569✔





3766



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




10,579,569✔





3767



        QUERY_CHECK_CODE(code, lino, _end);




10,577,989✔





3768



      }










3769



    }










3770



  } else {










3771



    size_t szTables = taosArrayGetSize(aUidTags);




3,016,922✔





3772



    for (int i = 0; i < szTables; ++i) {




7,837,017✔





3773



      STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i);




4,819,609✔





3774



      QUERY_CHECK_NULL(pUidTagInfo, code, lino, _end, terrno);




4,820,121✔





3775



      for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) {




23,744,067✔





3776



        SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId);




18,923,648✔





3777



        QUERY_CHECK_NULL(pDst, code, lino, _end, terrno);




18,924,031✔





3778



        code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode);




18,924,031✔





3779



        QUERY_CHECK_CODE(code, lino, _end);




18,923,946✔





3780



      }










3781



    }










3782



  }










3783












3784



_end:




3,017,408✔





3785



  if (code != TSDB_CODE_SUCCESS) {




4,626,760✔





3786



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3787



  }










3788



  return code;




4,627,395✔





3789



}










3790












3791



static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




9,207,490✔





3792



  int32_t        code = TSDB_CODE_SUCCESS;




9,207,490✔





3793



  int32_t        lino = 0;




9,207,490✔





3794



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,207,490✔





3795



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




9,208,304✔





3796












3797



  STagScanInfo* pInfo = pOperator->info;




9,206,251✔





3798



  SSDataBlock*  pRes = pInfo->pRes;




9,211,460✔





3799












3800



  QRY_PARAM_CHECK(ppRes);




9,204,836✔





3801












3802



  if (pOperator->status == OP_EXEC_DONE) {




9,205,463✔





3803



    return TSDB_CODE_SUCCESS;




4,504,020✔





3804



  }










3805



  blockDataCleanup(pRes);




4,700,667✔





3806












3807



  if (pInfo->pCtbCursor == NULL) {




4,700,293✔





3808



    pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);




4,702,119✔





3809



    QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, terrno);




4,702,371✔





3810



  } else {










3811



    code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);




×







3812



    QUERY_CHECK_CODE(code, lino, _end);




×







3813



  }










3814












3815



  SArray* aUidTags = pInfo->aUidTags;




4,701,885✔





3816



  SArray* aFilterIdxs = pInfo->aFilterIdxs;




4,701,885✔





3817



  int32_t count = 0;




4,701,065✔





3818



  bool    ctbCursorFinished = false;




4,701,065✔





3819



  while (1) {




108,447✔





3820



    taosArrayClearEx(aUidTags, tagScanFreeUidTag);




4,809,512✔





3821



    taosArrayClear(aFilterIdxs);




4,809,399✔





3822












3823



    int32_t numTables = 0;




4,807,560✔





3824



    while (numTables < pOperator->resultInfo.capacity) {




12,049,312✔





3825



      SMCtbCursor* pCur = pInfo->pCtbCursor;




12,045,969✔





3826



      tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);




12,045,375✔





3827



      if (uid == 0) {




12,043,693✔





3828



        ctbCursorFinished = true;




4,812,788✔





3829



        break;




4,812,788✔





3830



      }










3831



      STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};




7,230,905✔





3832



      info.pTagVal = taosMemoryMalloc(pCur->vLen);




7,227,974✔





3833



      QUERY_CHECK_NULL(info.pTagVal, code, lino, _end, terrno);




7,228,316✔





3834












3835



      memcpy(info.pTagVal, pCur->pVal, pCur->vLen);




7,228,316✔





3836



      void* tmp = taosArrayPush(aUidTags, &info);




7,235,726✔





3837



      QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




7,235,726✔





3838



      ++numTables;




7,235,726✔





3839



    }










3840












3841



    if (numTables == 0) {




4,812,788✔





3842



      break;




183,062✔





3843



    }










3844



    bool ignoreFilterIdx = true;




4,629,726✔





3845



    if (pInfo->pTagCond != NULL) {




4,629,726✔





3846



      ignoreFilterIdx = false;




1,611,944✔





3847



      code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo, pTaskInfo->pStreamRuntimeInfo);




1,611,944✔





3848



      QUERY_CHECK_CODE(code, lino, _end);




1,605,265✔





3849



    } else {










3850



      ignoreFilterIdx = true;




3,017,296✔





3851



    }










3852












3853



    code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI);




4,622,561✔





3854



    QUERY_CHECK_CODE(code, lino, _end);




4,627,395✔





3855












3856



    count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs);




4,627,395✔





3857












3858



    if (count != 0) {




4,627,738✔





3859



      break;




4,519,291✔





3860



    }










3861



  }










3862












3863



  if (count > 0) {




4,702,353✔





3864



    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);




4,517,442✔





3865



  }










3866



  if (count == 0 || ctbCursorFinished) {




4,701,608✔





3867



    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




4,701,608✔





3868



    pInfo->pCtbCursor = NULL;




4,693,138✔





3869



    setOperatorCompleted(pOperator);




4,692,637✔





3870



  }










3871












3872



  pRes->info.rows = count;




4,696,504✔





3873



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




4,695,392✔





3874



  if (bLimitReached) {




4,698,637✔





3875



    setOperatorCompleted(pOperator);




×







3876



  }










3877












3878



  pOperator->resultInfo.totalRows += pRes->info.rows;




4,698,637✔





3879



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




4,693,436✔





3880












3881



_end:




4,690,865✔





3882



  if (code != TSDB_CODE_SUCCESS) {




4,690,865✔





3883



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







3884



    pTaskInfo->code = code;




×







3885



    T_LONG_JMP(pTaskInfo->env, code);




×







3886



  }










3887












3888



  return code;




4,690,865✔





3889



}










3890












3891



static int32_t createTagScanTableListInfoFromParam(SOperatorInfo* pOperator) {




3,544,166✔





3892



  STagScanInfo*          pInfo = pOperator->info;




3,544,166✔





3893



  SExecTaskInfo*         pTaskInfo = pOperator->pTaskInfo;




3,544,166✔





3894



  int32_t                code = 0;




3,544,166✔





3895



  STableListInfo*        pListInfo = pInfo->pTableListInfo;




3,544,166✔





3896



  STagScanOperatorParam* pParam = (STagScanOperatorParam*)pOperator->pOperatorGetParam->value;




3,544,166✔





3897



  tb_uid_t               pUid = pParam->vcUid;




3,544,166✔





3898












3899



  // qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d",










3900



  //        pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList),










3901



  //        pOperator->status);










3902












3903



  STableKeyInfo info = {.groupId = 0};




3,544,166✔





3904












3905



  int32_t tableIdx = 0;




3,544,166✔





3906



  taosHashClear(pListInfo->map);




3,544,166✔





3907



  taosArrayClear(pListInfo->pTableList);




3,544,166✔





3908












3909



  if (taosHashPut(pListInfo->map, &pUid, sizeof(uint64_t), &tableIdx, sizeof(int32_t))) {




3,544,166✔





3910



    if (TSDB_CODE_DUP_KEY == terrno) {




×







3911



    } else {










3912



      return terrno;




×







3913



    }










3914



  }










3915












3916



  info.uid = pUid;




3,544,166✔





3917



  void* p = taosArrayPush(pListInfo->pTableList, &info);




3,544,166✔





3918



  if (p == NULL) {




3,544,166✔





3919



    return terrno;




×







3920



  }










3921












3922



  qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo));




3,544,166✔





3923












3924



  return code;




3,544,166✔





3925



}










3926












3927



static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




6,854,204✔





3928



  int32_t       code = TSDB_CODE_SUCCESS;




6,854,204✔





3929



  int32_t       lino = 0;




6,854,204✔





3930



  STagScanInfo* pInfo = pOperator->info;




6,854,204✔





3931



  if (pOperator->pOperatorGetParam) {




6,855,493✔





3932



    pOperator->resultInfo.totalRows = 0;




3,544,166✔





3933



    pOperator->dynamicTask = true;




3,544,166✔





3934



    pInfo->curPos = 0;




3,544,166✔





3935



    code = createTagScanTableListInfoFromParam(pOperator);




3,544,166✔





3936



    freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM);




3,544,166✔





3937



    pOperator->pOperatorGetParam = NULL;




3,544,166✔





3938



    QUERY_CHECK_CODE(code, lino, _end);




3,544,166✔





3939












3940



    if (pOperator->status == OP_EXEC_DONE) {




3,544,166✔





3941



      pOperator->status = OP_OPENED;




1,921,244✔





3942



    }










3943



  }










3944












3945



  if (pOperator->status == OP_EXEC_DONE) {




6,854,978✔





3946



    (*ppRes) = NULL;




1,641,289✔





3947



    return code;




1,641,289✔





3948



  }










3949












3950



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




5,212,311✔





3951



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




5,213,430✔





3952












3953



  SExprInfo*   pExprInfo = &pOperator->exprSupp.pExprInfo[0];




5,211,423✔





3954



  SSDataBlock* pRes = pInfo->pRes;




5,214,062✔





3955



  blockDataCleanup(pRes);




5,213,174✔





3956












3957



  int32_t size = 0;




5,212,915✔





3958



  code = tableListGetSize(pInfo->pTableListInfo, &size);




5,213,547✔





3959



  QUERY_CHECK_CODE(code, lino, _end);




5,212,915✔





3960












3961



  if (size == 0) {




5,212,915✔





3962



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




17,943✔





3963



    (*ppRes) = NULL;




17,943✔





3964



    return code;




17,943✔





3965



  }










3966












3967



  SMetaReader mr = {0};




5,194,972✔





3968



  pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);




5,194,972✔





3969



  pRes->info.rows = 0;




5,195,746✔





3970












3971



  while (pInfo->curPos < size && pRes->info.rows < pOperator->resultInfo.capacity) {




14,872,664✔





3972



    code = doTagScanOneTable(pOperator, pRes, &mr, &pTaskInfo->storageAPI);




9,675,142✔





3973



    if (code != TSDB_CODE_OUT_OF_MEMORY && code != TSDB_CODE_QRY_REACH_QMEM_THRESHOLD &&




9,677,294✔





3974



        code != TSDB_CODE_QRY_QUERY_MEM_EXHAUSTED) {










3975



      // ignore other error










3976



      code = TSDB_CODE_SUCCESS;




9,677,294✔





3977



    }










3978



    QUERY_CHECK_CODE(code, lino, _end);




9,677,294✔





3979












3980



    if (++pInfo->curPos >= size) {




9,677,294✔





3981



      setOperatorCompleted(pOperator);




5,196,634✔





3982



    }










3983



  }










3984












3985



  pAPI->metaReaderFn.clearReader(&mr);




5,195,259✔





3986



  bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo);




5,196,634✔





3987



  if (bLimitReached) {




5,196,634✔





3988



    setOperatorCompleted(pOperator);




×







3989



  }










3990












3991



  // qDebug("QInfo:0x%" PRIx64 ", create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count);










3992



  if (pOperator->status == OP_EXEC_DONE) {




5,196,634✔





3993



    setTaskStatus(pTaskInfo, TASK_COMPLETED);




5,196,634✔





3994



  }










3995












3996



  pOperator->resultInfo.totalRows += pRes->info.rows;




5,196,002✔





3997












3998



  (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;




5,196,002✔





3999



_end:




5,196,634✔





4000



  if (code != TSDB_CODE_SUCCESS) {




5,196,002✔





4001



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4002



    pTaskInfo->code = code;




×







4003



    T_LONG_JMP(pTaskInfo->env, code);




×







4004



  }










4005



  return code;




5,196,002✔





4006



}










4007












4008



static void destroyTagScanOperatorInfo(void* param) {




8,326,110✔





4009



  STagScanInfo* pInfo = (STagScanInfo*)param;




8,326,110✔





4010



  if (pInfo->pCtbCursor != NULL && pInfo->pStorageAPI != NULL) {




8,326,110✔





4011



    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




×







4012



  }










4013



  taosHashCleanup(pInfo->filterCtx.colHash);




8,330,285✔





4014



  taosArrayDestroy(pInfo->filterCtx.cInfoList);




8,318,793✔





4015



  taosArrayDestroy(pInfo->aFilterIdxs);




8,309,989✔





4016



  taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag);




8,314,063✔





4017












4018



  blockDataDestroy(pInfo->pRes);




8,322,093✔





4019



  taosArrayDestroy(pInfo->matchInfo.pList);




8,322,125✔





4020



  tableListDestroy(pInfo->pTableListInfo);




8,324,075✔





4021












4022



  pInfo->pRes = NULL;




8,326,699✔





4023



  pInfo->pTableListInfo = NULL;




8,325,880✔





4024



  taosMemoryFreeClear(param);




8,327,198✔





4025



}




8,323,179✔





4026












4027



static int32_t resetTagScanOperatorState(SOperatorInfo* pOper) {




4,696✔





4028



  int32_t         code = TSDB_CODE_SUCCESS;




4,696✔





4029



  STagScanInfo*   pInfo = pOper->info;




4,696✔





4030












4031



  pOper->status = OP_NOT_OPENED;




4,696✔





4032



  STagScanPhysiNode* pTagScanNode = (STagScanPhysiNode*)pOper->pPhyNode;




4,696✔





4033



  if (pTagScanNode->onlyMetaCtbIdx) {




4,696✔





4034



      SExecTaskInfo* pTaskInfo = pOper->pTaskInfo;




2,032✔





4035



      SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




2,032✔





4036



      pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);




2,032✔





4037



      pInfo->pCtbCursor = NULL;




2,032✔





4038



  } else {










4039



      pInfo->curPos = 0;




2,664✔





4040



  }










4041












4042



  return code;




4,696✔





4043



}










4044












4045



int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode,




8,328,381✔





4046



                                  STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond,










4047



                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










4048



  QRY_PARAM_CHECK(pOptrInfo);




8,328,381✔





4049












4050



  int32_t         code = TSDB_CODE_SUCCESS;




8,318,481✔





4051



  int32_t         lino = 0;




8,318,481✔





4052



  SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode;




8,318,481✔





4053



  STagScanInfo*   pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo));




8,318,481✔





4054



  SOperatorInfo*  pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




8,321,746✔





4055



  if (pInfo == NULL || pOperator == NULL) {




8,317,691✔





4056



    code = terrno;




×







4057



    goto _error;




×







4058



  }










4059



  pOperator->pPhyNode = pTagScanNode;




8,317,691✔





4060



  SDataBlockDescNode* pDescNode = pPhyNode->node.pOutputDataBlockDesc;




8,318,554✔





4061












4062



  int32_t    numOfExprs = 0;




8,321,666✔





4063



  SExprInfo* pExprInfo = NULL;




8,323,018✔





4064












4065



  code = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &pExprInfo, &numOfExprs);




8,324,465✔





4066



  QUERY_CHECK_CODE(code, lino, _error);




8,324,621✔





4067












4068



  code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);




8,324,621✔





4069



  QUERY_CHECK_CODE(code, lino, _error);




8,316,952✔





4070












4071



  int32_t num = 0;




8,316,952✔





4072



  code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);




8,319,904✔





4073



  QUERY_CHECK_CODE(code, lino, _error);




8,308,482✔





4074












4075



  pInfo->pTagCond = pTagCond;




8,308,482✔





4076



  pInfo->pTagIndexCond = pTagIndexCond;




8,320,207✔





4077



  pInfo->suid = pPhyNode->suid;




8,312,925✔





4078



  pInfo->pStorageAPI = &pTaskInfo->storageAPI;




8,308,731✔





4079












4080



  pInfo->pTableListInfo = pTableListInfo;




8,321,253✔





4081



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




8,308,948✔





4082



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




8,324,486✔





4083












4084



  pInfo->readHandle = *pReadHandle;




8,310,244✔





4085



  pInfo->curPos = 0;




8,325,253✔





4086












4087



  initLimitInfo(pPhyNode->node.pLimit, pPhyNode->node.pSlimit, &pInfo->limitInfo);




8,303,967✔





4088



  setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo,




8,304,652✔





4089



                  pTaskInfo);










4090



  initResultSizeInfo(&pOperator->resultInfo, 4096);




8,305,438✔





4091



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




8,320,104✔





4092



  QUERY_CHECK_CODE(code, lino, _error);




8,330,556✔





4093












4094



  if (pTagScanNode->onlyMetaCtbIdx) {




8,330,556✔





4095



    pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo));




4,707,858✔





4096



    QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, terrno);




4,709,242✔





4097












4098



    pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t));




4,708,891✔





4099



    QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, terrno);




4,708,257✔





4100












4101



    pInfo->filterCtx.colHash =




4,707,271✔





4102



        taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);




4,708,739✔





4103



    QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, terrno);




4,707,271✔





4104












4105



    pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));




4,708,256✔





4106



    QUERY_CHECK_NULL(pInfo->filterCtx.cInfoList, code, lino, _error, terrno);




4,708,742✔





4107












4108



    if (pInfo->pTagCond != NULL) {




4,708,242✔





4109



      nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx);




1,615,475✔





4110



    }










4111



  }










4112



  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;




8,331,940✔





4113



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,




8,332,401✔





4114



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










4115



  setOperatorResetStateFn(pOperator, resetTagScanOperatorState);     




8,327,417✔





4116



  










4117



  *pOptrInfo = pOperator;




8,331,695✔





4118



  return code;




8,319,210✔





4119












4120



_error:




×







4121



  if (pInfo) {




×







4122



    pInfo->pTableListInfo = NULL;




×







4123



  }










4124












4125



  if (pInfo != NULL) destroyTagScanOperatorInfo(pInfo);




×







4126



  if (pOperator != NULL) {




×







4127



    pOperator->info = NULL;




×







4128



    destroyOperator(pOperator);




×







4129



  }










4130



  return code;




×







4131



}










4132












4133



// table merge scan operator










4134












4135



static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) {




238,634,507✔





4136



  int32_t                 left = *(int32_t*)pLeft;




238,634,507✔





4137



  int32_t                 right = *(int32_t*)pRight;




238,635,229✔





4138



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




238,635,951✔





4139












4140



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




238,635,951✔





4141



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




238,634,868✔





4142












4143



  if (leftIdx == -1) {




238,636,312✔





4144



    return 1;




204,603,352✔





4145



  } else if (rightIdx == -1) {




34,032,960✔





4146



    return -1;




336,960✔





4147



  }










4148












4149



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




33,696,000✔





4150



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




33,696,000✔





4151



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




33,696,000✔





4152



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




33,696,000✔





4153



    ret = -1 * ret;




×







4154



  }










4155



  return ret;




33,696,000✔





4156



}










4157












4158



static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) {




×







4159



  int32_t                 left = *(int32_t*)pLeft;




×







4160



  int32_t                 right = *(int32_t*)pRight;




×







4161



  STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param;




×







4162












4163



  int32_t leftIdx = pInfo->aInputs[left].rowIdx;




×







4164



  int32_t rightIdx = pInfo->aInputs[right].rowIdx;




×







4165












4166



  if (leftIdx == -1) {




×







4167



    return 1;




×







4168



  } else if (rightIdx == -1) {




×







4169



    return -1;




×







4170



  }










4171












4172



  int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx];




×







4173



  int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx];




×







4174



  int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0);




×







4175



  if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) {




×







4176



    ret = -1 * ret;




×







4177



  }










4178



  if (ret == 0 && pInfo->pPkOrderInfo) {




×







4179



    ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx,




×







4180



                               pInfo->pPkOrderInfo);




×







4181



  }










4182



  return ret;




×







4183



}










4184












4185



int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) {




3,031,884✔





4186



  int32_t code = TSDB_CODE_SUCCESS;




3,031,884✔





4187



  int32_t lino = 0;




3,031,884✔





4188



  memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond));




3,031,884✔





4189



  dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo));




3,031,884✔





4190



  QUERY_CHECK_NULL(dst->colList, code, lino, _end, terrno);




3,022,337✔





4191



  for (int i = 0; i < src->numOfCols; i++) {




10,364,215✔





4192



    dst->colList[i] = src->colList[i];




7,353,521✔





4193



  }










4194












4195



_end:




3,036,497✔





4196



  if (code != TSDB_CODE_SUCCESS) {




3,036,497✔





4197



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4198



  }










4199



  return code;




3,031,874✔





4200



}










4201












4202



static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput,




4,554,676✔





4203



                                                bool* pSubTableHasBlock) {










4204



  int32_t code = 0;




4,554,676✔





4205












4206



  STableMergeScanInfo*    pInfo = pOperator->info;




4,554,676✔





4207



  SReadHandle*            pHandle = &pInfo->base.readHandle;




4,555,047✔





4208



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




4,554,676✔





4209



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




4,557,504✔





4210



  const SStorageAPI*      pAPI = &pTaskInfo->storageAPI;




4,554,365✔





4211












4212



  blockDataCleanup(pInput->pReaderBlock);




4,553,653✔





4213



  if (!pInput->bInMemReader) {




4,552,901✔





4214



    code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock,




4,565,643✔





4215



                                         (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




2,283,699✔





4216



    if (code != 0) {




2,279,487✔





4217



      return code;




×







4218



    }










4219



  }










4220












4221



  pInfo->base.dataReader = pInput->pReader;




4,553,653✔





4222












4223



  while (true) {




9,747✔





4224



    bool hasNext = false;




4,563,310✔





4225



    code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext);




4,563,681✔





4226



    if (code != 0) {




4,567,973✔





4227



      pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4228



      pInfo->base.dataReader = NULL;




×







4229



      return code;




×







4230



    }










4231












4232



    if (!hasNext || isTaskKilled(pTaskInfo)) {




4,567,973✔





4233



      if (isTaskKilled(pTaskInfo)) {




3,043,878✔





4234



        pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader);




×







4235



        pInfo->base.dataReader = NULL;




×







4236



        return code;




×







4237



      }










4238












4239



      *pSubTableHasBlock = false;




3,044,229✔





4240



      break;




3,044,219✔





4241



    }










4242












4243



    if (pInput->tblCond.order == TSDB_ORDER_ASC) {




1,524,095✔





4244



      pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1;




1,498,103✔





4245



    } else {










4246



      pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1;




25,992✔





4247



    }










4248












4249



    uint32_t status = 0;




1,524,095✔





4250



    code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status);




1,524,456✔





4251



    if (code != 0) {




1,524,456✔





4252



      pInfo->base.dataReader = NULL;




×







4253



      return code;




×







4254



    }










4255












4256



    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




1,524,456✔





4257



      *pSubTableHasBlock = false;




×







4258



      break;




×







4259



    }










4260



    if (status == FUNC_DATA_REQUIRED_FILTEROUT || pInput->pReaderBlock->info.rows == 0) {




1,524,456✔





4261



      continue;




9,747✔





4262



    }










4263












4264



    *pSubTableHasBlock = true;




1,514,358✔





4265



    break;




1,514,358✔





4266



  }










4267












4268



  if (*pSubTableHasBlock) {




4,558,938✔





4269



    pInput->pReaderBlock->info.id.groupId =




3,029,418✔





4270



        tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid);




3,029,067✔





4271



    pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows;




1,514,709✔





4272



  }










4273



  if (!pInput->bInMemReader || !*pSubTableHasBlock) {




4,559,289✔





4274



    pAPI->tsdReader.tsdReaderClose(pInput->pReader);




3,425,455✔





4275



    pInput->pReader = NULL;




3,424,021✔





4276



  }










4277












4278



  pInfo->base.dataReader = NULL;




4,557,133✔





4279



  return TSDB_CODE_SUCCESS;




4,557,143✔





4280



}










4281












4282



static int32_t setGroupStartEndIndex(STableMergeScanInfo* pInfo) {




1,889,055✔





4283



  pInfo->bGroupProcessed = false;




1,889,055✔





4284












4285



  int32_t numOfTables = 0;




1,892,575✔





4286



  int32_t code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




1,877,482✔





4287



  if (code != TSDB_CODE_SUCCESS) {




1,869,690✔





4288



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4289



    return code;




×







4290



  }










4291












4292



  int32_t i = pInfo->tableStartIndex + 1;




1,869,690✔





4293



  for (; i < numOfTables; ++i) {




3,015,638✔





4294



    STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




1,195,809✔





4295



    if (!tableKeyInfo) {




1,194,004✔





4296



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4297



      return terrno;




×







4298



    }










4299



    if (tableKeyInfo->groupId != pInfo->groupId) {




1,194,004✔





4300



      break;




56,560✔





4301



    }










4302



  }










4303



  pInfo->tableEndIndex = i - 1;




1,876,389✔





4304



  return TSDB_CODE_SUCCESS;




1,899,274✔





4305



}










4306












4307



static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) {




1,902,463✔





4308



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,944,185✔





4309



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,043,868✔





4310



    if (pInput->rowIdx == -1) {




3,043,156✔





4311



      continue;




1,528,808✔





4312



    }










4313












4314



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,513,636✔





4315



      pInput->rowIdx = 0;




1,514,709✔





4316



      pInput->pageIdx = -1;




1,514,709✔





4317



    }










4318












4319



    pInput->pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




1,513,646✔





4320



    SColumnInfoData* col = taosArrayGet(pInput->pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




1,513,997✔





4321



    if (!col) {




1,513,626✔





4322



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4323



      return terrno;




×







4324



    }










4325



    pInput->aTs = (int64_t*)col->pData;




1,513,626✔





4326



  }










4327












4328



  __merge_compare_fn_t mergeCompareFn = (!pSubTblsInfo->pPkOrderInfo) ? subTblRowCompareTsFn : subTblRowCompareTsPkFn;




1,901,751✔





4329



  return tMergeTreeCreate(&pSubTblsInfo->pTree, pSubTblsInfo->numSubTables, pSubTblsInfo, mergeCompareFn);




1,903,165✔





4330



}










4331












4332



static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) {




1,889,777✔





4333



  int32_t code = setGroupStartEndIndex(pInfo);




1,889,777✔





4334



  if (code != TSDB_CODE_SUCCESS) {




1,895,363✔





4335



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







4336



    return code;




×







4337



  }










4338



  STmsSubTablesMergeInfo* pSubTblsInfo = taosMemoryCalloc(1, sizeof(STmsSubTablesMergeInfo));




1,895,363✔





4339



  if (pSubTblsInfo == NULL) {




1,880,942✔





4340



    return terrno;




×







4341



  }










4342



  pSubTblsInfo->pTsOrderInfo = taosArrayGet(pInfo->pSortInfo, 0);




1,880,942✔





4343



  if (!pSubTblsInfo->pTsOrderInfo) {




1,892,605✔





4344



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4345



    return terrno;




×







4346



  }










4347



  if (taosArrayGetSize(pInfo->pSortInfo) == 2) {




1,878,846✔





4348



    pSubTblsInfo->pPkOrderInfo = taosArrayGet(pInfo->pSortInfo, 1);




×







4349



    if (!pSubTblsInfo->pPkOrderInfo) {




×







4350



      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4351



      return terrno;




×







4352



    }










4353



  } else {










4354



    pSubTblsInfo->pPkOrderInfo = NULL;




1,878,154✔





4355



  }










4356



  pSubTblsInfo->numSubTables = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




1,896,476✔





4357



  pSubTblsInfo->aInputs = taosMemoryCalloc(pSubTblsInfo->numSubTables, sizeof(STmsSubTableInput));




1,890,138✔





4358



  if (pSubTblsInfo->aInputs == NULL) {




1,878,455✔





4359



    taosMemoryFree(pSubTblsInfo);




×







4360



    return terrno;




×







4361



  }










4362



  int32_t bufPageSize = pInfo->bufPageSize;




1,888,704✔





4363



  int32_t inMemSize = (pSubTblsInfo->numSubTables - pSubTblsInfo->numTableBlocksInMem) * bufPageSize;




1,890,469✔





4364



  code = createDiskbasedBuf(&pSubTblsInfo->pBlocksBuf, pInfo->bufPageSize, inMemSize, "blocksExternalBuf", tsTempDir);




1,884,472✔





4365



  if (code != TSDB_CODE_SUCCESS) {




1,880,621✔





4366



    taosMemoryFree(pSubTblsInfo->aInputs);




×







4367



    taosMemoryFree(pSubTblsInfo);




×







4368



    return code;




×







4369



  }










4370



  pSubTblsInfo->numTableBlocksInMem = pSubTblsInfo->numSubTables;




1,880,621✔





4371



  pSubTblsInfo->numInMemReaders = pSubTblsInfo->numSubTables;




1,887,681✔





4372












4373



  pInfo->pSubTablesMergeInfo = pSubTblsInfo;




1,894,701✔





4374



  return TSDB_CODE_SUCCESS;




1,880,621✔





4375



}










4376












4377



static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) {




1,889,065✔





4378



  int32_t        code = TSDB_CODE_SUCCESS;




1,889,065✔





4379



  int32_t        lino = 0;




1,889,065✔





4380



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,889,065✔





4381



  SReadHandle*   pHandle = &pInfo->base.readHandle;




1,889,075✔





4382



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




1,880,972✔





4383












4384



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




1,877,462✔





4385












4386



  for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,935,049✔





4387



    STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,032,616✔





4388



    pInput->type = SUB_TABLE_MEM_BLOCK;




3,021,675✔





4389












4390



    code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond);




3,024,864✔





4391



    QUERY_CHECK_CODE(code, lino, _end);




3,032,927✔





4392












4393



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pReaderBlock);




3,032,927✔





4394



    QUERY_CHECK_CODE(code, lino, _end);




3,036,457✔





4395












4396



    code = createOneDataBlock(pInfo->pResBlock, false, &pInput->pPageBlock);




3,036,457✔





4397



    QUERY_CHECK_CODE(code, lino, _end);




3,043,878✔





4398












4399



    STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex);




3,043,878✔





4400



    pInput->pKeyInfo = keyInfo;




3,043,527✔





4401












4402



    if (isTaskKilled(pTaskInfo)) {




3,043,527✔





4403



      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);




×







4404



    }










4405












4406



    if (i + 1 < pSubTblsInfo->numInMemReaders) {




3,035,424✔





4407



      code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock,




2,281,747✔





4408



                                           (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL);




1,141,054✔





4409



      QUERY_CHECK_CODE(code, lino, _end);




1,139,249✔





4410



      pInput->bInMemReader = true;




1,139,249✔





4411



    } else {










4412



      pInput->pReader = NULL;




1,899,655✔





4413



      pInput->bInMemReader = false;




1,900,357✔





4414



    }










4415



    bool hasNext = true;




3,040,298✔





4416



    code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext);




3,039,616✔





4417



    QUERY_CHECK_CODE(code, lino, _end);




3,043,868✔





4418



    if (!hasNext) {




3,043,868✔





4419



      pInput->rowIdx = -1;




1,529,159✔





4420



      ++pSubTblsInfo->numSubTablesCompleted;




1,529,520✔





4421



      continue;




1,529,871✔





4422



    } else {










4423



      pInput->rowIdx = 0;




1,514,709✔





4424



      pInput->pageIdx = -1;




1,514,709✔





4425



    }










4426



  }










4427












4428



_end:




1,902,814✔





4429



  if (code != TSDB_CODE_SUCCESS) {




1,902,814✔





4430



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4431



  }










4432



  return code;




1,902,453✔





4433



}










4434












4435



static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




1,514,709✔





4436



  int32_t              code = TSDB_CODE_SUCCESS;




1,514,709✔





4437



  int32_t              lino = 0;




1,514,709✔





4438



  SExecTaskInfo*       pTaskInfo = pOperatorInfo->pTaskInfo;




1,514,709✔





4439



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




1,514,709✔





4440



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




1,514,709✔





4441



  bool                 hasNext = true;




1,514,709✔





4442



  code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext);




1,514,709✔





4443



  QUERY_CHECK_CODE(code, lino, _end);




1,514,709✔





4444












4445



  if (!hasNext) {




1,514,709✔





4446



    pInput->rowIdx = -1;




1,514,709✔





4447



    ++pSubTblsInfo->numSubTablesCompleted;




1,514,709✔





4448



  } else {










4449



    pInput->rowIdx = 0;




×







4450



  }










4451












4452



_end:




1,514,709✔





4453



  if (code != TSDB_CODE_SUCCESS) {




1,514,709✔





4454



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4455



    pTaskInfo->code = code;




×







4456



    T_LONG_JMP(pTaskInfo->env, code);




×







4457



  }










4458



}




1,514,709✔





4459












4460



static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) {




275,694,789✔





4461



  STableMergeScanInfo* pInfo = pOperatorInfo->info;




275,694,789✔





4462



  STmsSubTableInput*   pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




275,696,935✔





4463












4464



  SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




275,699,823✔





4465



  if (pInput->rowIdx < pInputBlock->info.rows - 1) {




275,702,711✔





4466



    ++pInput->rowIdx;




274,186,207✔





4467



  } else if (pInput->rowIdx == pInputBlock->info.rows - 1) {




1,514,709✔





4468



    if (pInput->type == SUB_TABLE_MEM_BLOCK) {




1,514,709✔





4469



      adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo);




1,514,709✔





4470



    }










4471



    if (pInput->rowIdx != -1) {




1,514,709✔





4472



      SColumnInfoData* col = taosArrayGet(pInputBlock->pDataBlock, pSubTblsInfo->pTsOrderInfo->slotId);




×







4473



      if (!col) {




×







4474



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







4475



        return terrno;




×







4476



      }










4477



      pInput->pInputBlock = pInputBlock;




×







4478



      pInput->aTs = (int64_t*)col->pData;




×







4479



    }










4480



  }










4481












4482



  return tMergeTreeAdjust(pSubTblsInfo->pTree, tMergeTreeGetAdjustIndex(pSubTblsInfo->pTree));




275,700,555✔





4483



}










4484












4485



static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) {




275,531,766✔





4486



  int32_t            code = TSDB_CODE_SUCCESS;




275,531,766✔





4487



  int32_t            lino = 0;




275,531,766✔





4488



  STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree);




275,531,766✔





4489



  SSDataBlock*       pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock;




275,632,252✔





4490












4491



  for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) {




1,152,615,350✔





4492



    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);




876,366,241✔





4493



    QUERY_CHECK_NULL(pColInfo, code, lino, _end, terrno);




876,311,797✔





4494












4495



    SColumnInfoData* pSrcColInfo = taosArrayGet(pInputBlock->pDataBlock, i);




876,311,797✔





4496



    QUERY_CHECK_NULL(pSrcColInfo, code, lino, _end, terrno);




876,241,929✔





4497



    bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL);




876,241,929✔





4498












4499



    if (isNull) {




876,707,737✔





4500



      code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true);




119,715,387✔





4501



      QUERY_CHECK_CODE(code, lino, _end);




119,708,157✔





4502



    } else {










4503



      if (pSrcColInfo->pData != NULL) {




756,992,350✔





4504



        char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx);




756,953,019✔





4505



        code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false);




757,650,672✔





4506



        QUERY_CHECK_CODE(code, lino, _end);




757,572,895✔





4507



      }










4508



    }










4509



  }










4510



  pBlock->info.dataLoad = 1;




275,694,789✔





4511



  pBlock->info.scanFlag = pInputBlock->info.scanFlag;




275,695,872✔





4512



  pBlock->info.rows += 1;




275,697,627✔





4513












4514



_end:




275,700,144✔





4515



  if (code != TSDB_CODE_SUCCESS) {




275,700,144✔





4516



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4517



  }










4518



  return code;




275,695,902✔





4519



}










4520












4521



static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity,




3,080,563✔





4522



                                       SSDataBlock** pResBlock) {










4523



  int32_t                 code = TSDB_CODE_SUCCESS;




3,080,563✔





4524



  int32_t                 lino = 0;




3,080,563✔





4525



  STableMergeScanInfo*    pInfo = pOperator->info;




3,080,563✔





4526



  SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;




3,080,563✔





4527



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




3,079,851✔





4528



  bool                    finished = false;




3,078,778✔





4529












4530



  QRY_PARAM_CHECK(pResBlock);




3,078,778✔





4531












4532



  blockDataCleanup(pBlock);




3,080,563✔





4533












4534



  while (true) {




×







4535



    while (true) {










4536



      if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) {




278,701,122✔





4537



        finished = true;




3,080,914✔





4538



        break;




3,080,914✔





4539



      }










4540












4541



      code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock);




275,620,960✔





4542



      QUERY_CHECK_CODE(code, lino, _end);




275,697,296✔





4543












4544



      code = adjustSubTableForNextRow(pOperator, pSubTblsInfo);




275,697,296✔





4545



      QUERY_CHECK_CODE(code, lino, _end);




275,618,082✔





4546












4547



      if (pBlock->info.rows >= capacity) {




275,618,082✔





4548



        break;




×







4549



      }










4550



    }










4551












4552



    if (isTaskKilled(pTaskInfo)) {




3,080,914✔





4553



      return pTaskInfo->code;




×







4554



    }










4555












4556



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);




3,080,914✔





4557



    if (finished || limitReached || pBlock->info.rows > 0) {




3,080,212✔





4558



      break;










4559



    }










4560



  }










4561












4562



  if (pBlock->info.rows > 0) {




3,080,212✔





4563



    *pResBlock = pBlock;




1,177,749✔





4564



  }










4565












4566



_end:




1,902,463✔





4567



  if (code != TSDB_CODE_SUCCESS) {




3,080,212✔





4568



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4569



    pTaskInfo->code = code;




×







4570



  }










4571



  return code;




3,080,914✔





4572



}










4573












4574



static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) {




1,889,065✔





4575



  int32_t              code = TSDB_CODE_SUCCESS;




1,889,065✔





4576



  int32_t              lino = 0;




1,889,065✔





4577



  STableMergeScanInfo* pInfo = pOperator->info;




1,889,065✔





4578












4579



  code = initSubTablesMergeInfo(pInfo);




1,895,403✔





4580



  QUERY_CHECK_CODE(code, lino, _end);




1,881,674✔





4581












4582



  code = initSubTableInputs(pOperator, pInfo);




1,881,674✔





4583



  QUERY_CHECK_CODE(code, lino, _end);




1,901,380✔





4584












4585



  code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo);




1,901,380✔





4586



  QUERY_CHECK_CODE(code, lino, _end);




1,901,751✔





4587












4588



_end:




1,901,751✔





4589



  if (code != TSDB_CODE_SUCCESS) {




1,901,751✔





4590



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4591



  }










4592



  return code;




1,902,814✔





4593



}










4594












4595



static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) {




28,114,516✔





4596



  STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo;




28,114,516✔





4597



  if (pSubTblsInfo != NULL) {




28,118,030✔





4598



    tMergeTreeDestroy(&pSubTblsInfo->pTree);




1,902,814✔





4599












4600



    for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) {




4,947,043✔





4601



      STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i;




3,044,580✔





4602



      taosMemoryFree(pInput->tblCond.colList);




3,044,580✔





4603



      blockDataDestroy(pInput->pReaderBlock);




3,043,878✔





4604



      blockDataDestroy(pInput->pPageBlock);




3,043,878✔





4605



      taosArrayDestroy(pInput->aBlockPages);




3,043,878✔





4606



      pInfo->base.readerAPI.tsdReaderClose(pInput->pReader);




3,043,878✔





4607



      pInput->pReader = NULL;




3,043,878✔





4608



    }










4609












4610



    destroyDiskbasedBuf(pSubTblsInfo->pBlocksBuf);




1,902,814✔





4611



    taosMemoryFree(pSubTblsInfo->aInputs);




1,901,761✔





4612












4613



    taosMemoryFree(pSubTblsInfo);




1,902,463✔





4614



    pInfo->pSubTablesMergeInfo = NULL;




1,902,112✔





4615












4616



    // taosMemoryTrim(0);










4617



  }










4618



}




28,117,328✔





4619












4620



int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




3,052,832✔





4621



  QRY_PARAM_CHECK(ppRes);




3,052,832✔





4622












4623



  int32_t lino = 0;




3,052,481✔





4624



  int32_t tableListSize = 0;




3,052,481✔





4625



  int64_t st = taosGetTimestampUs();




3,058,819✔





4626












4627



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,058,819✔





4628



  STableMergeScanInfo* pInfo = pOperator->info;




3,047,206✔





4629












4630



  if (pOperator->status == OP_EXEC_DONE) {




3,044,378✔





4631



    return TSDB_CODE_SUCCESS;




×







4632



  }










4633












4634



  int32_t code = pOperator->fpSet._openFn(pOperator);




3,051,779✔





4635



  QUERY_CHECK_CODE(code, lino, _end);




3,034,911✔





4636












4637



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




3,034,911✔





4638



  QUERY_CHECK_CODE(code, lino, _end);




3,048,590✔





4639












4640



  if (!pInfo->hasGroupId) {




3,048,590✔





4641



    pInfo->hasGroupId = true;




1,872,616✔





4642












4643



    if (tableListSize == 0) {




1,861,344✔





4644



      setOperatorCompleted(pOperator);




41,515✔





4645



      (*ppRes) = NULL;




41,154✔





4646



      return code;




41,154✔





4647



    }










4648












4649



    pInfo->tableStartIndex = 0;




1,819,829✔





4650



    STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,831,091✔





4651



    QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




1,818,766✔





4652



    pInfo->groupId = pTmpGpId->groupId;




1,818,766✔





4653



    code = startSubTablesTableMergeScan(pOperator);




1,833,919✔





4654



    QUERY_CHECK_CODE(code, lino, _end);




1,846,605✔





4655



  }










4656












4657



  SSDataBlock* pBlock = NULL;




3,024,003✔





4658



  while (pInfo->tableStartIndex < tableListSize) {




3,080,914✔





4659



    if (isTaskKilled(pTaskInfo)) {




3,080,553✔





4660



      break;




×







4661



    }










4662












4663



    code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock);




3,079,851✔





4664



    QUERY_CHECK_CODE(code, lino, _end);




3,080,914✔





4665












4666



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




3,080,914✔





4667



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




×







4668



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




×







4669












4670



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




×







4671



    }










4672












4673



    if (pBlock != NULL) {




3,080,563✔





4674



      pBlock->info.id.groupId = pInfo->groupId;




1,177,749✔





4675



      pOperator->resultInfo.totalRows += pBlock->info.rows;




1,177,749✔





4676



      pInfo->bGroupProcessed = true;




1,177,749✔





4677



      break;




1,177,749✔





4678



    } else {










4679



      // Data of this group are all dumped, let's try the next group










4680



      stopSubTablesTableMergeScan(pInfo);




1,902,814✔





4681



      if (pInfo->tableEndIndex >= tableListSize - 1) {




1,901,761✔





4682



        setOperatorCompleted(pOperator);




1,845,201✔





4683



        break;




1,845,552✔





4684



      }










4685












4686



      pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




56,560✔





4687



      STableKeyInfo* pTmpGpId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




56,560✔





4688



      QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno);




56,560✔





4689












4690



      pInfo->groupId = pTmpGpId->groupId;




56,560✔





4691



      code = startSubTablesTableMergeScan(pOperator);




56,560✔





4692



      QUERY_CHECK_CODE(code, lino, _end);




56,560✔





4693



      resetLimitInfoForNextGroup(&pInfo->limitInfo);




56,560✔





4694



    }










4695



  }










4696












4697



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




3,023,301✔





4698












4699



_end:




3,024,003✔





4700



  if (code != TSDB_CODE_SUCCESS) {




3,024,354✔





4701



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4702



    pTaskInfo->code = code;




×







4703



    T_LONG_JMP(pTaskInfo->env, code);




×







4704



  } else {










4705



    (*ppRes) = pBlock;




3,024,354✔





4706



  }










4707












4708



  return code;




3,023,652✔





4709



}










4710












4711



static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {




3,515,947✔





4712



  int32_t              code = TSDB_CODE_SUCCESS;




3,515,947✔





4713



  int32_t              lino = 0;




3,515,947✔





4714



  SOperatorInfo*       pOperator = (SOperatorInfo*)pTableMergeOpInfo;




3,515,947✔





4715



  STableMergeScanInfo* pInfo = pOperator->info;




3,515,947✔





4716



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




3,516,484✔





4717












4718



  if (pInfo->mSkipTables == NULL) {




3,516,484✔





4719



    pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1,




245,338✔





4720



                                      taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);










4721



    QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, terrno);




245,338✔





4722



  }










4723



  int bSkip = 1;




3,516,484✔





4724



  if (pInfo->mSkipTables != NULL) {




3,516,484✔





4725



    code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));




3,516,484✔





4726



    if (code == TSDB_CODE_DUP_KEY) {




3,516,484✔





4727



      code = TSDB_CODE_SUCCESS;




×







4728



    }










4729



    QUERY_CHECK_CODE(code, lino, _end);




3,516,484✔





4730



  }










4731












4732



_end:




3,516,484✔





4733



  if (code != TSDB_CODE_SUCCESS) {




3,516,484✔





4734



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4735



    pTaskInfo->code = code;




×







4736



    T_LONG_JMP(pTaskInfo->env, code);




×







4737



  }










4738



}




3,516,484✔





4739












4740



static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) {




168,941,321✔





4741



  STableMergeScanInfo* pInfo = pOperator->info;




168,941,321✔





4742



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




168,945,892✔





4743



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




168,943,545✔





4744



  SSDataBlock*         pBlock = pInfo->pReaderBlock;




168,923,048✔





4745



  int32_t              code = 0;




168,937,596✔





4746



  bool                 hasNext = false;




168,937,596✔





4747



  STsdbReader*         reader = pInfo->base.dataReader;




168,933,991✔





4748












4749



  code = pAPI->tsdReader.tsdNextDataBlock(reader, &hasNext);




168,935,687✔





4750



  if (code != 0) {




168,910,181✔





4751



    pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4752



    qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo));




×







4753



    pTaskInfo->code = code;




×







4754



    return code;




×







4755



  }










4756












4757



  if (!hasNext || isTaskKilled(pTaskInfo)) {




168,910,181✔





4758



    if (isTaskKilled(pTaskInfo)) {




27,516,488✔





4759



      qInfo("table merge scan fetch next data block found task killed. %s", GET_TASKID(pTaskInfo));




×







4760



      pAPI->tsdReader.tsdReaderReleaseDataBlock(reader);




×







4761



    }










4762



    *pFinished = true;




27,513,352✔





4763



    return code;




27,509,135✔





4764



  }










4765












4766



  uint32_t status = 0;




141,400,680✔





4767



  code = loadDataBlock(pOperator, &pInfo->base, pBlock, &status);




141,404,530✔





4768












4769



  if (code != TSDB_CODE_SUCCESS) {




141,394,797✔





4770



    qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo));




16,896✔





4771



    pTaskInfo->code = code;




16,896✔





4772



    return code;




16,896✔





4773



  }










4774












4775



  if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {




141,377,901✔





4776



    *pFinished = true;




×







4777



    return code;




×







4778



  }










4779












4780



  // current block is filter out according to filter condition, continue load the next block










4781



  if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {




141,377,901✔





4782



    *pSkipped = true;




7,330,907✔





4783



    return code;




7,327,347✔





4784



  }










4785












4786



  return code;




134,037,930✔





4787



}










4788












4789



static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) {




169,943,029✔





4790



  STableMergeScanSortSourceParam* source = param;




169,943,029✔





4791












4792



  SOperatorInfo*       pOperator = source->pOperator;




169,943,029✔





4793



  STableMergeScanInfo* pInfo = pOperator->info;




169,942,103✔





4794



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




169,933,482✔





4795



  SSDataBlock*         pBlock = NULL;




169,953,575✔





4796



  int64_t              st = taosGetTimestampUs();




169,935,462✔





4797



  int32_t              code = TSDB_CODE_SUCCESS;




169,935,462✔





4798












4799



  while (true) {










4800



    if (pInfo->rtnNextDurationBlocks) {




184,805,814✔





4801



      qDebug("%s table merge scan return already fetched new duration blocks. index %d num of blocks %d",




15,880,469✔





4802



             GET_TASKID(pTaskInfo), pInfo->nextDurationBlocksIdx, pInfo->numNextDurationBlocks);










4803












4804



      if (pInfo->nextDurationBlocksIdx < pInfo->numNextDurationBlocks) {




15,886,159✔





4805



        pBlock = pInfo->nextDurationBlocks[pInfo->nextDurationBlocksIdx];




7,551,026✔





4806



        ++pInfo->nextDurationBlocksIdx;




7,551,026✔





4807



      } else {










4808



        for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




15,880,609✔





4809



          blockDataDestroy(pInfo->nextDurationBlocks[i]);




7,549,964✔





4810



          pInfo->nextDurationBlocks[i] = NULL;




7,546,745✔





4811



        }










4812












4813



        pInfo->rtnNextDurationBlocks = false;




8,330,645✔





4814



        pInfo->nextDurationBlocksIdx = 0;




8,331,540✔





4815



        pInfo->numNextDurationBlocks = 0;




8,331,393✔





4816



        continue;




8,329,149✔





4817



      }










4818



    } else {










4819



      bool bFinished = false;




168,924,268✔





4820



      bool bSkipped = false;




168,937,919✔





4821












4822



      code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped);




168,938,794✔





4823



      if (code != 0) {




168,901,097✔





4824



        return code;




16,896✔





4825



      }










4826












4827



      pBlock = pInfo->pReaderBlock;




168,884,201✔





4828



      qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d",




168,910,665✔





4829



             GET_TASKID(pTaskInfo), bFinished, bSkipped, pInfo->bNextDurationBlockEvent, pInfo->bNewFilesetEvent);










4830



      if (bFinished) {




168,939,727✔





4831



        pInfo->bNewFilesetEvent = false;




27,525,033✔





4832



        break;




27,523,029✔





4833



      }










4834












4835



      if (pInfo->bNextDurationBlockEvent || pInfo->bNewFilesetEvent) {




141,414,694✔





4836



        if (!bSkipped) {




8,335,146✔





4837



          code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]);




7,551,026✔





4838



          if (code) {




7,543,546✔





4839



            *ppBlock = NULL;




×







4840



            return code;




×







4841



          }










4842












4843



          ++pInfo->numNextDurationBlocks;




7,543,546✔





4844



          if (pInfo->numNextDurationBlocks > 2) {




7,542,798✔





4845



            qError("%s table merge scan prefetch %d next duration blocks. end early.", GET_TASKID(pTaskInfo),




×







4846



                   pInfo->numNextDurationBlocks);










4847



            pInfo->bNewFilesetEvent = false;




×







4848



            break;




×







4849



          }










4850



        }










4851












4852



        if (pInfo->bNewFilesetEvent) {




8,327,065✔





4853



          pInfo->rtnNextDurationBlocks = true;




8,331,560✔





4854



          *ppBlock = NULL;




8,327,820✔





4855



          return code;




8,323,706✔





4856



        }










4857












4858



        if (pInfo->bNextDurationBlockEvent) {




×







4859



          pInfo->bNextDurationBlockEvent = false;




×







4860



          continue;




×







4861



        }










4862



      }










4863



      if (bSkipped) continue;




133,081,360✔





4864



    }










4865












4866



    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);




134,089,660✔





4867












4868



    pOperator->resultInfo.totalRows += pBlock->info.rows;




134,088,019✔





4869



    pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;




134,080,710✔





4870



    *ppBlock = pBlock;




134,080,826✔





4871












4872



    return code;




134,080,069✔





4873



  }










4874












4875



  *ppBlock = NULL;




27,523,048✔





4876



  return code;




27,524,050✔





4877



}










4878












4879



int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) {




23,871,098✔





4880



  int32_t code = TSDB_CODE_SUCCESS;




23,871,098✔





4881



  int32_t lino = 0;




23,871,098✔





4882



  SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo));




23,871,098✔





4883



  QUERY_CHECK_NULL(pSortInfo, code, lino, _end, terrno);




23,838,177✔





4884



  SBlockOrderInfo biTs = {0};




23,838,177✔





4885



  SBlockOrderInfo biPk = {0};




23,834,740✔





4886












4887



  int32_t tsTargetSlotId = 0;




23,854,915✔





4888



  int32_t pkTargetSlotId = -1;




23,854,915✔





4889



  for (int32_t i = 0; i < taosArrayGetSize(colMatchInfo); ++i) {




86,693,406✔





4890



    SColMatchItem* colInfo = taosArrayGet(colMatchInfo, i);




62,868,485✔





4891



    QUERY_CHECK_NULL(colInfo, code, lino, _end, terrno);




62,874,377✔





4892



    if (colInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {




62,874,377✔





4893



      tsTargetSlotId = colInfo->dstSlotId;




23,873,926✔





4894



      biTs.order = order;




23,869,161✔





4895



      biTs.slotId = tsTargetSlotId;




23,869,161✔





4896



      biTs.nullFirst = (order == TSDB_ORDER_ASC);




23,869,161✔





4897



      biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order);




23,869,161✔





4898



    }










4899



    // TODO: order by just ts










4900



    if (colInfo->isPk) {




62,856,258✔





4901



      pkTargetSlotId = colInfo->dstSlotId;




1,580,971✔





4902



      biPk.order = order;




1,580,971✔





4903



      biPk.slotId = pkTargetSlotId;




1,580,971✔





4904



      biPk.nullFirst = (order == TSDB_ORDER_ASC);




1,580,971✔





4905



      biPk.compFn = getKeyComparFunc(colInfo->dataType.type, order);




1,580,971✔





4906



    }










4907



  }










4908












4909



  void* tmp = taosArrayPush(pSortInfo, &biTs);




23,885,947✔





4910



  QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




23,885,947✔





4911



  if (pkTargetSlotId != -1) {




23,885,947✔





4912



    tmp = taosArrayPush(pSortInfo, &biPk);




1,580,338✔





4913



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




1,580,338✔





4914



  }










4915












4916



  (*ppSortArray) = pSortInfo;




23,885,915✔





4917












4918



_end:




23,857,092✔





4919



  if (code != TSDB_CODE_SUCCESS) {




23,860,892✔





4920



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







4921



  }










4922



  return code;




23,860,892✔





4923



}










4924












4925



void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) {




29,454,019✔





4926



  STableMergeScanInfo* pTmsInfo = param;




29,454,019✔





4927



  if (type == TSD_READER_NOTIFY_DURATION_START) {




29,454,019✔





4928



    pTmsInfo->bNewFilesetEvent = true;




29,476,176✔





4929



  } else if (type == TSD_READER_NOTIFY_NEXT_DURATION_BLOCK) {




×







4930



    pTmsInfo->bNextDurationBlockEvent = true;




×







4931



  }










4932



  qDebug("table merge scan receive notification. type %d, fileset %d", type, info->duration.filesetId);




29,448,662✔





4933












4934



  return;




29,498,106✔





4935



}










4936












4937



int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




36,079,321✔





4938



  STableMergeScanInfo* pInfo = pOperator->info;




36,079,321✔





4939



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




36,083,172✔





4940












4941



  int32_t code = TSDB_CODE_SUCCESS;




36,078,930✔





4942



  int32_t lino = 0;




36,078,930✔





4943



  int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1;




36,078,930✔





4944












4945



  qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo));




36,074,176✔





4946



  pInfo->bNewFilesetEvent = false;




36,111,055✔





4947



  pInfo->bNextDurationBlockEvent = false;




36,098,986✔





4948












4949



  pInfo->sortBufSize = 2048 * pInfo->bufPageSize;




36,096,000✔





4950



  int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize;




36,093,475✔





4951












4952



  pInfo->pSortHandle = NULL;




36,091,019✔





4953



  code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage,




72,181,654✔





4954



                               pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0, &pInfo->pSortHandle);




36,090,964✔





4955



  if (code) {




36,055,871✔





4956



    return code;




×







4957



  }










4958












4959



  if (pInfo->bSortRowId && numOfTable != 1) {




36,055,871✔





4960



    int32_t memSize = 512 * 1024 * 1024;




3,121,197✔





4961



    code = tsortSetSortByRowId(pInfo->pSortHandle, memSize);




3,121,197✔





4962



    QUERY_CHECK_CODE(code, lino, _end);




3,126,850✔





4963



  }










4964












4965



  tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit);




36,065,527✔





4966



  tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator);




36,070,850✔





4967



  tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo);




36,044,372✔





4968












4969



  tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL);




36,047,353✔





4970



  QUERY_CHECK_CODE(code, lino, _end);




36,043,469✔





4971












4972



  STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam));




36,043,469✔





4973



  QUERY_CHECK_NULL(param, code, lino, _end, terrno);




36,057,505✔





4974



  param->pOperator = pOperator;




36,057,505✔





4975












4976



  SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource));




36,056,720✔





4977



  if (ps == NULL) {




36,050,341✔





4978



    taosMemoryFree(param);




×







4979



    QUERY_CHECK_NULL(ps, code, lino, _end, terrno);




×







4980



  }










4981












4982



  ps->param = param;




36,050,341✔





4983



  ps->onlyRef = false;




36,068,663✔





4984



  code = tsortAddSource(pInfo->pSortHandle, ps);




36,067,556✔





4985



  QUERY_CHECK_CODE(code, lino, _end);




36,080,167✔





4986












4987



  if (numOfTable == 1) {




36,080,167✔





4988



    tsortSetSingleTableMerge(pInfo->pSortHandle);




24,695,998✔





4989



  } else {










4990



    code = tsortOpen(pInfo->pSortHandle);




11,384,169✔





4991



    QUERY_CHECK_CODE(code, lino, _end);




11,384,224✔





4992



  }










4993












4994



_end:




11,375,776✔





4995



  if (code != TSDB_CODE_SUCCESS) {




36,086,343✔





4996



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




8,448✔





4997



  }










4998



  return code;




36,082,211✔





4999



}










5000












5001



void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) {




36,063,832✔





5002



  STableMergeScanInfo* pInfo = pOperator->info;




36,063,832✔





5003



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




36,062,456✔





5004



  qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo));




36,062,574✔





5005












5006



  SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle);




36,063,202✔





5007



  pInfo->sortExecInfo.sortMethod = sortExecInfo.sortMethod;




36,059,301✔





5008



  pInfo->sortExecInfo.sortBuffer = sortExecInfo.sortBuffer;




36,062,062✔





5009



  pInfo->sortExecInfo.loops += sortExecInfo.loops;




36,058,553✔





5010



  pInfo->sortExecInfo.readBytes += sortExecInfo.readBytes;




36,056,044✔





5011



  pInfo->sortExecInfo.writeBytes += sortExecInfo.writeBytes;




36,058,406✔





5012












5013



  tsortDestroySortHandle(pInfo->pSortHandle);




36,052,807✔





5014



  pInfo->pSortHandle = NULL;




36,055,418✔





5015



}




36,056,166✔





5016












5017



void startGroupTableMergeScan(SOperatorInfo* pOperator) {




27,751,152✔





5018



  int32_t              code = TSDB_CODE_SUCCESS;




27,751,152✔





5019



  int32_t              lino = 0;




27,751,152✔





5020



  STableMergeScanInfo* pInfo = pOperator->info;




27,751,152✔





5021



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




27,750,259✔





5022



  SReadHandle*         pHandle = &pInfo->base.readHandle;




27,753,757✔





5023



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




27,748,089✔





5024



  qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




27,742,491✔





5025












5026



  {










5027



    int32_t numOfTables = 0;




27,751,767✔





5028



    code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);




27,755,797✔





5029



    QUERY_CHECK_CODE(code, lino, _end);




27,731,467✔





5030












5031



    int32_t i = pInfo->tableStartIndex + 1;




27,731,467✔





5032



    for (; i < numOfTables; ++i) {




135,697,838✔





5033



      STableKeyInfo* tableKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i);




114,268,005✔





5034



      QUERY_CHECK_NULL(tableKeyInfo, code, lino, _end, terrno);




114,267,041✔





5035



      if (tableKeyInfo->groupId != pInfo->groupId) {




114,267,041✔





5036



        break;




6,295,159✔





5037



      }










5038



    }










5039



    pInfo->tableEndIndex = i - 1;




27,724,992✔





5040



  }










5041



  pInfo->bGroupProcessed = false;




27,762,310✔





5042



  int32_t tableStartIdx = pInfo->tableStartIndex;




27,761,790✔





5043



  int32_t tableEndIdx = pInfo->tableEndIndex;




27,757,395✔





5044












5045



  int32_t        numOfTable = tableEndIdx - tableStartIdx + 1;




27,757,338✔





5046



  STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx);




27,757,338✔





5047



  code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock,




55,503,145✔





5048



                                       (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables);




27,743,803✔





5049



  QUERY_CHECK_CODE(code, lino, _end);




27,737,314✔





5050



  if (pInfo->filesetDelimited) {




27,737,314✔





5051



    pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);




27,741,513✔





5052



  }










5053



  pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo);




27,752,059✔





5054












5055



  code = startDurationForGroupTableMergeScan(pOperator);




27,723,828✔





5056



  QUERY_CHECK_CODE(code, lino, _end);




27,763,777✔





5057












5058



_end:




27,755,329✔





5059



  if (code != TSDB_CODE_SUCCESS) {




27,757,397✔





5060



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




8,448✔





5061



    pTaskInfo->code = code;




8,448✔





5062



    T_LONG_JMP(pTaskInfo->env, code);




8,448✔





5063



  }










5064



}




27,748,949✔





5065












5066



void stopGroupTableMergeScan(SOperatorInfo* pOperator) {




27,728,029✔





5067



  STableMergeScanInfo* pInfo = pOperator->info;




27,728,029✔





5068



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




27,729,033✔





5069



  SStorageAPI*         pAPI = &pTaskInfo->storageAPI;




27,728,532✔





5070












5071



  stopDurationForGroupTableMergeScan(pOperator);




27,727,530✔





5072












5073



  if (pInfo->base.dataReader != NULL) {




27,721,851✔





5074



    pAPI->tsdReader.tsdReaderClose(pInfo->base.dataReader);




27,725,908✔





5075



    pInfo->base.dataReader = NULL;




27,678,348✔





5076



  }










5077



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




27,690,646✔





5078



    if (pInfo->nextDurationBlocks[i]) {




1,062✔





5079



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




1,062✔





5080



      pInfo->nextDurationBlocks[i] = NULL;




1,062✔





5081



    }










5082



    pInfo->numNextDurationBlocks = 0;




1,062✔





5083



    pInfo->nextDurationBlocksIdx = 0;




1,062✔





5084



  }










5085



  resetLimitInfoForNextGroup(&pInfo->limitInfo);




27,706,045✔





5086



  taosHashCleanup(pInfo->mSkipTables);




27,677,662✔





5087



  pInfo->mSkipTables = NULL;




27,688,885✔





5088



  qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId);




27,697,274✔





5089



}




27,715,402✔





5090












5091



// all data produced by this function only belongs to one group










5092



// slimit/soffset does not need to be concerned here, since this function only deal with data within one group.










5093



SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* pResBlock, int32_t capacity,




75,541,167✔





5094



                                              SOperatorInfo* pOperator) {










5095



  STableMergeScanInfo* pInfo = pOperator->info;




75,541,167✔





5096



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




75,544,667✔





5097



  STupleHandle*        pTupleHandle = NULL;




75,548,062✔





5098












5099



  blockDataCleanup(pResBlock);




75,536,068✔





5100












5101



  while (1) {




×







5102



    while (1) {




2,147,483,647✔





5103



      pTupleHandle = NULL;




2,147,483,647✔





5104



      int32_t code = tsortNextTuple(pHandle, &pTupleHandle);




2,147,483,647✔





5105



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5106



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




4,797,604✔





5107



        T_LONG_JMP(pOperator->pTaskInfo->env, code);




4,797,604✔





5108



      }










5109



      if (pTupleHandle == NULL) {




2,147,483,647✔





5110



        break;




58,888,114✔





5111



      }










5112












5113



      code = tsortAppendTupleToBlock(pInfo->pSortHandle, pResBlock, pTupleHandle);




2,147,483,647✔





5114



      if (code != TSDB_CODE_SUCCESS) {




2,147,483,647✔





5115



        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));




×







5116



        T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5117



      }










5118












5119



      if (pResBlock->info.rows >= capacity) {




2,147,483,647✔





5120



        break;




16,657,498✔





5121



      }










5122



    }










5123












5124



    if (tsortIsClosed(pHandle)) {




75,545,612✔





5125



      terrno = TSDB_CODE_TSC_QUERY_CANCELLED;




×







5126



      T_LONG_JMP(pOperator->pTaskInfo->env, terrno);




×







5127



    }










5128












5129



    bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo);




75,549,038✔





5130



    qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows,




75,550,609✔





5131



           pInfo->limitInfo.numOfOutputRows);










5132



    if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) {




75,556,529✔





5133



      break;










5134



    }










5135



  }










5136



  return (pResBlock->info.rows > 0) ? pResBlock : NULL;




75,556,529✔





5137



}










5138












5139



int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




63,839,940✔





5140



  if (pOperator->status == OP_EXEC_DONE) {




63,839,940✔





5141



    (*ppRes) = NULL;




42,343✔





5142



    return TSDB_CODE_SUCCESS;




42,343✔





5143



  }










5144












5145



  int32_t              code = TSDB_CODE_SUCCESS;




63,777,536✔





5146



  int32_t              lino = 0;




63,777,536✔





5147



  SExecTaskInfo*       pTaskInfo = pOperator->pTaskInfo;




63,777,536✔





5148



  STableMergeScanInfo* pInfo = pOperator->info;




63,792,054✔





5149












5150



  code = pOperator->fpSet._openFn(pOperator);




63,798,447✔





5151



  QUERY_CHECK_CODE(code, lino, _end);




63,771,511✔





5152












5153



  int64_t st = taosGetTimestampUs();




63,780,873✔





5154












5155



  int32_t tableListSize = 0;




63,780,873✔





5156



  code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize);




63,783,906✔





5157



  QUERY_CHECK_CODE(code, lino, _end);




63,787,818✔





5158












5159



  if (!pInfo->hasGroupId) {




63,787,818✔





5160



    pInfo->hasGroupId = true;




24,316,382✔





5161












5162



    if (tableListSize == 0) {




24,303,337✔





5163



      setOperatorCompleted(pOperator);




2,860,423✔





5164



      (*ppRes) = NULL;




2,859,567✔





5165



      return code;




2,859,567✔





5166



    }










5167



    pInfo->tableStartIndex = 0;




21,442,914✔





5168



    STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




21,447,877✔





5169



    QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




21,438,054✔





5170



    pInfo->groupId = tmp->groupId;




21,438,054✔





5171



    startGroupTableMergeScan(pOperator);




21,444,415✔





5172



  }










5173












5174



  SSDataBlock* pBlock = NULL;




60,919,457✔





5175



  while (pInfo->tableStartIndex < tableListSize) {




75,543,024✔





5176



    if (isTaskKilled(pTaskInfo)) {




75,552,286✔





5177



      goto _end;




13,425✔





5178



    }










5179












5180



    pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity,




75,537,307✔





5181



                                              pOperator);










5182



    if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) {




75,556,629✔





5183



      STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




1,832,253✔





5184



      QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno);




1,832,253✔





5185



      pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo);




1,832,253✔





5186



    }










5187



    if (pBlock != NULL) {




75,556,638✔





5188



      pBlock->info.id.groupId = pInfo->groupId;




39,493,307✔





5189



      pOperator->resultInfo.totalRows += pBlock->info.rows;




39,493,307✔





5190



      pInfo->bGroupProcessed = true;




39,492,924✔





5191



      break;




39,493,307✔





5192



    } else {










5193



      if (pInfo->bNewFilesetEvent) {




36,063,331✔





5194



        stopDurationForGroupTableMergeScan(pOperator);




8,335,674✔





5195



        code = startDurationForGroupTableMergeScan(pOperator);




8,333,056✔





5196



        QUERY_CHECK_CODE(code, lino, _end);




8,328,408✔





5197



      } else {










5198



        // Data of this group are all dumped, let's try the next group










5199



        stopGroupTableMergeScan(pOperator);




27,728,158✔





5200



        if (pInfo->tableEndIndex >= tableListSize - 1) {




27,724,055✔





5201



          setOperatorCompleted(pOperator);




21,428,959✔





5202



          break;




21,427,938✔





5203



        }










5204












5205



        pInfo->tableStartIndex = pInfo->tableEndIndex + 1;




6,295,159✔





5206



        STableKeyInfo* tmp = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex);




6,295,159✔





5207



        QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);




6,295,159✔





5208



        pInfo->groupId = tmp->groupId;




6,295,159✔





5209



        startGroupTableMergeScan(pOperator);




6,295,159✔





5210



        resetLimitInfoForNextGroup(&pInfo->limitInfo);




6,294,647✔





5211



      }










5212



    }










5213



  }










5214












5215



  pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;




60,918,551✔





5216












5217



_end:




60,931,219✔





5218



  if (code != TSDB_CODE_SUCCESS) {




60,931,602✔





5219



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5220



    pTaskInfo->code = code;




×







5221



    T_LONG_JMP(pTaskInfo->env, code);




×







5222



  } else {










5223



    (*ppRes) = pBlock;




60,931,602✔





5224



  }










5225












5226



  return code;




60,932,244✔





5227



}










5228












5229



static SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {




×







5230



  SSDataBlock* pRes = NULL;




×







5231



  int32_t      code = doTableMergeScanNext(pOperator, &pRes);




×







5232



  return pRes;




×







5233



}










5234












5235



void destroyTableMergeScanOperatorInfo(void* param) {




23,891,855✔





5236



  STableMergeScanInfo* pTableScanInfo = (STableMergeScanInfo*)param;




23,891,855✔





5237












5238



  // start one reader variable










5239



  if (pTableScanInfo->base.readerAPI.tsdReaderClose != NULL) {




23,891,855✔





5240



    pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader);




23,893,077✔





5241



    pTableScanInfo->base.dataReader = NULL;




23,889,363✔





5242



  }










5243












5244



  for (int32_t i = 0; i < pTableScanInfo->numNextDurationBlocks; ++i) {




23,891,405✔





5245



    if (pTableScanInfo->nextDurationBlocks[i] != NULL) {




×







5246



      blockDataDestroy(pTableScanInfo->nextDurationBlocks[i]);




×







5247



      pTableScanInfo->nextDurationBlocks[i] = NULL;




×







5248



    }










5249



  }










5250












5251



  tsortDestroySortHandle(pTableScanInfo->pSortHandle);




23,891,004✔





5252



  pTableScanInfo->pSortHandle = NULL;




23,888,430✔





5253



  taosHashCleanup(pTableScanInfo->mSkipTables);




23,888,430✔





5254



  pTableScanInfo->mSkipTables = NULL;




23,889,588✔





5255



  blockDataDestroy(pTableScanInfo->pSortInputBlock);




23,890,939✔





5256



  pTableScanInfo->pSortInputBlock = NULL;




23,881,517✔





5257



  // end one reader variable










5258












5259



  destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI);




23,881,891✔





5260












5261



  blockDataDestroy(pTableScanInfo->pResBlock);




23,886,370✔





5262



  pTableScanInfo->pResBlock = NULL;




23,886,691✔





5263












5264



  // remove it from the task->result list










5265



  blockDataDestroy(pTableScanInfo->pReaderBlock);




23,884,813✔





5266



  pTableScanInfo->pReaderBlock = NULL;




23,888,232✔





5267



  taosArrayDestroy(pTableScanInfo->pSortInfo);




23,888,232✔





5268












5269



  stopSubTablesTableMergeScan(pTableScanInfo);




23,882,506✔





5270












5271



  taosMemoryFreeClear(param);




23,881,966✔





5272



}




23,875,582✔





5273












5274



int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {




1,229,297✔





5275



  if (pOptr == NULL) {




1,229,297✔





5276



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_INVALID_PARA));




×







5277



    return TSDB_CODE_INVALID_PARA;




×







5278



  }










5279



  // TODO: merge these two info into one struct










5280



  STableMergeScanExecInfo* execInfo = taosMemoryCalloc(1, sizeof(STableMergeScanExecInfo));




1,229,297✔





5281



  if (!execInfo) {




1,227,792✔





5282



    return terrno;




×







5283



  }










5284



  STableMergeScanInfo* pInfo = pOptr->info;




1,227,792✔





5285



  execInfo->blockRecorder = pInfo->base.readRecorder;




1,229,297✔





5286



  execInfo->sortExecInfo = pInfo->sortExecInfo;




1,228,540✔





5287












5288



  *pOptrExplain = execInfo;




1,228,914✔





5289



  *len = sizeof(STableMergeScanExecInfo);




1,229,297✔





5290












5291



  return TSDB_CODE_SUCCESS;




1,228,923✔





5292



}










5293












5294



static int32_t resetTableMergeScanOperatorState(SOperatorInfo* pOper) {




2,324,362✔





5295



  int32_t         code = TSDB_CODE_SUCCESS;




2,324,362✔





5296



  STableMergeScanInfo*   pInfo = pOper->info;




2,324,362✔





5297



  pOper->status = OP_NOT_OPENED;




2,324,362✔





5298












5299



  pInfo->tableEndIndex = 0;




2,324,362✔





5300



  pInfo->tableStartIndex = 0;




2,324,362✔





5301



  pInfo->hasGroupId = false;




2,324,362✔





5302



  if (pInfo->base.readerAPI.tsdReaderClose) {




2,324,362✔





5303



    pInfo->base.readerAPI.tsdReaderClose(pInfo->base.dataReader);




2,324,362✔





5304



  }










5305



  pInfo->base.dataReader = NULL;




2,324,362✔





5306



  pInfo->base.scanFlag = MAIN_SCAN;




2,324,362✔





5307












5308



  pInfo->base.limitInfo = (SLimitInfo){0};




2,324,362✔





5309



  pInfo->base.limitInfo.limit.limit = -1;




2,324,362✔





5310



  pInfo->base.limitInfo.slimit.limit = -1;




2,324,362✔





5311












5312



  tableListDestroy(pInfo->base.pTableListInfo);




2,324,362✔





5313



  pInfo->base.pTableListInfo = tableListCreate();




2,324,362✔





5314



  if (!pInfo->base.pTableListInfo) {




2,324,362✔





5315



    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));




×







5316



    return terrno;




×







5317



  }










5318



  SExecTaskInfo*         pTaskInfo = pOper->pTaskInfo;




2,324,362✔





5319












5320



  STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pTaskInfo->pSubplan->pNode;




2,324,362✔





5321



  code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort,




4,648,724✔





5322



                                  &pInfo->base.readHandle, pInfo->base.pTableListInfo, 










5323



                                  pTaskInfo->pSubplan->pTagCond, pTaskInfo->pSubplan->pTagIndexCond, pTaskInfo, NULL);




4,648,724✔





5324



  if (code) {




2,324,362✔





5325



    qError("%s failed to createScanTableListInfo, code:%s", __func__, tstrerror(code));




×







5326



    return code;




×







5327



  }










5328












5329



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




2,324,362✔





5330



  cleanupQueryTableDataCond(&pInfo->base.cond);




2,324,362✔





5331



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, &pInfo->base.readHandle, false);




2,324,362✔





5332



  if (code) {




2,324,362✔





5333



    qError("%s failed to initQueryTableDataCond, code:%s", __func__, tstrerror(code));




×







5334



    return code;




×







5335



  }










5336












5337



  tsortDestroySortHandle(pInfo->pSortHandle);




2,324,362✔





5338



  pInfo->pSortHandle = NULL;




2,324,362✔





5339












5340



  taosHashCleanup(pInfo->mSkipTables);




2,324,362✔





5341



  pInfo->mSkipTables = NULL;




2,324,362✔





5342



  pOper->resultInfo.totalRows = 0;




2,324,362✔





5343



  










5344



  pInfo->bGroupProcessed = false;




2,324,362✔





5345



  pInfo->bNewFilesetEvent = false;




2,324,362✔





5346



  pInfo->bNextDurationBlockEvent = false;




2,324,362✔





5347



  pInfo->rtnNextDurationBlocks = false;




2,324,362✔





5348



  pInfo->nextDurationBlocksIdx = 0;




2,324,362✔





5349



  pInfo->bSortRowId = false;




2,324,362✔





5350












5351



  for (int32_t i = 0; i < pInfo->numNextDurationBlocks; ++i) {




2,324,362✔





5352



    if (pInfo->nextDurationBlocks[i] != NULL) {




×







5353



      blockDataDestroy(pInfo->nextDurationBlocks[i]);




×







5354



      pInfo->nextDurationBlocks[i] = NULL;




×







5355



    }










5356



  }










5357



  pInfo->numNextDurationBlocks = 0;




2,324,362✔





5358












5359



  stopSubTablesTableMergeScan(pInfo);




2,324,362✔





5360



  return code;




2,324,362✔





5361



}










5362












5363



int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle,




23,853,188✔





5364



                                         STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo,










5365



                                         SOperatorInfo** pOptrInfo) {










5366



  QRY_PARAM_CHECK(pOptrInfo);




23,853,188✔





5367












5368



  int32_t              code = TSDB_CODE_SUCCESS;




23,864,103✔





5369



  int32_t              lino = 0;




23,864,103✔





5370



  STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo));




23,864,103✔





5371



  SOperatorInfo*       pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




23,824,070✔





5372



  if (pInfo == NULL || pOperator == NULL) {




23,795,318✔





5373



    code = terrno;




3✔





5374



    goto _error;




×







5375



  }










5376












5377



  pOperator->pPhyNode = pTableScanNode;




23,796,171✔





5378



  SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc;




23,797,510✔





5379












5380



  int32_t numOfCols = 0;




23,830,312✔





5381



  code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID,




23,843,494✔





5382



                             &pInfo->base.matchInfo);










5383



  QUERY_CHECK_CODE(code, lino, _error);




23,803,447✔





5384












5385



  code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle, false);




23,803,447✔





5386



  QUERY_CHECK_CODE(code, lino, _error);




23,794,377✔





5387












5388



  if (pTableScanNode->scan.pScanPseudoCols != NULL) {




23,794,377✔





5389



    SExprSupp* pSup = &pInfo->base.pseudoSup;




10,246,945✔





5390



    code = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->pExprInfo, &pSup->numOfExprs);




10,262,783✔





5391



    QUERY_CHECK_CODE(code, lino, _error);




10,245,724✔





5392












5393



    pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset,




10,245,724✔





5394



                                      &pTaskInfo->storageAPI.functionStore);










5395



    QUERY_CHECK_NULL(pSup->pCtx, code, lino, _error, terrno);




10,257,572✔





5396



  }










5397












5398



  pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]};




23,792,481✔





5399












5400



  if (tsMetaEntryCache && readHandle->streamRtInfo == NULL) {




23,757,624✔





5401



    pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(tsMetaEntryCacheSize, -1, .5);




×







5402



    QUERY_CHECK_NULL(pInfo->base.metaCache.pTableMetaEntryCache, code, lino, _error, terrno);




×







5403



  }










5404












5405



  pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader;




23,757,624✔





5406



  pInfo->base.dataBlockLoadFlag = FUNC_DATA_REQUIRED_DATA_LOAD;




23,839,554✔





5407



  pInfo->base.scanFlag = MAIN_SCAN;




23,814,668✔





5408



  pInfo->base.readHandle = *readHandle;




23,732,895✔





5409












5410



  pInfo->readIdx = -1;




23,789,155✔





5411












5412



  pInfo->base.limitInfo.limit.limit = -1;




23,713,085✔





5413



  pInfo->base.limitInfo.slimit.limit = -1;




23,843,648✔





5414



  pInfo->base.pTableListInfo = pTableListInfo;




23,819,759✔





5415












5416



  pInfo->sample.sampleRatio = pTableScanNode->ratio;




23,782,905✔





5417



  pInfo->sample.seed = taosGetTimestampSec();




23,844,718✔





5418












5419



  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0,




23,821,623✔





5420



                            pTaskInfo->pStreamRuntimeInfo);




23,820,714✔





5421



  QUERY_CHECK_CODE(code, lino, _error);




23,783,736✔





5422












5423



  initLimitInfo(pTableScanNode->scan.node.pLimit, pTableScanNode->scan.node.pSlimit, &pInfo->limitInfo);




23,783,736✔





5424












5425



  pInfo->mergeLimit = -1;




23,773,685✔





5426



  bool hasLimit = pInfo->limitInfo.limit.limit != -1 || pInfo->limitInfo.limit.offset != -1;




23,780,436✔





5427



  if (hasLimit) {




23,841,924✔





5428



    pInfo->mergeLimit = pInfo->limitInfo.limit.offset != -1




3,730,881✔





5429



                            ? pInfo->limitInfo.limit.limit + pInfo->limitInfo.limit.offset




770,906✔





5430



                            : pInfo->limitInfo.limit.limit;




2,634,773✔





5431



    pInfo->mSkipTables = NULL;




1,864,901✔





5432



  }










5433












5434



  initResultSizeInfo(&pOperator->resultInfo, 1024);




23,842,285✔





5435



  pInfo->pResBlock = createDataBlockFromDescNode(pDescNode);




23,829,435✔





5436



  QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, terrno);




23,841,558✔





5437



  code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);




23,775,965✔





5438



  QUERY_CHECK_CODE(code, lino, _error);




23,882,429✔





5439



  if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) {




23,882,429✔





5440



    pInfo->bSortRowId = true;




4,882,811✔





5441



  } else {










5442



    pInfo->bSortRowId = false;




18,997,715✔





5443



  }










5444












5445



  code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo);




23,854,334✔





5446



  QUERY_CHECK_CODE(code, lino, _error);




23,883,009✔





5447












5448



  code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo);




23,883,009✔





5449



  QUERY_CHECK_CODE(code, lino, _error);




23,844,780✔





5450












5451



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pReaderBlock);




23,844,780✔





5452



  QUERY_CHECK_CODE(code, lino, _error);




23,864,352✔





5453












5454



  pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable;




23,864,352✔





5455












5456



  int32_t  rowSize = pInfo->pResBlock->info.rowSize;




23,864,284✔





5457



  uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock);




23,847,642✔





5458












5459



  pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols);




23,857,111✔





5460












5461



  // start one reader variable










5462



  code = createOneDataBlock(pInfo->pResBlock, false, &pInfo->pSortInputBlock);




23,873,794✔





5463



  QUERY_CHECK_CODE(code, lino, _error);




23,867,011✔





5464












5465



  if (!tsExperimental) {




23,867,011✔





5466



    pInfo->filesetDelimited = false;




×







5467



  } else {










5468



    pInfo->filesetDelimited = pTableScanNode->filesetDelimited;




23,867,011✔





5469



  }










5470



  // end one reader variable










5471



  setOperatorInfo(pOperator, "TableMergeScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN, false, OP_NOT_OPENED,




23,877,161✔





5472



                  pInfo, pTaskInfo);










5473



  pOperator->exprSupp.numOfExprs = numOfCols;




23,822,004✔





5474












5475



  pOperator->fpSet = createOperatorFpSet(




23,858,827✔





5476



      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,




23,843,826✔





5477



      destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn,










5478



      NULL);










5479



  setOperatorResetStateFn(pOperator, resetTableMergeScanOperatorState);     




23,832,942✔





5480



  pOperator->cost.openCost = 0;




23,830,959✔





5481












5482



  *pOptrInfo = pOperator;




23,830,364✔





5483



  return code;




23,806,679✔





5484












5485



_error:




×







5486



  if (code != TSDB_CODE_SUCCESS) {




×







5487



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5488



  }










5489



  pTaskInfo->code = code;




×







5490



  if (pInfo != NULL) {




×







5491



    pInfo->base.pTableListInfo = NULL;




×







5492



    destroyTableMergeScanOperatorInfo(pInfo);




×







5493



  }










5494



  if (pOperator != NULL) {




×







5495



    pOperator->info = NULL;




×







5496



    destroyOperator(pOperator);




×







5497



  }










5498



  return code;




×







5499



}










5500












5501



// ====================================================================================================================










5502



// TableCountScanOperator










5503



static void        destoryTableCountScanOperator(void* param);










5504



static int32_t     buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5505



                                                  SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI);










5506



static int32_t     buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,










5507



                                                  SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI);










5508



static int32_t     buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5509



                                             STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName);










5510



static int32_t     buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5511



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName);










5512



static int32_t     buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5513



                                          STableCountScanSupp* pSupp, SSDataBlock* pRes);










5514



static void        buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,










5515



                                               STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5516



                                               size_t perfdbTableNum);










5517



static void        buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,










5518



                                              size_t infodbTableNum, size_t perfdbTableNum);










5519



static const char* GROUP_TAG_DB_NAME = "db_name";










5520



static const char* GROUP_TAG_STABLE_NAME = "stable_name";










5521












5522



int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountScanSupp* supp) {




29,021✔





5523



  if (scanCols != NULL) {




29,021✔





5524



    SNode* pNode = NULL;




15,734✔





5525



    FOREACH(pNode, scanCols) {




36,790✔





5526



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




21,056✔





5527



        return TSDB_CODE_QRY_SYS_ERROR;




×







5528



      }










5529



      STargetNode* targetNode = (STargetNode*)pNode;




21,056✔





5530



      if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {




21,056✔





5531



        return TSDB_CODE_QRY_SYS_ERROR;




×







5532



      }










5533



      SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);




21,056✔





5534



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




21,056✔





5535



        supp->dbNameSlotId = targetNode->slotId;




10,466✔





5536



      } else if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




10,590✔





5537



        supp->stbNameSlotId = targetNode->slotId;




10,590✔





5538



      }










5539



    }










5540



  }










5541



  return TSDB_CODE_SUCCESS;




29,021✔





5542



}










5543












5544



int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanSupp* supp) {




29,021✔





5545



  if (pseudoCols != NULL) {




29,021✔





5546



    SNode* pNode = NULL;




29,021✔





5547



    FOREACH(pNode, pseudoCols) {




58,042✔





5548



      if (nodeType(pNode) != QUERY_NODE_TARGET) {




29,026✔





5549



        return TSDB_CODE_QRY_SYS_ERROR;




×







5550



      }










5551



      STargetNode* targetNode = (STargetNode*)pNode;




29,026✔





5552



      if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {




29,026✔





5553



        return TSDB_CODE_QRY_SYS_ERROR;




×







5554



      }










5555



      SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);




29,026✔





5556



      if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {




29,021✔





5557



        supp->tbCountSlotId = targetNode->slotId;




29,026✔





5558



      }










5559



    }










5560



  }










5561



  return TSDB_CODE_SUCCESS;




29,021✔





5562



}










5563












5564



int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCountScanSupp* supp) {




29,021✔





5565



  if (groupTags != NULL) {




29,021✔





5566



    SNode* pNode = NULL;




15,734✔





5567



    FOREACH(pNode, groupTags) {




36,790✔





5568



      if (nodeType(pNode) != QUERY_NODE_COLUMN) {




21,056✔





5569



        return TSDB_CODE_QRY_SYS_ERROR;




×







5570



      }










5571



      SColumnNode* colNode = (SColumnNode*)pNode;




21,056✔





5572



      if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {




21,056✔





5573



        supp->groupByDbName = true;




10,466✔





5574



      }










5575



      if (strcmp(colNode->colName, GROUP_TAG_STABLE_NAME) == 0) {




21,056✔





5576



        supp->groupByStbName = true;




10,590✔





5577



      }










5578



    }










5579



  } else {










5580



    tstrncpy(supp->dbNameFilter, tNameGetDbNameP(tableName), TSDB_DB_NAME_LEN);




13,287✔





5581



    tstrncpy(supp->stbNameFilter, tNameGetTableName(tableName), TSDB_TABLE_NAME_LEN);




13,287✔





5582



  }










5583



  return TSDB_CODE_SUCCESS;




29,026✔





5584



}










5585












5586



int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* scanCols, SNodeList* pseudoCols,




29,021✔





5587



                              STableCountScanSupp* supp, SExecTaskInfo* taskInfo) {










5588



  int32_t code = 0;




29,021✔





5589



  code = tblCountScanGetInputs(groupTags, tableName, supp);




29,021✔





5590



  if (code != TSDB_CODE_SUCCESS) {




29,026✔





5591



    qError("%s get table count scan supp. get inputs error", GET_TASKID(taskInfo));




×







5592



    return code;




×







5593



  }










5594












5595



  supp->dbNameSlotId = -1;




29,026✔





5596



  supp->stbNameSlotId = -1;




29,021✔





5597



  supp->tbCountSlotId = -1;




29,021✔





5598












5599



  code = tblCountScanGetGroupTagsSlotId(scanCols, supp);




29,026✔





5600



  if (code != TSDB_CODE_SUCCESS) {




29,021✔





5601



    qError("%s get table count scan supp. get group tags slot id error", GET_TASKID(taskInfo));




×







5602



    return code;




×







5603



  }










5604












5605



  code = tblCountScanGetCountSlotId(pseudoCols, supp);




29,021✔





5606



  if (code != TSDB_CODE_SUCCESS) {




29,021✔





5607



    qError("%s get table count scan supp. get count error", GET_TASKID(taskInfo));




×







5608



    return code;




×







5609



  }










5610



  return code;




29,021✔





5611



}










5612












5613



int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode,




28,857✔





5614



                                         SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {










5615



  QRY_PARAM_CHECK(pOptrInfo);




28,857✔





5616












5617



  int32_t                      code = TSDB_CODE_SUCCESS;




29,026✔





5618



  int32_t                      lino = 0;




29,026✔





5619



  SScanPhysiNode*              pScanNode = &pTblCountScanNode->scan;




29,026✔





5620



  STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo));




29,026✔





5621



  SOperatorInfo*               pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));




29,026✔





5622



  if (!pInfo || !pOperator) {




29,026✔





5623



    code = terrno;




×







5624



    goto _error;




×







5625



  }










5626












5627



  pInfo->readHandle = *readHandle;




29,026✔





5628












5629



  SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;




29,026✔





5630



  initResultSizeInfo(&pOperator->resultInfo, 1);




29,026✔





5631



  pInfo->pRes = createDataBlockFromDescNode(pDescNode);




29,026✔





5632



  QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);




29,026✔





5633












5634



  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);




29,026✔





5635



  QUERY_CHECK_CODE(code, lino, _error);




29,026✔





5636












5637



  code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName,




29,026✔





5638



                               pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp,










5639



                               pTaskInfo);










5640



  QUERY_CHECK_CODE(code, lino, _error);




29,026✔





5641












5642



  setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,




29,026✔





5643



                  pInfo, pTaskInfo);










5644



  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,




29,021✔





5645



                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);










5646



  *pOptrInfo = pOperator;




29,021✔





5647



  return code;




29,021✔





5648












5649



_error:




×







5650



  if (pInfo != NULL) {




×







5651



    destoryTableCountScanOperator(pInfo);




×







5652



  }










5653



  if (pOperator != NULL) {




×







5654



    pOperator->info = NULL;




×







5655



    destroyOperator(pOperator);




×







5656



  }










5657



  pTaskInfo->code = code;




×







5658



  return code;




×







5659



}










5660












5661



int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count,




39,746✔





5662



                                    SSDataBlock* pRes) {










5663



  int32_t code = TSDB_CODE_SUCCESS;




39,746✔





5664



  int32_t lino = 0;




39,746✔





5665



  if (pSupp->dbNameSlotId != -1) {




39,746✔





5666



    QUERY_CHECK_CONDITION((strlen(dbName) > 0), code, lino, _end, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);




15,794✔





5667



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId);




15,625✔





5668



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




15,794✔





5669












5670



    char varDbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




15,794✔





5671



    tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN);




15,794✔





5672












5673



    varDataSetLen(varDbName, strlen(dbName));




15,625✔





5674



    code = colDataSetVal(colInfoData, 0, varDbName, false);




15,794✔





5675



    QUERY_CHECK_CODE(code, lino, _end);




15,794✔





5676



  }










5677












5678



  if (pSupp->stbNameSlotId != -1) {




39,746✔





5679



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->stbNameSlotId);




20,279✔





5680



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




20,110✔





5681



    if (strlen(stbName) != 0) {




20,110✔





5682



      char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




14,634✔





5683



      tstrncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN);




14,634✔





5684



      varDataSetLen(varStbName, strlen(stbName));




14,296✔





5685



      code = colDataSetVal(colInfoData, 0, varStbName, false);




14,634✔





5686



      QUERY_CHECK_CODE(code, lino, _end);




14,634✔





5687



    } else {










5688



      colDataSetNULL(colInfoData, 0);










5689



    }










5690



  }










5691












5692



  if (pSupp->tbCountSlotId != -1) {




39,751✔





5693



    SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId);




39,577✔





5694



    QUERY_CHECK_NULL(colInfoData, code, lino, _end, terrno);




39,403✔





5695



    code = colDataSetVal(colInfoData, 0, (char*)&count, false);




39,403✔





5696



    QUERY_CHECK_CODE(code, lino, _end);




39,746✔





5697



  }










5698



  pRes->info.rows = 1;




39,910✔





5699












5700



_end:




39,577✔





5701



  if (code != TSDB_CODE_SUCCESS) {




39,577✔





5702



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5703



  }










5704



  return code;




39,746✔





5705



}










5706












5707



static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) {




11,395✔





5708



  STableCountScanSupp* pSupp = &pInfo->supp;




11,395✔





5709



  SSDataBlock*         pRes = pInfo->pRes;




11,395✔





5710












5711



  size_t infodbTableNum;




11,395✔





5712



  getInfosDbMeta(NULL, &infodbTableNum);




11,395✔





5713



  infodbTableNum -= 1;




11,395✔





5714



  size_t perfdbTableNum;




11,395✔





5715



  getPerfDbMeta(NULL, &perfdbTableNum);




11,395✔





5716












5717



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




11,395✔





5718



    buildSysDbGroupedTableCount(pOperator, pInfo, pSupp, pRes, infodbTableNum, perfdbTableNum);




9,807✔





5719



    return (pRes->info.rows > 0) ? pRes : NULL;




9,807✔





5720



  } else {










5721



    buildSysDbFilterTableCount(pOperator, pSupp, pRes, infodbTableNum, perfdbTableNum);




1,588✔





5722



    return (pRes->info.rows > 0) ? pRes : NULL;




1,588✔





5723



  }










5724



}










5725












5726



static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes,




1,588✔





5727



                                       size_t infodbTableNum, size_t perfdbTableNum) {










5728



  int32_t        code = TSDB_CODE_SUCCESS;




1,588✔





5729



  int32_t        lino = 0;




1,588✔





5730



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




1,588✔





5731



  if (strlen(pSupp->stbNameFilter) != 0) {




1,588✔





5732



    // sys dbs do not contain any stable, so the count is always 0










5733



    code = fillTableCountScanDataBlock(pSupp, "", "", 0, pRes);




534✔





5734



    QUERY_CHECK_CODE(code, lino, _end);




534✔





5735



  } else if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) {




1,054✔





5736



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




178✔





5737



    QUERY_CHECK_CODE(code, lino, _end);




178✔





5738



  } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) {




876✔





5739



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




×







5740



    QUERY_CHECK_CODE(code, lino, _end);




×







5741



  } else if (strlen(pSupp->dbNameFilter) == 0) {




876✔





5742



    code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes);




698✔





5743



    QUERY_CHECK_CODE(code, lino, _end);




698✔





5744



  } else {










5745



    // other dbs do not exist in sys dbs, so the count is always 0










5746



    code = fillTableCountScanDataBlock(pSupp, pSupp->dbNameFilter, pSupp->stbNameFilter, 0, pRes);




178✔





5747



    QUERY_CHECK_CODE(code, lino, _end);




178✔





5748



  }










5749












5750



_end:




178✔





5751



  if (code != TSDB_CODE_SUCCESS) {




1,588✔





5752



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5753



    pTaskInfo->code = code;




×







5754



    T_LONG_JMP(pTaskInfo->env, code);




×







5755



  }










5756



  setOperatorCompleted(pOperator);




1,588✔





5757



}




1,588✔





5758












5759



static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




9,807✔





5760



                                        STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum,










5761



                                        size_t perfdbTableNum) {










5762



  int32_t        code = TSDB_CODE_SUCCESS;




9,807✔





5763



  int32_t        lino = 0;




9,807✔





5764



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




9,807✔





5765



  if (pInfo->currGrpIdx == 0) {




9,807✔





5766



    uint64_t groupId = 0;




3,269✔





5767



    if (pSupp->groupByDbName) {




3,269✔





5768



      groupId = calcGroupId(TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB));




2,250✔





5769



    } else {










5770



      groupId = calcGroupId("", 0);




1,019✔





5771



    }










5772












5773



    pRes->info.id.groupId = groupId;




3,269✔





5774



    code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes);




3,269✔





5775



    QUERY_CHECK_CODE(code, lino, _end);




3,269✔





5776



  } else if (pInfo->currGrpIdx == 1) {




6,538✔





5777



    uint64_t groupId = 0;




3,269✔





5778



    if (pSupp->groupByDbName) {




3,269✔





5779



      groupId = calcGroupId(TSDB_PERFORMANCE_SCHEMA_DB, strlen(TSDB_PERFORMANCE_SCHEMA_DB));




2,250✔





5780



    } else {










5781



      groupId = calcGroupId("", 0);




1,019✔





5782



    }










5783












5784



    pRes->info.id.groupId = groupId;




3,269✔





5785



    code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes);




3,269✔





5786



    QUERY_CHECK_CODE(code, lino, _end);




3,269✔





5787



  } else {










5788



    setOperatorCompleted(pOperator);




3,269✔





5789



  }










5790



  pInfo->currGrpIdx++;




9,807✔





5791












5792



_end:




9,807✔





5793



  if (code != TSDB_CODE_SUCCESS) {




9,807✔





5794



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5795



    pTaskInfo->code = code;




×







5796



    T_LONG_JMP(pTaskInfo->env, code);




×







5797



  }










5798



}




9,807✔





5799












5800



static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {




68,608✔





5801



  int32_t                      code = TSDB_CODE_SUCCESS;




68,608✔





5802



  SExecTaskInfo*               pTaskInfo = pOperator->pTaskInfo;




68,608✔





5803



  STableCountScanOperatorInfo* pInfo = pOperator->info;




68,608✔





5804



  STableCountScanSupp*         pSupp = &pInfo->supp;




68,608✔





5805



  SSDataBlock*                 pRes = pInfo->pRes;




68,777✔





5806












5807



  blockDataCleanup(pRes);




68,777✔





5808



  QRY_PARAM_CHECK(ppRes);




68,777✔





5809












5810



  if (pOperator->status == OP_EXEC_DONE) {




68,777✔





5811



    return code;




17,400✔





5812



  }










5813












5814



  if (pInfo->readHandle.mnd != NULL) {




51,377✔





5815



    (*ppRes) = buildSysDbTableCount(pOperator, pInfo);




11,395✔





5816



    return code;




11,395✔





5817



  }










5818












5819



  code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);




39,982✔





5820



  if (code != TSDB_CODE_SUCCESS) {




39,972✔





5821



    qError("%s failed since %s", __func__, tstrerror(code));




×







5822



    pTaskInfo->code = code;




×







5823



    T_LONG_JMP(pTaskInfo->env, code);




×







5824



  }










5825



  if (pRes->info.rows > 0) {




39,972✔





5826



    *ppRes = pRes;




31,625✔





5827



  }










5828












5829



  return code;




39,644✔





5830



}










5831












5832



static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




39,982✔





5833



                                      STableCountScanSupp* pSupp, SSDataBlock* pRes) {










5834



  int32_t        code = TSDB_CODE_SUCCESS;




39,982✔





5835



  int32_t        lino = 0;




39,982✔





5836



  const char*    db = NULL;




39,982✔





5837



  int32_t        vgId = 0;




39,982✔





5838



  char           dbName[TSDB_DB_NAME_LEN] = {0};




39,982✔





5839



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




39,982✔





5840



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




39,982✔





5841












5842



  // get dbname










5843



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);




39,644✔





5844



  SName sn = {0};




39,977✔





5845












5846



  code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);




39,977✔





5847



  QUERY_CHECK_CODE(code, lino, _end);




39,977✔





5848












5849



  code = tNameGetDbName(&sn, dbName);




39,977✔





5850



  QUERY_CHECK_CODE(code, lino, _end);




39,977✔





5851












5852



  if (pSupp->groupByDbName || pSupp->groupByStbName) {




39,977✔





5853



    code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName);




28,278✔





5854



  } else {










5855



    code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName);




11,699✔





5856



  }










5857












5858



_end:




39,794✔





5859



  if (code != TSDB_CODE_SUCCESS) {




39,972✔





5860



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5861



    pTaskInfo->code = code;




×







5862



  }










5863












5864



  return code;




39,972✔





5865



}










5866












5867



static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




28,278✔





5868



                                           STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) {










5869



  int32_t        code = TSDB_CODE_SUCCESS;




28,278✔





5870



  int32_t        lino = 0;




28,278✔





5871



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




28,278✔





5872



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




28,278✔





5873












5874



  if (pSupp->groupByStbName) {




28,278✔





5875



    if (pInfo->stbUidList == NULL) {




24,170✔





5876



      pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t));




8,357✔





5877



      QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, terrno);




8,357✔





5878



      code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList);




8,357✔





5879



      QUERY_CHECK_CODE(code, lino, _end);




8,357✔





5880



    }










5881












5882



    if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) {




24,170✔





5883



      tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx);




14,634✔





5884



      code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI);




14,634✔





5885



      QUERY_CHECK_CODE(code, lino, _end);




14,634✔





5886












5887



      pInfo->currGrpIdx++;




14,634✔





5888



    } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) {




9,536✔





5889



      code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI);




8,357✔





5890



      QUERY_CHECK_CODE(code, lino, _end);




8,179✔





5891












5892



      pInfo->currGrpIdx++;




8,179✔





5893



    } else {










5894



      setOperatorCompleted(pOperator);




1,179✔





5895



    }










5896



  } else {










5897



    uint64_t groupId = calcGroupId(dbName, strlen(dbName));




4,108✔





5898



    pRes->info.id.groupId = groupId;




4,108✔





5899












5900



    int64_t dbTableCount = 0;




4,108✔





5901



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL);




4,108✔





5902



    code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes);




4,108✔





5903



    QUERY_CHECK_CODE(code, lino, _end);




4,108✔





5904



    setOperatorCompleted(pOperator);




4,108✔





5905



  }










5906












5907



_end:




28,100✔





5908



  if (code != TSDB_CODE_SUCCESS) {




28,100✔





5909



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5910



    pTaskInfo->code = code;




×







5911



  }










5912



  return code;




28,100✔





5913



}










5914












5915



static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,




11,699✔





5916



                                         STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) {










5917



  int32_t        code = TSDB_CODE_SUCCESS;




11,699✔





5918



  int32_t        lino = 0;




11,699✔





5919



  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;




11,699✔





5920



  SStorageAPI*   pAPI = &pTaskInfo->storageAPI;




11,699✔





5921












5922



  if (strlen(pSupp->dbNameFilter) != 0 && strcmp(dbName, pSupp->dbNameFilter) != 0) {




11,699✔





5923



    // db name not match, return count 0










5924



    code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




×







5925



    QUERY_CHECK_CODE(code, lino, _end);




×







5926



  } else if (strlen(pSupp->stbNameFilter) != 0) {




11,709✔





5927



    uint64_t uid = 0;




5,694✔





5928



    code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid);




5,694✔





5929



    if (code == TSDB_CODE_TDB_TABLE_NOT_EXIST) {




5,694✔





5930



      // table not exist, return count 0










5931



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, 0, pRes);




1,424✔





5932



      QUERY_CHECK_CODE(code, lino, _end);




1,424✔





5933



    } else {










5934



      QUERY_CHECK_CODE(code, lino, _end);




4,270✔





5935












5936



      int64_t numOfChildTables = 0;




4,270✔





5937



      code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL, NULL);




4,270✔





5938



      QUERY_CHECK_CODE(code, lino, _end);




4,270✔





5939












5940



      code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes);




4,270✔





5941



      QUERY_CHECK_CODE(code, lino, _end);




4,270✔





5942



    }










5943



  } else {










5944



    int64_t tbNumVnode = 0;




6,005✔





5945



    pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL);




6,005✔





5946



    code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes);




6,005✔





5947



    QUERY_CHECK_CODE(code, lino, _end);




6,005✔





5948



  }










5949












5950



_end:




11,699✔





5951



  if (code != TSDB_CODE_SUCCESS) {




11,699✔





5952



    pTaskInfo->code = code;




×







5953



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5954



  }










5955












5956



  setOperatorCompleted(pOperator);




11,699✔





5957



  return code;




11,694✔





5958



}










5959












5960



static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




8,357✔





5961



                                              SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) {










5962



  int32_t code = TSDB_CODE_SUCCESS;




8,357✔





5963



  int32_t lino = 0;




8,357✔





5964



  char    fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




8,357✔





5965



  if (pSupp->groupByDbName) {




8,357✔





5966



    snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, "");




4,108✔





5967



  }










5968












5969



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




8,357✔





5970



  pRes->info.id.groupId = groupId;




8,357✔





5971












5972



  int64_t numOfTables = 0;




8,357✔





5973



  pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables);




8,179✔





5974












5975



  if (numOfTables != 0) {




8,357✔





5976



    code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes);




1,179✔





5977



  }










5978












5979



_end:




7,178✔





5980



  if (code != TSDB_CODE_SUCCESS) {




8,357✔





5981



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







5982



  }










5983



  return code;




8,357✔





5984



}










5985












5986



static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,




14,634✔





5987



                                              SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) {










5988



  int32_t code = TSDB_CODE_SUCCESS;




14,634✔





5989



  int32_t lino = 0;




14,634✔





5990



  char    stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};




14,634✔





5991



  code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName);




14,634✔





5992



  QUERY_CHECK_CODE(code, lino, _end);




14,634✔





5993












5994



  char fullStbName[TSDB_TABLE_FNAME_LEN] = {0};




14,634✔





5995



  if (pSupp->groupByDbName) {




14,634✔





5996



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName));




6,848✔





5997



  } else {










5998



    (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName));




7,786✔





5999



  }










6000












6001



  uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName));




14,634✔





6002



  pRes->info.id.groupId = groupId;




14,634✔





6003












6004



  int64_t ctbNum = 0;




14,296✔





6005



  code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL, NULL);




14,634✔





6006



  QUERY_CHECK_CODE(code, lino, _end);




14,634✔





6007



  code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes);




14,634✔





6008



  QUERY_CHECK_CODE(code, lino, _end);




14,634✔





6009












6010



_end:




14,634✔





6011



  if (code != TSDB_CODE_SUCCESS) {




14,634✔





6012



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







6013



  }










6014



  return code;




14,634✔





6015



}










6016












6017



static void destoryTableCountScanOperator(void* param) {




29,026✔





6018



  STableCountScanOperatorInfo* pTableCountScanInfo = param;




29,026✔





6019



  blockDataDestroy(pTableCountScanInfo->pRes);




29,026✔





6020












6021



  taosArrayDestroy(pTableCountScanInfo->stbUidList);




29,021✔





6022



  taosMemoryFreeClear(param);




29,026✔





6023



}




29,026✔



















    

  • 

    •