taosdata / TDengine / #3653

coverage: 22.565% (-41.0%) from 63.596%
#3653

push

travis-ci

web-flow 
feat(keep): support keep on super table level. (#30097)

* Feat: support use keep while create super table.

* Test(keep): add test for create super table with keep option.

* Feat(keep): Add tmsg for create keep.

* Feat(keep): support alter table option keep.

* Fix(keep): Add baisc test for alter table option.

* Fix(keep): memory leek.

* Feat(keep): add keep to metaEntry&metaCache and fix earliestTs with stn keep.

* Test(keep): add some cases for select with stb keep.

* Fix: fix ci core while alter stb.

* Feat(keep): delete expired data in super table level.

* Feat: remove get stb keep while query.

* Fix : build error.

* Revert "Fix : build error."

This reverts commit 0ed66e4e8.

* Revert "Feat(keep): delete expired data in super table level."

This reverts commit 36330f6b4.

* Fix : build errors.

* Feat : support restart taosd.

* Fix : alter table comment problems.

* Test : add tests for super table keep.

* Fix: change sdb stb reserve size.

* Test: add more tests.

* Feat: Disable normal tables and sub tables from setting the keep parameter

* Fix: add more checks to avoid unknown address.

* Docs: Add docs for stable keep.

* Fix: some review changes.

* Fix: review errors.

49248 of 302527 branches covered (16.28%)

Branch coverage included in aggregate %.

53 of 99 new or added lines in 12 files covered. (53.54%)

155872 existing lines in 443 files now uncovered.

87359 of 302857 relevant lines covered (28.84%)

570004.22 hits per line

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

0.0
/source/dnode/vnode/src/tsdb/tsdbRead2.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 "osDef.h"










17



#include "tsdb.h"










18



#include "tsdbDataFileRW.h"










19



#include "tsdbFS2.h"










20



#include "tsdbMerge.h"










21



#include "tsdbReadUtil.h"










22



#include "tsdbUtil2.h"










23



#include "tsimplehash.h"










24












25



#define ASCENDING_TRAVERSE(o)       (o == TSDB_ORDER_ASC)










26



#define getCurrentKeyInSttBlock(_r) (&((_r)->currentKey))










27



#define tColRowGetKeyDeepCopy(_pBlock, _irow, _slotId, _pKey)             \










28



  do {                                                                    \










29



    (_pKey)->ts = (_pBlock)->aTSKEY[(_irow)];                             \










30



    (_pKey)->numOfPKs = 0;                                                \










31



    if ((_slotId) != -1) {                                                \










32



      code = tColRowGetPriamyKeyDeepCopy(_pBlock, _irow, _slotId, _pKey); \










33



      TSDB_CHECK_CODE(code, lino, _end);                                  \










34



    }                                                                     \










35



  } while (0)










36












37



#define outOfTimeWindow(_ts, _window) (((_ts) > (_window)->ekey) || ((_ts) < (_window)->skey))










38












39



typedef struct {










40



  bool overlapWithNeighborBlock;










41



  bool hasDupTs;










42



  bool overlapWithDelInfo;










43



  bool overlapWithSttBlock;










44



  bool overlapWithKeyInBuf;










45



  bool partiallyRequired;










46



  bool moreThanCapcity;










47



} SDataBlockToLoadInfo;










48












49



static int32_t getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInfo** pInfo, const char* idStr);










50



static int32_t buildDataBlockFromBufImpl(STableBlockScanInfo* pBlockScanInfo, int64_t endKey, int32_t capacity,










51



                                         STsdbReader* pReader);










52



static int32_t getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader, TSDBROW** pRes);










53



static int32_t doMergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pScanInfo, SRowKey* pKey,










54



                                       STsdbReader* pReader);










55



static int32_t doMergeRowsInSttBlock(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo,










56



                                     SRowMerger* pMerger, int32_t pkSrcSlot, SVersionRange* pVerRange, const char* id);










57



static int32_t doMergeRowsInBuf(SIterInfo* pIter, uint64_t uid, SRowKey* pCurKey, SArray* pDelList,










58



                                STsdbReader* pReader);










59



static int32_t doAppendRowFromTSRow(SSDataBlock* pBlock, STsdbReader* pReader, SRow* pTSRow,










60



                                    STableBlockScanInfo* pScanInfo);










61



static int32_t doAppendRowFromFileBlock(SSDataBlock* pResBlock, STsdbReader* pReader, SBlockData* pBlockData,










62



                                        int32_t rowIndex);










63



static void    setComposedBlockFlag(STsdbReader* pReader, bool composed);










64



static int32_t hasBeenDropped(const SArray* pDelList, int32_t* index, int64_t key, int64_t ver, int32_t order,










65



                              SVersionRange* pVerRange, bool hasPk, bool* dropped);










66












67



static int32_t doMergeMemTableMultiRows(TSDBROW* pRow, SRowKey* pKey, uint64_t uid, SIterInfo* pIter, SArray* pDelList,










68



                                        TSDBROW* pResRow, STsdbReader* pReader, bool* freeTSRow);










69



static int32_t doMergeMemIMemRows(TSDBROW* pRow, SRowKey* pRowKey, TSDBROW* piRow, SRowKey* piRowKey,










70



                                  STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader, SRow** pTSRow);










71



static int32_t mergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pBlockScanInfo, SRowKey* pKey,










72



                                     STsdbReader* pReader);










73



static int32_t mergeRowsInSttBlocks(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo,










74



                                    STsdbReader* pReader);










75












76



static int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, int32_t order, SReadCostSummary* pCost);










77



static void getTsdbByRetentions(SVnode* pVnode, SQueryTableDataCond* pCond, SRetention* retentions, const char* idstr,










78



                                int8_t* pLevel, STsdb** pTsdb);










79



static SVersionRange getQueryVerRange(SVnode* pVnode, SQueryTableDataCond* pCond, int8_t level);










80



static int32_t       doBuildDataBlock(STsdbReader* pReader);










81



static int32_t       getCurrentKeyInBuf(STableBlockScanInfo* pScanInfo, STsdbReader* pReader, TSDBKEY* key);










82



static bool          hasDataInFileBlock(const SBlockData* pBlockData, const SFileBlockDumpInfo* pDumpInfo);










83



static bool          hasDataInSttBlock(STableBlockScanInfo* pInfo);










84



static int32_t       initBlockDumpInfo(STsdbReader* pReader, SDataBlockIter* pBlockIter);










85



static int32_t       getInitialDelIndex(const SArray* pDelSkyline, int32_t order);










86



static int32_t       resetTableListIndex(SReaderStatus* pStatus, const char* id);










87



static void          getMemTableTimeRange(STsdbReader* pReader, int64_t* pMaxKey, int64_t* pMinKey);










88



static void          updateComposedBlockInfo(STsdbReader* pReader, double el, STableBlockScanInfo* pBlockScanInfo);










89



static int32_t       buildFromPreFilesetBuffer(STsdbReader* pReader);










90












91



static void resetPreFilesetMemTableListIndex(SReaderStatus* pStatus);










92












93



FORCE_INLINE int32_t pkCompEx(SRowKey* p1, SRowKey* p2) {




×








UNCOV

94



  if (p2 == NULL) {





×








UNCOV

95



    return 1;




×







96



  }










97













UNCOV

98



  if (p1 == NULL) {





×







99



    return -1;




×







100



  }










101













UNCOV

102



  if (p1->ts < p2->ts) {





×








UNCOV

103



    return -1;




×








UNCOV

104



  } else if (p1->ts > p2->ts) {





×








UNCOV

105



    return 1;




×







106



  }










107













UNCOV

108



  if (p1->numOfPKs == 0) {





×








UNCOV

109



    return 0;




×







110



  } else {











UNCOV

111



    return tRowKeyCompare(p1, p2);




×







112



  }










113



}










114













UNCOV

115



static int32_t tColRowGetPriamyKeyDeepCopy(SBlockData* pBlock, int32_t irow, int32_t slotId, SRowKey* pKey) {




×








UNCOV

116



  int32_t   code = TSDB_CODE_SUCCESS;




×








UNCOV

117



  int32_t   lino = 0;




×








UNCOV

118



  SColData* pColData = NULL;




×







119



  SColVal   cv;










120













UNCOV

121



  TSDB_CHECK_CONDITION((pBlock != NULL) && (pBlock->aColData != NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

122



  TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







123













UNCOV

124



  pColData = &pBlock->aColData[slotId];




×







125













UNCOV

126



  code = tColDataGetValue(pColData, irow, &cv);




×








UNCOV

127



  TSDB_CHECK_CODE(code, lino, _end);





×







128













UNCOV

129



  pKey->numOfPKs = 1;




×








UNCOV

130



  pKey->pks[0].type = cv.value.type;




×







131













UNCOV

132



  if (IS_NUMERIC_TYPE(cv.value.type)) {





×








UNCOV

133



    pKey->pks[0].val = cv.value.val;




×







134



  } else {










135



    pKey->pks[0].nData = cv.value.nData;




×







136



    TAOS_MEMCPY(pKey->pks[0].pData, cv.value.pData, cv.value.nData);




×







137



  }










138













UNCOV

139



_end:




×








UNCOV

140



  if (code != TSDB_CODE_SUCCESS) {





×







141



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





×







142



  }











UNCOV

143



  return code;




×







144



}










145












146



// for test purpose, todo remove it











UNCOV

147



static int32_t tGetPrimaryKeyIndex(uint8_t* p, SPrimaryKeyIndex* index) {




×








UNCOV

148



  int32_t n = 0;




×








UNCOV

149



  n += tGetI8(p + n, &index->type);





×








UNCOV

150



  n += tGetU32v(p + n, &index->offset);





×








UNCOV

151



  return n;




×







152



}










153













UNCOV

154



static int32_t tRowGetPrimaryKeyDeepCopy(SRow* pRow, SRowKey* pKey) {




×








UNCOV

155



  int32_t          code = TSDB_CODE_SUCCESS;




×








UNCOV

156



  int32_t          lino = 0;




×







157



  SPrimaryKeyIndex indices[TD_MAX_PK_COLS];











UNCOV

158



  uint8_t*         data = NULL;




×








UNCOV

159



  int32_t          len = 0;




×







160













UNCOV

161



  TSDB_CHECK_NULL(pRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

162



  if (pRow->numOfPKs > 0) {





×








UNCOV

163



    TSDB_CHECK_NULL(pRow->data, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

164



    TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







165



  }










166













UNCOV

167



  data = pRow->data;




×








UNCOV

168



  for (int32_t i = 0; i < pRow->numOfPKs; i++) {





×








UNCOV

169



    data += tGetPrimaryKeyIndex(data, &indices[i]);




×







170



  }










171












172



  // primary keys











UNCOV

173



  for (int32_t i = 0; i < pRow->numOfPKs; i++) {





×








UNCOV

174



    pKey->pks[i].type = indices[i].type;




×







175













UNCOV

176



    uint8_t* tdata = data + indices[i].offset;




×








UNCOV

177



    if (pRow->flag >> 4) {





×








UNCOV

178



      tdata += tGetI16v(tdata, NULL);




×







179



    }










180













UNCOV

181



    if (IS_VAR_DATA_TYPE(indices[i].type)) {





×








UNCOV

182



      tdata += tGetU32v(tdata, &pKey->pks[i].nData);





×








UNCOV

183



      TAOS_MEMCPY(pKey->pks[i].pData, tdata, pKey->pks[i].nData);




×







184



    } else {











UNCOV

185



      TAOS_MEMCPY(&pKey->pks[i].val, data + indices[i].offset, tDataTypes[pKey->pks[i].type].bytes);




×







186



    }










187



  }










188













UNCOV

189



_end:




×








UNCOV

190



  if (code != TSDB_CODE_SUCCESS) {





×







191



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





×







192



  }











UNCOV

193



  return code;




×







194



}










195













UNCOV

196



static int32_t setColumnIdSlotList(SBlockLoadSuppInfo* pSupInfo, SColumnInfo* pCols, const int32_t* pSlotIdList,




×







197



                                   int32_t numOfCols) {











UNCOV

198



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

199



  int32_t lino = 0;




×







200













UNCOV

201



  TSDB_CHECK_NULL(pSupInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

202



  if (numOfCols > 0) {





×








UNCOV

203



    TSDB_CHECK_NULL(pSlotIdList, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

204



    TSDB_CHECK_NULL(pCols, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







205



  }










206













UNCOV

207



  pSupInfo->pk.pk = 0;




×








UNCOV

208



  pSupInfo->numOfPks = 0;




×








UNCOV

209



  pSupInfo->pkSrcSlot = -1;




×








UNCOV

210



  pSupInfo->pkDstSlot = -1;




×








UNCOV

211



  pSupInfo->smaValid = true;




×








UNCOV

212



  pSupInfo->numOfCols = numOfCols;




×







213













UNCOV

214



  pSupInfo->colId = taosMemoryCalloc(numOfCols, sizeof(int16_t) * 2 + POINTER_BYTES);





×








UNCOV

215



  TSDB_CHECK_NULL(pSupInfo->colId, code, lino, _end, terrno);





×







216













UNCOV

217



  pSupInfo->slotId = (int16_t*)((char*)pSupInfo->colId + (sizeof(int16_t) * numOfCols));




×








UNCOV

218



  pSupInfo->buildBuf = (char**)((char*)pSupInfo->slotId + (sizeof(int16_t) * numOfCols));




×








UNCOV

219



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





×








UNCOV

220



    pSupInfo->colId[i] = pCols[i].colId;




×








UNCOV

221



    pSupInfo->slotId[i] = pSlotIdList[i];




×







222













UNCOV

223



    if (pCols[i].pk) {





×








UNCOV

224



      pSupInfo->pk = pCols[i];




×








UNCOV

225



      pSupInfo->pkSrcSlot = i - 1;




×








UNCOV

226



      pSupInfo->pkDstSlot = pSlotIdList[i];




×








UNCOV

227



      pSupInfo->numOfPks += 1;




×







228



    }










229













UNCOV

230



    if (IS_VAR_DATA_TYPE(pCols[i].type)) {





×








UNCOV

231



      pSupInfo->buildBuf[i] = taosMemoryMalloc(pCols[i].bytes);





×








UNCOV

232



      if (pSupInfo->buildBuf[i] == NULL) {





×







233



        tsdbError("failed to prepare memory for set columnId slot list, size:%d, code:%s", pCols[i].bytes,





×







234



                  tstrerror(terrno));










235



      }











UNCOV

236



      TSDB_CHECK_NULL(pSupInfo->buildBuf[i], code, lino, _end, terrno);





×







237



    } else {











UNCOV

238



      pSupInfo->buildBuf[i] = NULL;




×







239



    }










240



  }










241













UNCOV

242



_end:




×








UNCOV

243



  if (code != TSDB_CODE_SUCCESS) {





×







244



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





×







245



  }











UNCOV

246



  return code;




×







247



}










248













UNCOV

249



static int32_t updateBlockSMAInfo(STSchema* pSchema, SBlockLoadSuppInfo* pSupInfo) {




×








UNCOV

250



  int32_t   code = TSDB_CODE_SUCCESS;




×








UNCOV

251



  int32_t   lino = 0;




×








UNCOV

252



  int32_t   i = 0, j = 0;




×








UNCOV

253



  STColumn* pTCol = NULL;




×







254













UNCOV

255



  TSDB_CHECK_NULL(pSchema, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

256



  TSDB_CHECK_NULL(pSupInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







257













UNCOV

258



  while (i < pSchema->numOfCols && j < pSupInfo->numOfCols) {





×








UNCOV

259



    pTCol = &pSchema->columns[i];




×








UNCOV

260



    if (pTCol->colId == pSupInfo->colId[j]) {





×








UNCOV

261



      if (!IS_BSMA_ON(pTCol) && (PRIMARYKEY_TIMESTAMP_COL_ID != pTCol->colId)) {





×








UNCOV

262



        pSupInfo->smaValid = false;




×








UNCOV

263



        goto _end;




×







264



      }










265













UNCOV

266



      i += 1;




×








UNCOV

267



      j += 1;




×








UNCOV

268



    } else if (pTCol->colId < pSupInfo->colId[j]) {  // do nothing





×








UNCOV

269



      i += 1;




×







270



    } else {










271



      code = TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER;




×







272



      TSDB_CHECK_CODE(code, lino, _end);





×







273



    }










274



  }










275













UNCOV

276



_end:




×








UNCOV

277



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

278



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





×







279



  }











UNCOV

280



  return code;




×







281



}










282













UNCOV

283



static bool isEmptyQueryTimeWindow(STimeWindow* pWindow) {




×








UNCOV

284



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





×







285



}










286












287



// Update the query time window according to the data time to live(TTL) information, in order to avoid to return










288



// the expired data to client, even it is queried already.











UNCOV

289



static int32_t updateQueryTimeWindow(STsdb* pTsdb, STimeWindow* pWindow, STimeWindow* out) {




×








UNCOV

290



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

291



  int32_t lino = 0;




×








UNCOV

292



  int64_t earlyTs = 0;




×







293













UNCOV

294



  TSDB_CHECK_NULL(pTsdb, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

295



  TSDB_CHECK_NULL(pWindow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

296



  TSDB_CHECK_NULL(out, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







297













UNCOV

298



  earlyTs = tsdbGetEarliestTs(pTsdb);




×








UNCOV

299



  *out = *pWindow;




×








UNCOV

300



  if (out->skey < earlyTs) {





×








UNCOV

301



    out->skey = earlyTs;




×







302



  }










303













UNCOV

304



_end:




×








UNCOV

305



  if (code != TSDB_CODE_SUCCESS) {





×







306



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





×







307



  }











UNCOV

308



  return code;




×







309



}










310












311



// init file iterator











UNCOV

312



static int32_t initFilesetIterator(SFilesetIter* pIter, TFileSetArray* pFileSetArray, STsdbReader* pReader) {




×








UNCOV

313



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

314



  int32_t             lino = 0;




×








UNCOV

315



  SBlockLoadSuppInfo* pInfo = NULL;




×








UNCOV

316



  SSttBlockReader*    pSttReader = NULL;




×








UNCOV

317



  size_t              numOfFileset = 0;




×








UNCOV

318



  bool                asc = false;




×







319













UNCOV

320



  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

321



  TSDB_CHECK_NULL(pFileSetArray, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

322



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







323













UNCOV

324



  pInfo = &pReader->suppInfo;




×








UNCOV

325



  numOfFileset = TARRAY2_SIZE(pFileSetArray);




×








UNCOV

326



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×







327













UNCOV

328



  pIter->index = asc ? -1 : numOfFileset;





×








UNCOV

329



  pIter->order = pReader->info.order;




×








UNCOV

330



  pIter->pFilesetList = pFileSetArray;




×








UNCOV

331



  pIter->numOfFiles = numOfFileset;




×







332













UNCOV

333



  if (pIter->pSttBlockReader == NULL) {





×








UNCOV

334



    pIter->pSttBlockReader = taosMemoryCalloc(1, sizeof(struct SSttBlockReader));





×








UNCOV

335



    if (pIter->pSttBlockReader == NULL) {





×







336



      tsdbError("failed to prepare the last block iterator, since:%s %s", tstrerror(terrno), pReader->idStr);





×







337



    }











UNCOV

338



    TSDB_CHECK_NULL(pIter->pSttBlockReader, code, lino, _end, terrno);





×







339



  }










340













UNCOV

341



  pSttReader = pIter->pSttBlockReader;




×








UNCOV

342



  pSttReader->order = pReader->info.order;




×








UNCOV

343



  pSttReader->window = pReader->info.window;




×








UNCOV

344



  pSttReader->verRange = pReader->info.verRange;




×








UNCOV

345



  pSttReader->numOfPks = pReader->suppInfo.numOfPks;




×








UNCOV

346



  pSttReader->uid = 0;




×







347













UNCOV

348



  tMergeTreeClose(&pSttReader->mergeTree);




×








UNCOV

349



  code = initRowKey(&pSttReader->currentKey, INT64_MIN, pInfo->numOfPks, pInfo->pk.type, pInfo->pk.bytes, asc);




×








UNCOV

350



  if (code != TSDB_CODE_SUCCESS) {





×







351



    tsdbError("failed init row key, %s", pReader->idStr);





×







352



  } else {











UNCOV

353



    tsdbDebug("init fileset iterator, total files:%d %s", pIter->numOfFiles, pReader->idStr);





×







354



  }











UNCOV

355



  TSDB_CHECK_CODE(code, lino, _end);





×







356













UNCOV

357



_end:




×








UNCOV

358



  if (code != TSDB_CODE_SUCCESS) {





×







359



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





×







360



  }











UNCOV

361



  return code;




×







362



}










363













UNCOV

364



static int32_t filesetIteratorNext(SFilesetIter* pIter, STsdbReader* pReader, bool* hasNext) {




×








UNCOV

365



  int32_t           code = TSDB_CODE_SUCCESS;




×








UNCOV

366



  int32_t           lino = 0;




×








UNCOV

367



  bool              asc = false;




×








UNCOV

368



  int32_t           step = 0;




×








UNCOV

369



  SReadCostSummary* pCost = NULL;




×








UNCOV

370



  STFileObj**       pFileObj = NULL;




×







371













UNCOV

372



  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

373



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

374



  TSDB_CHECK_NULL(hasNext, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







375













UNCOV

376



  asc = ASCENDING_TRAVERSE(pIter->order);




×








UNCOV

377



  step = asc ? 1 : -1;





×








UNCOV

378



  *hasNext = false;




×







379













UNCOV

380



  pIter->index += step;




×








UNCOV

381



  if ((asc && pIter->index >= pIter->numOfFiles) || ((!asc) && pIter->index < 0)) {





×








UNCOV

382



    *hasNext = false;




×








UNCOV

383



    goto _end;




×







384



  }










385













UNCOV

386



  pCost = &pReader->cost;




×







387













UNCOV

388



  TSDB_CHECK_NULL(pIter->pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

389



  pIter->pSttBlockReader->uid = 0;




×








UNCOV

390



  tMergeTreeClose(&pIter->pSttBlockReader->mergeTree);




×








UNCOV

391



  destroySttBlockReader(pReader->status.pLDataIterArray, &pCost->sttCost);




×







392













UNCOV

393



  pReader->status.pLDataIterArray = taosArrayInit(4, POINTER_BYTES);




×








UNCOV

394



  TSDB_CHECK_NULL(pReader->status.pLDataIterArray, code, lino, _end, terrno);





×







395












396



  // check file the time range of coverage











UNCOV

397



  STimeWindow win = {0};




×







398













UNCOV

399



  while (1) {




×








UNCOV

400



    if (pReader->pFileReader != NULL) {





×








UNCOV

401



      tsdbDataFileReaderClose(&pReader->pFileReader);




×







402



    }










403













UNCOV

404



    TSDB_CHECK_CONDITION(pIter->index < pIter->pFilesetList->size, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);





×








UNCOV

405



    pReader->status.pCurrentFileset = pIter->pFilesetList->data[pIter->index];




×







406













UNCOV

407



    pFileObj = pReader->status.pCurrentFileset->farr;




×








UNCOV

408



    if (pFileObj[0] != NULL || pFileObj[3] != NULL) {





×








UNCOV

409



      SDataFileReaderConfig conf = {.tsdb = pReader->pTsdb, .szPage = pReader->pTsdb->pVnode->config.tsdbPageSize};




×







410













UNCOV

411



      const char* filesName[4] = {0};




×







412













UNCOV

413



      if (pFileObj[0] != NULL) {





×








UNCOV

414



        conf.files[0].file = *pFileObj[0]->f;




×








UNCOV

415



        conf.files[0].exist = true;




×








UNCOV

416



        filesName[0] = pFileObj[0]->fname;




×







417













UNCOV

418



        conf.files[1].file = *pFileObj[1]->f;




×








UNCOV

419



        conf.files[1].exist = true;




×








UNCOV

420



        filesName[1] = pFileObj[1]->fname;




×







421













UNCOV

422



        conf.files[2].file = *pFileObj[2]->f;




×








UNCOV

423



        conf.files[2].exist = true;




×








UNCOV

424



        filesName[2] = pFileObj[2]->fname;




×







425



      }










426













UNCOV

427



      if (pFileObj[3] != NULL) {





×








UNCOV

428



        conf.files[3].exist = true;




×








UNCOV

429



        conf.files[3].file = *pFileObj[3]->f;




×








UNCOV

430



        filesName[3] = pFileObj[3]->fname;




×







431



      }










432













UNCOV

433



      code = tsdbDataFileReaderOpen(filesName, &conf, &pReader->pFileReader);




×








UNCOV

434



      TSDB_CHECK_CODE(code, lino, _end);





×







435













UNCOV

436



      pReader->cost.headFileLoad += 1;




×







437



    }










438













UNCOV

439



    int32_t fid = pReader->status.pCurrentFileset->fid;




×








UNCOV

440



    tsdbFidKeyRange(fid, pReader->pTsdb->keepCfg.days, pReader->pTsdb->keepCfg.precision, &win.skey, &win.ekey);




×







441












442



    // current file are no longer overlapped with query time window, ignore remain files











UNCOV

443



    if ((asc && win.skey > pReader->info.window.ekey) || (!asc && win.ekey < pReader->info.window.skey)) {





×








UNCOV

444



      tsdbDebug("%p remain files are not qualified for qrange:%" PRId64 "-%" PRId64 ", ignore, %s", pReader,





×







445



                pReader->info.window.skey, pReader->info.window.ekey, pReader->idStr);











UNCOV

446



      *hasNext = false;




×








UNCOV

447



      break;




×







448



    }










449













UNCOV

450



    if ((asc && (win.ekey < pReader->info.window.skey)) || ((!asc) && (win.skey > pReader->info.window.ekey))) {





×








UNCOV

451



      pIter->index += step;




×








UNCOV

452



      if ((asc && pIter->index >= pIter->numOfFiles) || ((!asc) && pIter->index < 0)) {





×








UNCOV

453



        *hasNext = false;




×








UNCOV

454



        break;




×







455



      }











UNCOV

456



      continue;




×







457



    }










458













UNCOV

459



    tsdbDebug("%p file found fid:%d for qrange:%" PRId64 "-%" PRId64 ", %s", pReader, fid, pReader->info.window.skey,





×







460



              pReader->info.window.ekey, pReader->idStr);










461













UNCOV

462



    *hasNext = true;




×








UNCOV

463



    break;




×







464



  }










465













UNCOV

466



_end:




×








UNCOV

467



  if (code != TSDB_CODE_SUCCESS) {





×







468



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





×







469



  }











UNCOV

470



  return code;




×







471



}










472













UNCOV

473



bool shouldFreePkBuf(SBlockLoadSuppInfo* pSupp) {




×








UNCOV

474



  return (pSupp != NULL) && (pSupp->numOfPks > 0) && IS_VAR_DATA_TYPE(pSupp->pk.type);





×







475



}










476













UNCOV

477



int32_t resetDataBlockIterator(SDataBlockIter* pIter, int32_t order, bool needFree, const char* id) {




×








UNCOV

478



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

479



  int32_t lino = 0;




×







480













UNCOV

481



  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







482













UNCOV

483



  pIter->order = order;




×








UNCOV

484



  pIter->index = -1;




×








UNCOV

485



  pIter->numOfBlocks = 0;




×







486













UNCOV

487



  if (pIter->blockList == NULL) {





×








UNCOV

488



    pIter->blockList = taosArrayInit(4, sizeof(SFileDataBlockInfo));




×








UNCOV

489



    if (pIter->blockList == NULL) {





×







490



      tsdbError("%s failed to reset block iter, func:%s at line:%d code:%s", id, __func__, __LINE__, tstrerror(terrno));





×







491



    }











UNCOV

492



    TSDB_CHECK_NULL(pIter->blockList, code, lino, _end, terrno);





×







493



  } else {











UNCOV

494



    clearDataBlockIterator(pIter, needFree);




×







495



  }










496













UNCOV

497



_end:




×








UNCOV

498



  if (code != TSDB_CODE_SUCCESS) {





×







499



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





×







500



  }











UNCOV

501



  return code;




×







502



}










503













UNCOV

504



static void initReaderStatus(SReaderStatus* pStatus) {




×








UNCOV

505



  if (pStatus == NULL) {





×







506



    return;




×







507



  }











UNCOV

508



  pStatus->pTableIter = NULL;




×








UNCOV

509



  pStatus->loadFromFile = true;




×







510



}










511













UNCOV

512



static int32_t createResBlock(SQueryTableDataCond* pCond, int32_t capacity, SSDataBlock** pResBlock) {




×








UNCOV

513



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

514



  int32_t      lino = 0;




×








UNCOV

515



  SSDataBlock* pBlock = NULL;




×







516













UNCOV

517



  TSDB_CHECK_NULL(pCond, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

518



  TSDB_CHECK_CONDITION(capacity >= 0, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

519



  TSDB_CHECK_NULL(pResBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







520













UNCOV

521



  code = createDataBlock(&pBlock);




×








UNCOV

522



  TSDB_CHECK_CODE(code, lino, _end);





×







523













UNCOV

524



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





×








UNCOV

525



    SColumnInfoData colInfo = {0};




×








UNCOV

526



    colInfo.info = pCond->colList[i];




×








UNCOV

527



    code = blockDataAppendColInfo(pBlock, &colInfo);




×








UNCOV

528



    TSDB_CHECK_CODE(code, lino, _end);





×







529



  }










530













UNCOV

531



  code = blockDataEnsureCapacity(pBlock, capacity);




×








UNCOV

532



  TSDB_CHECK_CODE(code, lino, _end);





×







533













UNCOV

534



  *pResBlock = pBlock;




×








UNCOV

535



  pBlock = NULL;




×







536













UNCOV

537



_end:




×








UNCOV

538



  if (code != TSDB_CODE_SUCCESS) {





×







539



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





×







540



  }











UNCOV

541



  if (pBlock) {





×







542



    taosArrayDestroy(pBlock->pDataBlock);




×







543



    taosMemoryFreeClear(pBlock);





×







544



  }











UNCOV

545



  return code;




×







546



}










547













UNCOV

548



static int32_t tsdbInitReaderLock(STsdbReader* pReader) {




×








UNCOV

549



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

550



  int32_t lino = 0;




×







551













UNCOV

552



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







553













UNCOV

554



  code = taosThreadMutexInit(&pReader->readerMutex, NULL);




×








UNCOV

555



  tsdbTrace("tsdb/read: %p, post-init read mutex: %p, code: %d", pReader, &pReader->readerMutex, code);





×








UNCOV

556



  TSDB_CHECK_CODE(code, lino, _end);





×







557













UNCOV

558



_end:




×








UNCOV

559



  if (code != TSDB_CODE_SUCCESS) {





×







560



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





×







561



  }











UNCOV

562



  return code;




×







563



}










564













UNCOV

565



static int32_t tsdbUninitReaderLock(STsdbReader* pReader) {




×








UNCOV

566



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

567



  int32_t lino = 0;




×







568













UNCOV

569



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







570













UNCOV

571



  tsdbTrace("tsdb/read: %p, pre-uninit read mutex: %p, code: %d", pReader, &pReader->readerMutex, code);





×








UNCOV

572



  code = taosThreadMutexDestroy(&pReader->readerMutex);




×








UNCOV

573



  tsdbTrace("tsdb/read: %p, post-uninit read mutex: %p, code: %d", pReader, &pReader->readerMutex, code);





×








UNCOV

574



  TSDB_CHECK_CODE(code, lino, _end);





×







575













UNCOV

576



_end:




×








UNCOV

577



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

578



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





×







579



  }











UNCOV

580



  return code;




×







581



}










582













UNCOV

583



static int32_t tsdbAcquireReader(STsdbReader* pReader) {




×








UNCOV

584



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

585



  int32_t lino = 0;




×







586













UNCOV

587



  TSDB_CHECK_CONDITION((pReader != NULL) && (pReader->idStr != NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);





×







588













UNCOV

589



  tsdbTrace("tsdb/read: %s, pre-take read mutex: %p, code: %d", pReader->idStr, &pReader->readerMutex, code);





×








UNCOV

590



  code = taosThreadMutexLock(&pReader->readerMutex);




×








UNCOV

591



  if (code != TSDB_CODE_SUCCESS) {





×







592



    tsdbError("tsdb/read:%p, failed to lock reader mutex, code:%s", pReader->idStr, tstrerror(code));





×







593



  } else {











UNCOV

594



    tsdbTrace("tsdb/read: %s, post-take read mutex: %p, code: %d", pReader->idStr, &pReader->readerMutex, code);





×







595



  }











UNCOV

596



  TSDB_CHECK_CODE(code, lino, _end);





×







597













UNCOV

598



_end:




×








UNCOV

599



  if (code != TSDB_CODE_SUCCESS) {





×







600



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





×







601



  }











UNCOV

602



  return code;




×







603



}










604












605



static int32_t tsdbTryAcquireReader(STsdbReader* pReader) {




×







606



  int32_t code = TSDB_CODE_SUCCESS;




×







607



  int32_t lino = 0;




×







608












609



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







610












611



  code = taosThreadMutexTryLock(&pReader->readerMutex);




×







612



  if (code != TSDB_CODE_SUCCESS) {





×







613



    // Failing to acquire the lock is reasonable, not an error










614



    tsdbWarn("tsdb/read: %p, post-trytake read mutex: %p, code: %d", pReader, &pReader->readerMutex, code);





×







615



  } else {










616



    tsdbTrace("tsdb/read: %p, post-trytask read mutex: %p", pReader, &pReader->readerMutex);





×







617



  }










618



  return code;




×







619












620



_end:




×







621



  if (code != TSDB_CODE_SUCCESS) {





×







622



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





×







623



  }










624



  return code;




×







625



}










626













UNCOV

627



static int32_t tsdbReleaseReader(STsdbReader* pReader) {




×








UNCOV

628



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

629



  int32_t lino = 0;




×







630













UNCOV

631



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







632













UNCOV

633



  code = taosThreadMutexUnlock(&pReader->readerMutex);




×








UNCOV

634



  if (code != TSDB_CODE_SUCCESS) {





×







635



    tsdbError("tsdb/read: %p post-untake read mutex:%p failed, code:%d", pReader, &pReader->readerMutex, code);





×







636



  } else {











UNCOV

637



    tsdbTrace("tsdb/read: %p, post-untake read mutex: %p", pReader, &pReader->readerMutex);





×







638



  }











UNCOV

639



  TSDB_CHECK_CODE(code, lino, _end);





×







640













UNCOV

641



_end:




×








UNCOV

642



  if (code != TSDB_CODE_SUCCESS) {





×







643



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





×







644



  }











UNCOV

645



  return code;




×







646



}










647













UNCOV

648



void tsdbReleaseDataBlock2(STsdbReader* pReader) {




×








UNCOV

649



  if (pReader == NULL) return;





×







650













UNCOV

651



  SReaderStatus* pStatus = &pReader->status;




×








UNCOV

652



  if (!pStatus->composedDataBlock) {





×








UNCOV

653



    (void) tsdbReleaseReader(pReader);




×







654



  }










655



}










656













UNCOV

657



static int32_t initResBlockInfo(SResultBlockInfo* pResBlockInfo, int64_t capacity, SSDataBlock* pResBlock,




×







658



                                SQueryTableDataCond* pCond, SBlockLoadSuppInfo* pSup) {











UNCOV

659



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

660



  int32_t      lino = 0;




×








UNCOV

661



  SSDataBlock* p = NULL;




×







662













UNCOV

663



  TSDB_CHECK_NULL(pResBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

664



  TSDB_CHECK_CONDITION((pResBlockInfo->pResBlock != NULL) || (pSup != NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);





×







665













UNCOV

666



  pResBlockInfo->capacity = capacity;




×








UNCOV

667



  pResBlockInfo->pResBlock = pResBlock;




×







668













UNCOV

669



  if (pResBlockInfo->pResBlock == NULL) {





×








UNCOV

670



    pResBlockInfo->freeBlock = true;




×








UNCOV

671



    pResBlockInfo->pResBlock = NULL;




×







672













UNCOV

673



    code = createResBlock(pCond, pResBlockInfo->capacity, &pResBlockInfo->pResBlock);




×








UNCOV

674



    TSDB_CHECK_CODE(code, lino, _end);





×







675













UNCOV

676



    if (pSup->numOfPks > 0) {





×







677



      p = pResBlockInfo->pResBlock;




×







678



      p->info.pks[0].type = pSup->pk.type;




×







679



      p->info.pks[1].type = pSup->pk.type;




×







680












681



      if (IS_VAR_DATA_TYPE(pSup->pk.type)) {





×







682



        p->info.pks[0].pData = taosMemoryCalloc(1, pSup->pk.bytes);





×







683



        TSDB_CHECK_NULL(p->info.pks[0].pData, code, lino, _end, terrno);





×







684












685



        p->info.pks[1].pData = taosMemoryCalloc(1, pSup->pk.bytes);





×







686



        TSDB_CHECK_NULL(p->info.pks[0].pData, code, lino, _end, terrno);





×







687












688



        p->info.pks[0].nData = pSup->pk.bytes;




×







689



        p->info.pks[1].nData = pSup->pk.bytes;




×







690



      }










691



    }










692



  } else {











UNCOV

693



    pResBlockInfo->freeBlock = false;




×







694



  }










695













UNCOV

696



_end:




×








UNCOV

697



  if (code != TSDB_CODE_SUCCESS) {





×







698



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





×







699



  }











UNCOV

700



  return code;




×







701



}










702













UNCOV

703



static int32_t tsdbReaderCreate(SVnode* pVnode, SQueryTableDataCond* pCond, void** ppReader, int32_t capacity,




×







704



                                SSDataBlock* pResBlock, const char* idstr) {











UNCOV

705



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

706



  int32_t             lino = 0;




×








UNCOV

707



  int8_t              level = 0;




×








UNCOV

708



  STsdbReader*        pReader = NULL;




×








UNCOV

709



  SBlockLoadSuppInfo* pSup = NULL;




×







710













UNCOV

711



  TSDB_CHECK_NULL(pVnode, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

712



  TSDB_CHECK_NULL(pCond, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

713



  TSDB_CHECK_NULL(ppReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







714













UNCOV

715



  *ppReader = NULL;




×








UNCOV

716



  pReader = (STsdbReader*)taosMemoryCalloc(1, sizeof(*pReader));





×








UNCOV

717



  TSDB_CHECK_NULL(pReader, code, lino, _end, terrno);





×







718













UNCOV

719



  if (VND_IS_TSMA(pVnode)) {





×







720



    tsdbDebug("vgId:%d, tsma is selected to query, %s", TD_VID(pVnode), idstr);





×







721



  }










722













UNCOV

723



  initReaderStatus(&pReader->status);




×








UNCOV

724



  getTsdbByRetentions(pVnode, pCond, pVnode->config.tsdbCfg.retentions, idstr, &level, &pReader->pTsdb);




×







725













UNCOV

726



  pReader->info.suid = pCond->suid;




×








UNCOV

727



  pReader->info.order = pCond->order;




×








UNCOV

728



  pReader->info.verRange = getQueryVerRange(pVnode, pCond, level);




×








UNCOV

729



  code = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows, &pReader->info.window);




×








UNCOV

730



  TSDB_CHECK_CODE(code, lino, _end);





×







731













UNCOV

732



  if (idstr == NULL) {





×








UNCOV

733



    idstr = "";




×







734



  }











UNCOV

735



  pReader->idStr = taosStrdup(idstr);





×








UNCOV

736



  TSDB_CHECK_NULL(pReader->idStr, code, lino, _end, terrno);





×







737













UNCOV

738



  pReader->type = pCond->type;




×








UNCOV

739



  pReader->bFilesetDelimited = false;




×








UNCOV

740



  pReader->blockInfoBuf.numPerBucket = 1000;  // 1000 tables per bucket




×







741













UNCOV

742



  if (pCond->numOfCols <= 0) {





×







743



    tsdbError("vgId:%d, invalid column number %d in query cond, %s", TD_VID(pVnode), pCond->numOfCols, idstr);





×







744



    TSDB_CHECK_CONDITION(pCond->numOfCols > 0, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







745



  }










746












747



  // allocate buffer in order to load data blocks from file











UNCOV

748



  pSup = &pReader->suppInfo;




×








UNCOV

749



  pSup->tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;




×








UNCOV

750



  code = setColumnIdSlotList(pSup, pCond->colList, pCond->pSlotList, pCond->numOfCols);




×








UNCOV

751



  TSDB_CHECK_CODE(code, lino, _end);





×







752













UNCOV

753



  code = initResBlockInfo(&pReader->resBlockInfo, capacity, pResBlock, pCond, pSup);




×








UNCOV

754



  TSDB_CHECK_CODE(code, lino, _end);





×







755













UNCOV

756



  code = tBlockDataCreate(&pReader->status.fileBlockData);




×








UNCOV

757



  TSDB_CHECK_CODE(code, lino, _end);





×







758













UNCOV

759



  if (pReader->suppInfo.colId[0] != PRIMARYKEY_TIMESTAMP_COL_ID) {





×







760



    tsdbError("the first column isn't primary timestamp, %d, %s", pReader->suppInfo.colId[0], pReader->idStr);





×







761



    TSDB_CHECK_CONDITION(pReader->suppInfo.colId[0] == PRIMARYKEY_TIMESTAMP_COL_ID, code, lino, _end,





×







762



                         TSDB_CODE_INVALID_PARA);










763



  }










764













UNCOV

765



  pReader->status.pPrimaryTsCol = taosArrayGet(pReader->resBlockInfo.pResBlock->pDataBlock, pSup->slotId[0]);




×








UNCOV

766



  TSDB_CHECK_NULL(pReader->status.pPrimaryTsCol, code, lino, _end, terrno);





×







767













UNCOV

768



  int32_t type = pReader->status.pPrimaryTsCol->info.type;




×








UNCOV

769



  if (type != TSDB_DATA_TYPE_TIMESTAMP) {





×







770



    tsdbError("the first column isn't primary timestamp in result block, actual: %s, %s", tDataTypes[type].name,





×







771



              pReader->idStr);










772



    TSDB_CHECK_CONDITION(type == TSDB_DATA_TYPE_TIMESTAMP, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







773



  }










774













UNCOV

775



  code = tsdbInitReaderLock(pReader);




×








UNCOV

776



  TSDB_CHECK_CODE(code, lino, _end);





×







777













UNCOV

778



  code = tsem_init(&pReader->resumeAfterSuspend, 0, 0);




×








UNCOV

779



  TSDB_CHECK_CODE(code, lino, _end);





×







780













UNCOV

781



  *ppReader = pReader;




×








UNCOV

782



  pReader = NULL;




×







783













UNCOV

784



_end:




×








UNCOV

785



  if (code != TSDB_CODE_SUCCESS) {





×







786



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





×







787



  }











UNCOV

788



  if (pReader) {





×







789



    tsdbReaderClose2(pReader);




×







790



  }











UNCOV

791



  return code;




×







792



}










793













UNCOV

794



static int32_t doLoadBlockIndex(STsdbReader* pReader, SDataFileReader* pFileReader, SArray* pIndexList) {




×








UNCOV

795



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

796



  int32_t              lino = 0;




×








UNCOV

797



  int32_t              st = 0;




×








UNCOV

798



  int32_t              et1 = 0;




×








UNCOV

799



  int32_t              et2 = 0;




×








UNCOV

800



  int32_t              numOfTables = 0;




×








UNCOV

801



  const TBrinBlkArray* pBlkArray = NULL;




×








UNCOV

802



  STableUidList*       pList = NULL;




×








UNCOV

803



  SBrinBlk*            pBrinBlk = NULL;




×







804













UNCOV

805



  if (pFileReader == NULL) {





×








UNCOV

806



    goto _end;




×







807



  }










808













UNCOV

809



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

810



  TSDB_CHECK_NULL(pIndexList, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







811













UNCOV

812



  st = taosGetTimestampUs();




×








UNCOV

813



  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);




×







814













UNCOV

815



  code = tsdbDataFileReadBrinBlk(pFileReader, &pBlkArray);




×








UNCOV

816



  TSDB_CHECK_CODE(code, lino, _end);





×







817












818



#if 0










819



  LRUHandle* handle = NULL;










820












821



  int32_t    code = tsdbCacheGetBlockIdx(pFileReader->pTsdb->biCache, pFileReader, &handle);










822



  if (code != TSDB_CODE_SUCCESS || handle == NULL) {










823



    goto _end;










824



  }










825












826












827



  SArray* aBlockIdx = (SArray*)taosLRUCacheValue(pFileReader->pTsdb->biCache, handle);










828



  size_t  num = taosArrayGetSize(aBlockIdx);










829



  if (num == 0) {










830



    tsdbBICacheRelease(pFileReader->pTsdb->biCache, handle);










831



    return TSDB_CODE_SUCCESS;










832



  }










833



#endif










834












835



  // todo binary search to the start position











UNCOV

836



  et1 = taosGetTimestampUs();




×







837













UNCOV

838



  pList = &pReader->status.uidList;




×







839













UNCOV

840



  int32_t i = 0;




×








UNCOV

841



  int32_t j = 0;




×








UNCOV

842



  while (i < TARRAY2_SIZE(pBlkArray)) {





×








UNCOV

843



    pBrinBlk = &pBlkArray->data[i];




×








UNCOV

844



    if (pBrinBlk->maxTbid.suid < pReader->info.suid) {





×








UNCOV

845



      i += 1;




×








UNCOV

846



      continue;




×







847



    }










848













UNCOV

849



    if (pBrinBlk->minTbid.suid > pReader->info.suid) {  // not include the queried table/super table, quit the loop





×








UNCOV

850



      break;




×







851



    }










852













UNCOV

853



    TSDB_CHECK_CONDITION(





×







854



        (pBrinBlk->minTbid.suid <= pReader->info.suid) && (pBrinBlk->maxTbid.suid >= pReader->info.suid), code, lino,










855



        _end, TSDB_CODE_INTERNAL_ERROR);










856













UNCOV

857



    if (pBrinBlk->maxTbid.suid == pReader->info.suid && pBrinBlk->maxTbid.uid < pList->tableUidList[j]) {





×








UNCOV

858



      i += 1;




×








UNCOV

859



      continue;




×







860



    }










861













UNCOV

862



    if (pBrinBlk->minTbid.suid == pReader->info.suid && pBrinBlk->minTbid.uid > pList->tableUidList[numOfTables - 1]) {





×








UNCOV

863



      break;




×







864



    }










865













UNCOV

866



    const void* p1 = taosArrayPush(pIndexList, pBrinBlk);




×








UNCOV

867



    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);





×







868













UNCOV

869



    i += 1;




×








UNCOV

870



    if (pBrinBlk->maxTbid.suid == pReader->info.suid) {





×








UNCOV

871



      while (j < numOfTables && pList->tableUidList[j] < pBrinBlk->maxTbid.uid) {





×








UNCOV

872



        j++;




×







873



      }











UNCOV

874



      if (j >= numOfTables) {





×








UNCOV

875



        break;




×







876



      }










877



    }










878



  }










879













UNCOV

880



  et2 = taosGetTimestampUs();




×








UNCOV

881



  tsdbDebug("load block index for %d/%d tables completed, elapsed time:%.2f ms, set BrinBlk:%.2f ms, size:%.2f Kb %s",





×







882



            numOfTables, (int32_t)pBlkArray->size, (et1 - st) / 1000.0, (et2 - et1) / 1000.0,










883



            pBlkArray->size * sizeof(SBrinBlk) / 1024.0, pReader->idStr);










884













UNCOV

885



  pReader->cost.headFileLoadTime += (et1 - st) / 1000.0;




×







886













UNCOV

887



_end:




×








UNCOV

888



  if (code != TSDB_CODE_SUCCESS) {





×







889



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





×







890



  }











UNCOV

891



  return code;




×







892



}










893













UNCOV

894



static int32_t loadFileBlockBrinInfo(STsdbReader* pReader, SArray* pIndexList, SBlockNumber* pBlockNum,




×







895



                                     SArray* pTableScanInfoList) {











UNCOV

896



  int32_t         code = TSDB_CODE_SUCCESS;




×








UNCOV

897



  int32_t         lino = 0;




×








UNCOV

898



  int64_t         st = 0;




×








UNCOV

899



  bool            asc = false;




×








UNCOV

900



  STimeWindow     w = {0};




×








UNCOV

901



  SBrinRecordIter iter = {0};




×








UNCOV

902



  int32_t         numOfTables = 0;




×








UNCOV

903



  SBrinRecord*    pRecord = NULL;




×








UNCOV

904



  int32_t         k = 0;




×








UNCOV

905



  size_t          sizeInDisk = 0;




×







906













UNCOV

907



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

908



  TSDB_CHECK_NULL(pBlockNum, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

909



  TSDB_CHECK_NULL(pTableScanInfoList, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







910













UNCOV

911



  st = taosGetTimestampUs();




×








UNCOV

912



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

913



  w = pReader->info.window;




×








UNCOV

914



  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);




×







915












916



  // clear info for the new file











UNCOV

917



  cleanupInfoForNextFileset(pReader->status.pTableMap);




×








UNCOV

918



  initBrinRecordIter(&iter, pReader->pFileReader, pIndexList);




×







919













UNCOV

920



  while (1) {




×








UNCOV

921



    code = getNextBrinRecord(&iter, &pRecord);




×








UNCOV

922



    TSDB_CHECK_CODE(code, lino, _end);





×







923













UNCOV

924



    if (pRecord == NULL) {





×








UNCOV

925



      break;




×







926



    }










927













UNCOV

928



    if (pRecord->suid > pReader->info.suid) {





×








UNCOV

929



      break;




×







930



    }










931













UNCOV

932



    uint64_t uid = pReader->status.uidList.tableUidList[k];




×








UNCOV

933



    if (pRecord->suid < pReader->info.suid) {





×








UNCOV

934



      continue;




×







935



    }










936













UNCOV

937



    if (uid < pRecord->uid) {  // forward the table uid index





×








UNCOV

938



      while (k < numOfTables && pReader->status.uidList.tableUidList[k] < pRecord->uid) {





×








UNCOV

939



        k += 1;




×







940



      }










941













UNCOV

942



      if (k >= numOfTables) {





×








UNCOV

943



        break;




×







944



      }










945













UNCOV

946



      uid = pReader->status.uidList.tableUidList[k];




×







947



    }










948













UNCOV

949



    if (pRecord->uid < uid) {





×








UNCOV

950



      continue;




×







951



    }










952













UNCOV

953



    TSDB_CHECK_CONDITION((pRecord->suid == pReader->info.suid) && (uid == pRecord->uid), code, lino, _end,





×







954



                         TSDB_CODE_INTERNAL_ERROR);










955













UNCOV

956



    STableBlockScanInfo* pScanInfo = NULL;




×








UNCOV

957



    code = getTableBlockScanInfo(pReader->status.pTableMap, uid, &pScanInfo, pReader->idStr);




×








UNCOV

958



    TSDB_CHECK_CODE(code, lino, _end);





×







959












960



    // here we should find the first timestamp that is greater than the lastProcKey










961



    // the window is an open interval NOW.











UNCOV

962



    if (asc) {





×








UNCOV

963



      w.skey = pScanInfo->lastProcKey.ts;




×







964



    } else {











UNCOV

965



      w.ekey = pScanInfo->lastProcKey.ts;




×







966



    }










967












968



    // NOTE: specialized for open interval











UNCOV

969



    if (((w.skey < INT64_MAX) && ((w.skey + 1) > w.ekey)) || (w.skey == INT64_MAX)) {





×







970



      k += 1;




×







971



      if (k >= numOfTables) {





×







972



        break;




×







973



      } else {










974



        continue;




×







975



      }










976



    }










977












978



    // 1. time range check











UNCOV

979



    if (pRecord->firstKey.key.ts > w.ekey || pRecord->lastKey.key.ts < w.skey) {





×








UNCOV

980



      continue;




×







981



    }










982



    // The data block's time range must intersect with the query time range











UNCOV

983



    if (pRecord->firstKey.key.ts > pReader->info.window.ekey || pRecord->lastKey.key.ts < pReader->info.window.skey) {





×







984



      continue;




×







985



    }










986













UNCOV

987



    if (asc) {





×








UNCOV

988



      if (pkCompEx(&pRecord->lastKey.key, &pScanInfo->lastProcKey) <= 0) {





×







989



        continue;




×







990



      }










991



    } else {











UNCOV

992



      if (pkCompEx(&pRecord->firstKey.key, &pScanInfo->lastProcKey) >= 0) {





×







993



        continue;




×







994



      }










995



    }










996












997



    // 2. version range check, version range is an CLOSED interval











UNCOV

998



    if (pRecord->minVer > pReader->info.verRange.maxVer || pRecord->maxVer < pReader->info.verRange.minVer) {





×








UNCOV

999



      continue;




×







1000



    }










1001













UNCOV

1002



    if (pScanInfo->pBlockList == NULL) {





×








UNCOV

1003



      pScanInfo->pBlockList = taosArrayInit(4, sizeof(SFileDataBlockInfo));




×








UNCOV

1004



      TSDB_CHECK_NULL(pScanInfo->pBlockList, code, lino, _end, terrno);





×







1005



    }










1006













UNCOV

1007



    if (pScanInfo->pBlockIdxList == NULL) {





×








UNCOV

1008



      pScanInfo->pBlockIdxList = taosArrayInit(4, sizeof(STableDataBlockIdx));




×








UNCOV

1009



      TSDB_CHECK_NULL(pScanInfo->pBlockIdxList, code, lino, _end, terrno);





×







1010



    }










1011













UNCOV

1012



    SFileDataBlockInfo blockInfo = {.tbBlockIdx = TARRAY_SIZE(pScanInfo->pBlockList)};




×








UNCOV

1013



    code = recordToBlockInfo(&blockInfo, pRecord);




×








UNCOV

1014



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

1015



    sizeInDisk += blockInfo.blockSize;




×







1016













UNCOV

1017



    const void* p1 = taosArrayPush(pScanInfo->pBlockList, &blockInfo);




×








UNCOV

1018



    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);





×







1019












1020



    // todo: refactor to record the fileset skey/ekey











UNCOV

1021



    if (pScanInfo->filesetWindow.skey > pRecord->firstKey.key.ts) {





×








UNCOV

1022



      pScanInfo->filesetWindow.skey = pRecord->firstKey.key.ts;




×







1023



    }










1024













UNCOV

1025



    if (pScanInfo->filesetWindow.ekey < pRecord->lastKey.key.ts) {





×








UNCOV

1026



      pScanInfo->filesetWindow.ekey = pRecord->lastKey.key.ts;




×







1027



    }










1028













UNCOV

1029



    pBlockNum->numOfBlocks += 1;




×








UNCOV

1030



    if (taosArrayGetSize(pTableScanInfoList) == 0) {





×








UNCOV

1031



      p1 = taosArrayPush(pTableScanInfoList, &pScanInfo);




×








UNCOV

1032



      TSDB_CHECK_NULL(p1, code, lino, _end, terrno);





×







1033



    } else {











UNCOV

1034



      STableBlockScanInfo** p = taosArrayGetLast(pTableScanInfoList);




×








UNCOV

1035



      TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1036













UNCOV

1037



      if ((*p)->uid != uid) {





×








UNCOV

1038



        p1 = taosArrayPush(pTableScanInfoList, &pScanInfo);




×








UNCOV

1039



        TSDB_CHECK_NULL(p1, code, lino, _end, terrno);





×







1040



      }










1041



    }










1042



  }










1043













UNCOV

1044



  pBlockNum->numOfSttFiles = pReader->status.pCurrentFileset->lvlArr->size;




×








UNCOV

1045



  int32_t total = pBlockNum->numOfSttFiles + pBlockNum->numOfBlocks;




×







1046













UNCOV

1047



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




×








UNCOV

1048



  tsdbDebug(





×







1049



      "load block of %d tables completed, blocks:%d in %d tables, stt-files:%d, block-info-size:%.2f Kb, elapsed "










1050



      "time:%.2f ms %s",










1051



      numOfTables, pBlockNum->numOfBlocks, (int32_t)taosArrayGetSize(pTableScanInfoList), pBlockNum->numOfSttFiles,










1052



      sizeInDisk / 1000.0, el, pReader->idStr);










1053













UNCOV

1054



  pReader->cost.numOfBlocks += total;




×








UNCOV

1055



  pReader->cost.headFileLoadTime += el;




×







1056













UNCOV

1057



_end:




×








UNCOV

1058



  if (code != TSDB_CODE_SUCCESS) {





×







1059



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





×







1060



  }











UNCOV

1061



  clearBrinBlockIter(&iter);




×








UNCOV

1062



  return code;




×







1063



}










1064













UNCOV

1065



static void setBlockAllDumped(SFileBlockDumpInfo* pDumpInfo, int64_t maxKey, int32_t order) {




×








UNCOV

1066



  if (pDumpInfo != NULL) {





×








UNCOV

1067



    pDumpInfo->allDumped = true;




×







1068



  }











UNCOV

1069



}




×







1070













UNCOV

1071



static int32_t updateLastKeyInfo(SRowKey* pKey, SFileDataBlockInfo* pBlockInfo, SDataBlockInfo* pInfo, int32_t numOfPks,




×







1072



                                 bool asc) {











UNCOV

1073



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1074



  int32_t lino = 0;




×







1075













UNCOV

1076



  TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1077



  TSDB_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1078













UNCOV

1079



  pKey->ts = asc ? pInfo->window.ekey : pInfo->window.skey;





×








UNCOV

1080



  pKey->numOfPKs = numOfPks;




×








UNCOV

1081



  if (pKey->numOfPKs <= 0) {





×








UNCOV

1082



    goto _end;




×







1083



  }










1084













UNCOV

1085



  TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1086



  if (IS_NUMERIC_TYPE(pKey->pks[0].type)) {





×








UNCOV

1087



    pKey->pks[0].val = asc ? pBlockInfo->lastPk.val : pBlockInfo->firstPk.val;





×







1088



  } else {










1089



    uint8_t* p = asc ? pBlockInfo->lastPk.pData : pBlockInfo->firstPk.pData;





×







1090



    pKey->pks[0].nData = asc ? varDataLen(pBlockInfo->lastPk.pData) : varDataLen(pBlockInfo->firstPk.pData);





×







1091



    TAOS_MEMCPY(pKey->pks[0].pData, p, pKey->pks[0].nData);




×







1092



  }










1093













UNCOV

1094



_end:




×








UNCOV

1095



  if (code != TSDB_CODE_SUCCESS) {





×







1096



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





×







1097



  }











UNCOV

1098



  return code;




×







1099



}










1100













UNCOV

1101



static int32_t doCopyColVal(SColumnInfoData* pColInfoData, int32_t rowIndex, int32_t colIndex, SColVal* pColVal,




×







1102



                            SBlockLoadSuppInfo* pSup) {











UNCOV

1103



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1104



  int32_t lino = 0;




×







1105













UNCOV

1106



  TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1107



  TSDB_CHECK_NULL(pColVal, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1108













UNCOV

1109



  if (IS_VAR_DATA_TYPE(pColVal->value.type)) {





×








UNCOV

1110



    if (!COL_VAL_IS_VALUE(pColVal)) {





×








UNCOV

1111



      colDataSetNULL(pColInfoData, rowIndex);





×







1112



    } else {











UNCOV

1113



      TSDB_CHECK_NULL(pSup, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1114



      varDataSetLen(pSup->buildBuf[colIndex], pColVal->value.nData);




×








UNCOV

1115



      if ((pColVal->value.nData + VARSTR_HEADER_SIZE) > pColInfoData->info.bytes) {





×








UNCOV

1116



        tsdbWarn("column cid:%d actual data len %d is bigger than schema len %d", pColVal->cid, pColVal->value.nData,





×







1117



                 pColInfoData->info.bytes);











UNCOV

1118



        code = TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER;




×








UNCOV

1119



        TSDB_CHECK_CODE(code, lino, _end);





×







1120



      }










1121













UNCOV

1122



      if (pColVal->value.nData > 0) {  // pData may be null, if nData is 0





×








UNCOV

1123



        (void)memcpy(varDataVal(pSup->buildBuf[colIndex]), pColVal->value.pData, pColVal->value.nData);




×







1124



      }










1125













UNCOV

1126



      code = colDataSetVal(pColInfoData, rowIndex, pSup->buildBuf[colIndex], false);




×








UNCOV

1127



      TSDB_CHECK_CODE(code, lino, _end);





×







1128



    }










1129



  } else {











UNCOV

1130



    code = colDataSetVal(pColInfoData, rowIndex, (const char*)&pColVal->value.val, !COL_VAL_IS_VALUE(pColVal));




×








UNCOV

1131



    TSDB_CHECK_CODE(code, lino, _end);





×







1132



  }










1133













UNCOV

1134



_end:




×








UNCOV

1135



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

1136



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





×







1137



  }











UNCOV

1138



  return code;




×







1139



}










1140













UNCOV

1141



static int32_t getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInfo** pInfo, const char* id) {




×








UNCOV

1142



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1143



  int32_t lino = 0;




×







1144













UNCOV

1145



  TSDB_CHECK_NULL(pBlockIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1146



  TSDB_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1147



  TSDB_CHECK_NULL(pBlockIter->blockList, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1148













UNCOV

1149



  *pInfo = NULL;




×







1150













UNCOV

1151



  size_t num = TARRAY_SIZE(pBlockIter->blockList);




×








UNCOV

1152



  if (num == 0) {





×







1153



    // Some callers would attempt to call this function. Filter out certain normal cases and return directly to avoid










1154



    // generating excessive unnecessary error logs.











UNCOV

1155



    TSDB_CHECK_CONDITION(num == pBlockIter->numOfBlocks, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1156



    return TSDB_CODE_INVALID_PARA;




×







1157



  }










1158













UNCOV

1159



  *pInfo = taosArrayGet(pBlockIter->blockList, pBlockIter->index);




×








UNCOV

1160



  TSDB_CHECK_NULL(*pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1161













UNCOV

1162



_end:




×








UNCOV

1163



  if (code != TSDB_CODE_SUCCESS) {





×







1164



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





×







1165



  }











UNCOV

1166



  return code;




×







1167



}










1168













UNCOV

1169



static int32_t doBinarySearchKey(const TSKEY* keyList, int num, int pos, TSKEY key, int order) {




×







1170



  // start end position










1171



  int s, e;











UNCOV

1172



  s = pos;




×







1173












1174



  // check











UNCOV

1175



  if (!(keyList != NULL && pos >= 0 && pos < num && num > 0)) {





×







1176



    return -1;




×







1177



  }











UNCOV

1178



  if (order == TSDB_ORDER_ASC) {





×







1179



    // find the first position which is smaller than the key











UNCOV

1180



    e = num - 1;




×








UNCOV

1181



    if (key < keyList[pos]) return -1;





×








UNCOV

1182



    while (1) {




×







1183



      // check can return











UNCOV

1184



      if (key >= keyList[e]) return e;





×








UNCOV

1185



      if (key <= keyList[s]) return s;





×








UNCOV

1186



      if (e - s <= 1) return s;





×







1187












1188



      // change start or end position











UNCOV

1189



      int mid = s + (e - s + 1) / 2;




×








UNCOV

1190



      if (keyList[mid] > key)





×








UNCOV

1191



        e = mid;




×








UNCOV

1192



      else if (keyList[mid] < key)





×








UNCOV

1193



        s = mid;




×







1194



      else











UNCOV

1195



        return mid;




×







1196



    }










1197



  } else {  // DESC










1198



    // find the first position which is bigger than the key











UNCOV

1199



    e = 0;




×








UNCOV

1200



    if (key > keyList[pos]) return -1;





×








UNCOV

1201



    while (1) {




×







1202



      // check can return











UNCOV

1203



      if (key <= keyList[e]) return e;





×








UNCOV

1204



      if (key >= keyList[s]) return s;





×








UNCOV

1205



      if (s - e <= 1) return s;





×







1206












1207



      // change start or end position











UNCOV

1208



      int mid = s - (s - e + 1) / 2;




×








UNCOV

1209



      if (keyList[mid] < key)





×








UNCOV

1210



        e = mid;




×








UNCOV

1211



      else if (keyList[mid] > key)





×








UNCOV

1212



        s = mid;




×







1213



      else











UNCOV

1214



        return mid;




×







1215



    }










1216



  }










1217



}










1218












1219



// handle the repeat ts cases.











UNCOV

1220



static int32_t findFirstPos(const int64_t* pTsList, int32_t num, int32_t startPos, bool asc) {




×








UNCOV

1221



  int32_t i = startPos;




×








UNCOV

1222



  int64_t startTs = pTsList[startPos];




×








UNCOV

1223



  if (asc) {





×








UNCOV

1224



    while (i < num && (pTsList[i] == startTs)) {





×








UNCOV

1225



      i++;




×







1226



    }











UNCOV

1227



    return i - 1;




×







1228



  } else {











UNCOV

1229



    while (i >= 0 && (pTsList[i] == startTs)) {





×








UNCOV

1230



      i--;




×







1231



    }











UNCOV

1232



    return i + 1;




×







1233



  }










1234



}










1235













UNCOV

1236



static int32_t getEndPosInDataBlock(STsdbReader* pReader, SBlockData* pBlockData, SBrinRecord* pRecord, int32_t pos) {




×







1237



  // NOTE: reverse the order to find the end position in data block











UNCOV

1238



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1239



  int32_t lino = 0;




×








UNCOV

1240



  int32_t endPos = -1;




×








UNCOV

1241



  bool    asc = false;




×







1242













UNCOV

1243



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1244



  TSDB_CHECK_NULL(pRecord, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1245













UNCOV

1246



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×







1247













UNCOV

1248



  if (asc && pReader->info.window.ekey >= pRecord->lastKey.key.ts) {





×








UNCOV

1249



    endPos = pRecord->numRow - 1;




×








UNCOV

1250



  } else if (!asc && pReader->info.window.skey <= pRecord->firstKey.key.ts) {





×








UNCOV

1251



    endPos = 0;




×







1252



  } else {











UNCOV

1253



    int64_t key = asc ? pReader->info.window.ekey : pReader->info.window.skey;





×








UNCOV

1254



    endPos = doBinarySearchKey(pBlockData->aTSKEY, pRecord->numRow, pos, key, pReader->info.order);




×








UNCOV

1255



    if (endPos == -1) {





×







1256



      goto _end;




×







1257



    }










1258













UNCOV

1259



    endPos = findFirstPos(pBlockData->aTSKEY, pRecord->numRow, endPos, asc);




×







1260



  }










1261













UNCOV

1262



  if ((pReader->info.verRange.maxVer >= pRecord->minVer && pReader->info.verRange.maxVer < pRecord->maxVer) ||





×








UNCOV

1263



      (pReader->info.verRange.minVer <= pRecord->maxVer && pReader->info.verRange.minVer > pRecord->minVer)) {





×







1264



    int32_t i = endPos;




×







1265












1266



    if (asc) {





×







1267



      for (; i >= 0; --i) {





×







1268



        if (pBlockData->aVersion[i] <= pReader->info.verRange.maxVer) {





×







1269



          break;




×







1270



        }










1271



      }










1272



    } else {










1273



      for (; i < pRecord->numRow; ++i) {





×







1274



        if (pBlockData->aVersion[i] >= pReader->info.verRange.minVer) {





×







1275



          break;




×







1276



        }










1277



      }










1278



    }










1279












1280



    endPos = i;




×







1281



  }










1282













UNCOV

1283



_end:




×








UNCOV

1284



  if (code != TSDB_CODE_SUCCESS) {





×







1285



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





×







1286



  }











UNCOV

1287



  return endPos;




×







1288



}










1289













UNCOV

1290



static int32_t copyPrimaryTsCol(const SBlockData* pBlockData, SFileBlockDumpInfo* pDumpInfo, SColumnInfoData* pColData,




×







1291



                                int32_t dumpedRows, bool asc) {











UNCOV

1292



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1293



  int32_t lino = 0;




×







1294













UNCOV

1295



  TSDB_CHECK_CONDITION((pBlockData != NULL) && (pBlockData->aTSKEY != NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1296



  TSDB_CHECK_NULL(pDumpInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1297



  TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1298



  TSDB_CHECK_CONDITION(dumpedRows >= 0, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1299













UNCOV

1300



  if (asc) {





×








UNCOV

1301



    TAOS_MEMCPY(pColData->pData, &pBlockData->aTSKEY[pDumpInfo->rowIndex], dumpedRows * sizeof(int64_t));




×







1302



  } else {











UNCOV

1303



    int32_t startIndex = pDumpInfo->rowIndex - dumpedRows + 1;




×








UNCOV

1304



    TAOS_MEMCPY(pColData->pData, &pBlockData->aTSKEY[startIndex], dumpedRows * sizeof(int64_t));




×







1305












1306



    // todo: opt perf by extract the loop










1307



    // reverse the array list











UNCOV

1308



    int32_t  mid = dumpedRows >> 1u;




×








UNCOV

1309



    int64_t* pts = (int64_t*)pColData->pData;




×








UNCOV

1310



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





×








UNCOV

1311



      int64_t t = pts[j];




×








UNCOV

1312



      pts[j] = pts[dumpedRows - j - 1];




×








UNCOV

1313



      pts[dumpedRows - j - 1] = t;




×







1314



    }










1315



  }










1316













UNCOV

1317



_end:




×








UNCOV

1318



  if (code != TSDB_CODE_SUCCESS) {





×







1319



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





×







1320



  }











UNCOV

1321



  return code;




×







1322



}










1323












1324



// a faster version of copy procedure.











UNCOV

1325



static int32_t copyNumericCols(const SColData* pData, SFileBlockDumpInfo* pDumpInfo, SColumnInfoData* pColData,




×







1326



                               int32_t dumpedRows, bool asc) {











UNCOV

1327



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

1328



  int32_t  lino = 0;




×








UNCOV

1329



  uint8_t* p = NULL;




×








UNCOV

1330



  int32_t  step = asc ? 1 : -1;





×







1331













UNCOV

1332



  TSDB_CHECK_NULL(pData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1333



  TSDB_CHECK_NULL(pDumpInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1334



  TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1335



  TSDB_CHECK_CONDITION(dumpedRows >= 0, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1336













UNCOV

1337



  TSDB_CHECK_CONDITION(pData->type < TSDB_DATA_TYPE_MAX, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1338



  if (asc) {





×








UNCOV

1339



    p = pData->pData + tDataTypes[pData->type].bytes * pDumpInfo->rowIndex;




×







1340



  } else {










1341



    int32_t startIndex = pDumpInfo->rowIndex - dumpedRows + 1;




×







1342



    p = pData->pData + tDataTypes[pData->type].bytes * startIndex;




×







1343



  }










1344












1345



  // make sure it is aligned to 8bit, the allocated memory address is aligned to 256bit










1346












1347



  // 1. copy data in a batch model











UNCOV

1348



  TAOS_MEMCPY(pColData->pData, p, dumpedRows * tDataTypes[pData->type].bytes);




×







1349












1350



  // 2. reverse the array list in case of descending order scan data block











UNCOV

1351



  if (!asc) {





×








UNCOV

1352



    switch (pColData->info.type) {





×








UNCOV

1353



      case TSDB_DATA_TYPE_TIMESTAMP:




×







1354



      case TSDB_DATA_TYPE_DOUBLE:










1355



      case TSDB_DATA_TYPE_BIGINT:










1356



      case TSDB_DATA_TYPE_UBIGINT: {











UNCOV

1357



        int32_t  mid = dumpedRows >> 1u;




×








UNCOV

1358



        int64_t* pts = (int64_t*)pColData->pData;




×








UNCOV

1359



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





×








UNCOV

1360



          int64_t t = pts[j];




×








UNCOV

1361



          pts[j] = pts[dumpedRows - j - 1];




×








UNCOV

1362



          pts[dumpedRows - j - 1] = t;




×







1363



        }











UNCOV

1364



        break;




×







1365



      }










1366












1367



      case TSDB_DATA_TYPE_BOOL:




×







1368



      case TSDB_DATA_TYPE_TINYINT:










1369



      case TSDB_DATA_TYPE_UTINYINT: {










1370



        int32_t mid = dumpedRows >> 1u;




×







1371



        int8_t* pts = (int8_t*)pColData->pData;




×







1372



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





×







1373



          int8_t t = pts[j];




×







1374



          pts[j] = pts[dumpedRows - j - 1];




×







1375



          pts[dumpedRows - j - 1] = t;




×







1376



        }










1377



        break;




×







1378



      }










1379












1380



      case TSDB_DATA_TYPE_SMALLINT:




×







1381



      case TSDB_DATA_TYPE_USMALLINT: {










1382



        int32_t  mid = dumpedRows >> 1u;




×







1383



        int16_t* pts = (int16_t*)pColData->pData;




×







1384



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





×







1385



          int64_t t = pts[j];




×







1386



          pts[j] = pts[dumpedRows - j - 1];




×







1387



          pts[dumpedRows - j - 1] = t;




×







1388



        }










1389



        break;




×







1390



      }










1391












1392



      case TSDB_DATA_TYPE_FLOAT:




×







1393



      case TSDB_DATA_TYPE_INT:










1394



      case TSDB_DATA_TYPE_UINT: {










1395



        int32_t  mid = dumpedRows >> 1u;




×







1396



        int32_t* pts = (int32_t*)pColData->pData;




×







1397



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





×







1398



          int32_t t = pts[j];




×







1399



          pts[j] = pts[dumpedRows - j - 1];




×







1400



          pts[dumpedRows - j - 1] = t;




×







1401



        }










1402



        break;




×







1403



      }










1404



    }










1405



  }










1406












1407



  // 3. if the  null value exists, check items one-by-one











UNCOV

1408



  if (pData->flag != HAS_VALUE) {





×








UNCOV

1409



    int32_t rowIndex = 0;




×







1410













UNCOV

1411



    for (int32_t j = pDumpInfo->rowIndex; rowIndex < dumpedRows; j += step, rowIndex++) {





×








UNCOV

1412



      uint8_t v = tColDataGetBitValue(pData, j);




×








UNCOV

1413



      if (v == 0 || v == 1) {





×








UNCOV

1414



        colDataSetNull_f(pColData->nullbitmap, rowIndex);




×








UNCOV

1415



        pColData->hasNull = true;




×







1416



      }










1417



    }










1418



  }










1419













UNCOV

1420



_end:




×








UNCOV

1421



  if (code != TSDB_CODE_SUCCESS) {





×







1422



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





×







1423



  }











UNCOV

1424



  return code;




×







1425



}










1426













UNCOV

1427



static void blockInfoToRecord(SBrinRecord* record, SFileDataBlockInfo* pBlockInfo, SBlockLoadSuppInfo* pSupp) {




×








UNCOV

1428



  record->uid = pBlockInfo->uid;




×








UNCOV

1429



  record->firstKey = (STsdbRowKey){.key = {.ts = pBlockInfo->firstKey, .numOfPKs = pSupp->numOfPks}};




×








UNCOV

1430



  record->lastKey = (STsdbRowKey){.key = {.ts = pBlockInfo->lastKey, .numOfPKs = pSupp->numOfPks}};




×







1431













UNCOV

1432



  if (pSupp->numOfPks > 0) {





×








UNCOV

1433



    SValue* pFirst = &record->firstKey.key.pks[0];




×








UNCOV

1434



    SValue* pLast = &record->lastKey.key.pks[0];




×







1435













UNCOV

1436



    pFirst->type = pSupp->pk.type;




×








UNCOV

1437



    pLast->type = pSupp->pk.type;




×







1438













UNCOV

1439



    if (IS_VAR_DATA_TYPE(pFirst->type)) {





×







1440



      pFirst->pData = (uint8_t*)varDataVal(pBlockInfo->firstPk.pData);




×







1441



      pFirst->nData = varDataLen(pBlockInfo->firstPk.pData);




×







1442












1443



      pLast->pData = (uint8_t*)varDataVal(pBlockInfo->lastPk.pData);




×







1444



      pLast->nData = varDataLen(pBlockInfo->lastPk.pData);




×







1445



    } else {











UNCOV

1446



      pFirst->val = pBlockInfo->firstPk.val;




×








UNCOV

1447



      pLast->val = pBlockInfo->lastPk.val;




×







1448



    }










1449



  }










1450













UNCOV

1451



  record->minVer = pBlockInfo->minVer;




×








UNCOV

1452



  record->maxVer = pBlockInfo->maxVer;




×








UNCOV

1453



  record->blockOffset = pBlockInfo->blockOffset;




×








UNCOV

1454



  record->smaOffset = pBlockInfo->smaOffset;




×








UNCOV

1455



  record->blockSize = pBlockInfo->blockSize;




×








UNCOV

1456



  record->blockKeySize = pBlockInfo->blockKeySize;




×








UNCOV

1457



  record->smaSize = pBlockInfo->smaSize;




×








UNCOV

1458



  record->numRow = pBlockInfo->numRow;




×








UNCOV

1459



  record->count = pBlockInfo->count;




×








UNCOV

1460



}




×







1461













UNCOV

1462



static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, SRowKey* pLastProcKey) {




×








UNCOV

1463



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

1464



  int32_t             lino = 0;




×








UNCOV

1465



  SReaderStatus*      pStatus = NULL;




×








UNCOV

1466



  SDataBlockIter*     pBlockIter = NULL;




×








UNCOV

1467



  SBlockLoadSuppInfo* pSupInfo = NULL;




×








UNCOV

1468



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

1469



  SBlockData*         pBlockData = NULL;




×








UNCOV

1470



  SFileDataBlockInfo* pBlockInfo = NULL;




×








UNCOV

1471



  SSDataBlock*        pResBlock = NULL;




×








UNCOV

1472



  int32_t             numOfOutputCols = 0;




×








UNCOV

1473



  int64_t             st = 0;




×








UNCOV

1474



  bool                asc = false;




×








UNCOV

1475



  int32_t             step = 0;




×








UNCOV

1476



  SColVal             cv = {0};




×







1477



  SBrinRecord         tmp;











UNCOV

1478



  SBrinRecord*        pRecord = NULL;




×







1479













UNCOV

1480



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1481













UNCOV

1482



  pStatus = &pReader->status;




×








UNCOV

1483



  pBlockIter = &pStatus->blockIter;




×








UNCOV

1484



  pSupInfo = &pReader->suppInfo;




×








UNCOV

1485



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







1486













UNCOV

1487



  pBlockData = &pStatus->fileBlockData;




×








UNCOV

1488



  pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

1489



  numOfOutputCols = pSupInfo->numOfCols;




×








UNCOV

1490



  st = taosGetTimestampUs();




×








UNCOV

1491



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

1492



  step = asc ? 1 : -1;





×







1493













UNCOV

1494



  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

1495



  TSDB_CHECK_CODE(code, lino, _end);





×







1496













UNCOV

1497



  blockInfoToRecord(&tmp, pBlockInfo, pSupInfo);




×








UNCOV

1498



  pRecord = &tmp;




×







1499












1500



  // no data exists, return directly.











UNCOV

1501



  if (pBlockData->nRow == 0 || pBlockData->aTSKEY == 0) {





×







1502



    tsdbWarn("%p no need to copy since no data in blockData, table uid:%" PRIu64 " has been dropped, %s", pReader,





×







1503



             pBlockInfo->uid, pReader->idStr);










1504



    pResBlock->info.rows = 0;




×







1505



    goto _end;




×







1506



  }










1507













UNCOV

1508



  TSDB_CHECK_CONDITION((pDumpInfo->rowIndex >= 0) && (pDumpInfo->rowIndex < pRecord->numRow), code, lino, _end,





×







1509



                       TSDB_CODE_INVALID_PARA);










1510












1511



  // row index of dump info remain the initial position, let's find the appropriate start position.











UNCOV

1512



  if (((pDumpInfo->rowIndex == 0) && asc) || ((pDumpInfo->rowIndex == (pRecord->numRow - 1)) && (!asc))) {





×








UNCOV

1513



    if (asc && pReader->info.window.skey <= pRecord->firstKey.key.ts &&





×








UNCOV

1514



        pReader->info.verRange.minVer <= pRecord->minVer) {





×







1515



      // pDumpInfo->rowIndex = 0;











UNCOV

1516



    } else if (!asc && pReader->info.window.ekey >= pRecord->lastKey.key.ts &&





×








UNCOV

1517



               pReader->info.verRange.maxVer >= pRecord->maxVer) {





×







1518



      // pDumpInfo->rowIndex = pRecord->numRow - 1;










1519



    } else {  // find the appropriate the start position in current block, and set it to be the current rowIndex











UNCOV

1520



      int32_t pos = asc ? pRecord->numRow - 1 : 0;





×








UNCOV

1521



      int32_t order = asc ? TSDB_ORDER_DESC : TSDB_ORDER_ASC;





×








UNCOV

1522



      int64_t key = asc ? pReader->info.window.skey : pReader->info.window.ekey;





×








UNCOV

1523



      pDumpInfo->rowIndex = doBinarySearchKey(pBlockData->aTSKEY, pRecord->numRow, pos, key, order);




×







1524













UNCOV

1525



      if (pDumpInfo->rowIndex < 0) {





×







1526



        tsdbError(





×







1527



            "%p failed to locate the start position in current block, global index:%d, table index:%d, brange:%" PRId64










1528



            "-%" PRId64 ", minVer:%" PRId64 ", maxVer:%" PRId64 " %s",










1529



            pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pRecord->firstKey.key.ts, pRecord->lastKey.key.ts,










1530



            pRecord->minVer, pRecord->maxVer, pReader->idStr);










1531



        code = TSDB_CODE_INVALID_PARA;




×







1532



        TSDB_CHECK_CODE(code, lino, _end);





×







1533



      }










1534













UNCOV

1535



      pDumpInfo->rowIndex = findFirstPos(pBlockData->aTSKEY, pRecord->numRow, pDumpInfo->rowIndex, (!asc));




×







1536













UNCOV

1537



      TSDB_CHECK_CONDITION(





×







1538



          (pReader->info.verRange.minVer <= pRecord->maxVer && pReader->info.verRange.maxVer >= pRecord->minVer), code,










1539



          lino, _end, TSDB_CODE_INVALID_PARA);










1540












1541



      // find the appropriate start position that satisfies the version requirement.











UNCOV

1542



      if ((pReader->info.verRange.maxVer >= pRecord->minVer && pReader->info.verRange.maxVer < pRecord->maxVer) ||





×








UNCOV

1543



          (pReader->info.verRange.minVer <= pRecord->maxVer && pReader->info.verRange.minVer > pRecord->minVer)) {





×







1544



        int32_t i = pDumpInfo->rowIndex;




×







1545



        if (asc) {





×







1546



          for (; i < pRecord->numRow; ++i) {





×







1547



            if (pBlockData->aVersion[i] >= pReader->info.verRange.minVer) {





×







1548



              break;




×







1549



            }










1550



          }










1551



        } else {










1552



          for (; i >= 0; --i) {





×







1553



            if (pBlockData->aVersion[i] <= pReader->info.verRange.maxVer) {





×







1554



              break;




×







1555



            }










1556



          }










1557



        }










1558












1559



        pDumpInfo->rowIndex = i;




×







1560



      }










1561



    }










1562



  }










1563












1564



  // time window check











UNCOV

1565



  int32_t endIndex = getEndPosInDataBlock(pReader, pBlockData, pRecord, pDumpInfo->rowIndex);




×








UNCOV

1566



  if (endIndex == -1) {





×







1567



    setBlockAllDumped(pDumpInfo, pReader->info.window.ekey, pReader->info.order);




×







1568



    goto _end;




×







1569



  }










1570













UNCOV

1571



  endIndex += step;




×








UNCOV

1572



  int32_t dumpedRows = asc ? (endIndex - pDumpInfo->rowIndex) : (pDumpInfo->rowIndex - endIndex);





×








UNCOV

1573



  if (dumpedRows > pReader->resBlockInfo.capacity) {  // output buffer check





×







1574



    dumpedRows = pReader->resBlockInfo.capacity;




×








UNCOV

1575



  } else if (dumpedRows <= 0) {  // no qualified rows in current data block, quit directly.





×







1576



    setBlockAllDumped(pDumpInfo, pReader->info.window.ekey, pReader->info.order);




×







1577



    goto _end;




×







1578



  }










1579













UNCOV

1580



  int32_t i = 0;




×








UNCOV

1581



  int32_t rowIndex = 0;




×







1582













UNCOV

1583



  SColumnInfoData* pColData = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

1584



  TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1585













UNCOV

1586



  if (pSupInfo->colId[i] == PRIMARYKEY_TIMESTAMP_COL_ID) {





×








UNCOV

1587



    code = copyPrimaryTsCol(pBlockData, pDumpInfo, pColData, dumpedRows, asc);




×








UNCOV

1588



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

1589



    i += 1;




×







1590



  }










1591













UNCOV

1592



  int32_t colIndex = 0;




×








UNCOV

1593



  int32_t num = pBlockData->nColData;




×








UNCOV

1594



  while (i < numOfOutputCols && colIndex < num) {





×








UNCOV

1595



    rowIndex = 0;




×







1596













UNCOV

1597



    SColData* pData = tBlockDataGetColDataByIdx(pBlockData, colIndex);




×








UNCOV

1598



    if (pData->cid < pSupInfo->colId[i]) {





×







1599



      colIndex += 1;




×








UNCOV

1600



    } else if (pData->cid == pSupInfo->colId[i]) {





×








UNCOV

1601



      pColData = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

1602



      TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1603













UNCOV

1604



      if (pData->flag == HAS_NONE || pData->flag == HAS_NULL || pData->flag == (HAS_NULL | HAS_NONE)) {





×








UNCOV

1605



        colDataSetNNULL(pColData, 0, dumpedRows);





×







1606



      } else {











UNCOV

1607



        if (IS_MATHABLE_TYPE(pColData->info.type)) {





×








UNCOV

1608



          code = copyNumericCols(pData, pDumpInfo, pColData, dumpedRows, asc);




×








UNCOV

1609



          TSDB_CHECK_CODE(code, lino, _end);





×







1610



        } else {  // varchar/nchar type











UNCOV

1611



          for (int32_t j = pDumpInfo->rowIndex; rowIndex < dumpedRows; j += step) {





×








UNCOV

1612



            code = tColDataGetValue(pData, j, &cv);




×








UNCOV

1613



            TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

1614



            code = doCopyColVal(pColData, rowIndex++, i, &cv, pSupInfo);




×








UNCOV

1615



            TSDB_CHECK_CODE(code, lino, _end);





×







1616



          }










1617



        }










1618



      }










1619













UNCOV

1620



      colIndex += 1;




×








UNCOV

1621



      i += 1;




×







1622



    } else {  // the specified column does not exist in file block, fill with null data










1623



      pColData = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);




×







1624



      TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1625












1626



      colDataSetNNULL(pColData, 0, dumpedRows);





×







1627



      i += 1;




×







1628



    }










1629



  }










1630












1631



  // fill the mis-matched columns with null value











UNCOV

1632



  while (i < numOfOutputCols) {





×







1633



    pColData = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);




×







1634



    TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1635












1636



    colDataSetNNULL(pColData, 0, dumpedRows);





×







1637



    i += 1;




×







1638



  }










1639













UNCOV

1640



  pResBlock->info.dataLoad = 1;




×








UNCOV

1641



  pResBlock->info.rows = dumpedRows;




×








UNCOV

1642



  pDumpInfo->rowIndex += step * dumpedRows;




×







1643













UNCOV

1644



  tColRowGetKeyDeepCopy(pBlockData, pDumpInfo->rowIndex - step, pSupInfo->pkSrcSlot, pLastProcKey);





×







1645












1646



  // check if current block are all handled











UNCOV

1647



  if (pDumpInfo->rowIndex >= 0 && pDumpInfo->rowIndex < pRecord->numRow) {





×








UNCOV

1648



    int64_t ts = pBlockData->aTSKEY[pDumpInfo->rowIndex];




×







1649












1650



    // the remain data has out of query time window, ignore current block











UNCOV

1651



    if (outOfTimeWindow(ts, &pReader->info.window)) {





×








UNCOV

1652



      setBlockAllDumped(pDumpInfo, ts, pReader->info.order);




×







1653



    }










1654



  } else {











UNCOV

1655



    int64_t ts = asc ? pRecord->lastKey.key.ts : pRecord->firstKey.key.ts;





×








UNCOV

1656



    setBlockAllDumped(pDumpInfo, ts, pReader->info.order);




×







1657



  }










1658













UNCOV

1659



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




×








UNCOV

1660



  pReader->cost.blockLoadTime += elapsedTime;




×







1661













UNCOV

1662



  int32_t unDumpedRows = asc ? pRecord->numRow - pDumpInfo->rowIndex : pDumpInfo->rowIndex + 1;





×








UNCOV

1663



  tsdbDebug("%p copy file block to sdatablock, global index:%d, table index:%d, brange:%" PRId64 "-%" PRId64





×







1664



            ", rows:%d, remain:%d, minVer:%" PRId64 ", maxVer:%" PRId64 ", uid:%" PRIu64 " elapsed time:%.2f ms, %s",










1665



            pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pRecord->firstKey.key.ts, pRecord->lastKey.key.ts,










1666



            dumpedRows, unDumpedRows, pRecord->minVer, pRecord->maxVer, pBlockInfo->uid, elapsedTime, pReader->idStr);










1667













UNCOV

1668



_end:




×








UNCOV

1669



  if (code != TSDB_CODE_SUCCESS) {





×







1670



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





×







1671



  }











UNCOV

1672



  return code;




×







1673



}










1674












1675



static FORCE_INLINE STSchema* getTableSchemaImpl(STsdbReader* pReader, uint64_t uid) {











UNCOV

1676



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1677



  int32_t lino = 0;




×







1678













UNCOV

1679



  TSDB_CHECK_CONDITION((pReader != NULL) && (pReader->info.pSchema == NULL), code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1680













UNCOV

1681



  code = metaGetTbTSchemaEx(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, uid, -1, &pReader->info.pSchema);




×








UNCOV

1682



  if (code != TSDB_CODE_SUCCESS || pReader->info.pSchema == NULL) {





×







1683



    terrno = code;




×







1684



    tsdbError("failed to get table schema, uid:%" PRIu64 ", it may have been dropped, ver:-1, %s", uid, pReader->idStr);





×







1685



  }











UNCOV

1686



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

1687



  TSDB_CHECK_NULL(pReader->info.pSchema, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);





×







1688













UNCOV

1689



  code = tsdbRowMergerInit(&pReader->status.merger, pReader->info.pSchema);




×








UNCOV

1690



  TSDB_CHECK_CODE(code, lino, _end);





×







1691













UNCOV

1692



_end:




×








UNCOV

1693



  if (code != TSDB_CODE_SUCCESS) {





×







1694



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





×







1695



    terrno = code;




×







1696



    return NULL;




×







1697



  }











UNCOV

1698



  return pReader->info.pSchema;




×







1699



}










1700













UNCOV

1701



static int32_t doLoadFileBlockData(STsdbReader* pReader, SDataBlockIter* pBlockIter, SBlockData* pBlockData,




×







1702



                                   uint64_t uid) {











UNCOV

1703



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

1704



  int32_t             lino = 0;




×








UNCOV

1705



  STSchema*           pSchema = NULL;




×








UNCOV

1706



  SFileDataBlockInfo* pBlockInfo = NULL;




×








UNCOV

1707



  SBlockLoadSuppInfo* pSup = NULL;




×








UNCOV

1708



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

1709



  int64_t             st = 0;




×







1710



  SBrinRecord         tmp;











UNCOV

1711



  SBrinRecord*        pRecord = NULL;




×







1712













UNCOV

1713



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1714



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1715













UNCOV

1716



  pSchema = pReader->info.pSchema;




×








UNCOV

1717



  st = taosGetTimestampUs();




×








UNCOV

1718



  pSup = &pReader->suppInfo;




×







1719













UNCOV

1720



  tBlockDataReset(pBlockData);




×







1721













UNCOV

1722



  if (pReader->info.pSchema == NULL) {





×







1723



    pSchema = getTableSchemaImpl(pReader, uid);




×







1724



    if (pSchema == NULL) {





×







1725



      tsdbError("%p table uid:%" PRIu64 " failed to get tableschema, code:%s, %s", pReader, uid, tstrerror(code),





×







1726



                pReader->idStr);










1727



      TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);





×







1728



    }










1729



  }










1730













UNCOV

1731



  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

1732



  TSDB_CHECK_CODE(code, lino, _end);





×







1733













UNCOV

1734



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







1735













UNCOV

1736



  blockInfoToRecord(&tmp, pBlockInfo, pSup);




×








UNCOV

1737



  pRecord = &tmp;




×








UNCOV

1738



  code = tsdbDataFileReadBlockDataByColumn(pReader->pFileReader, pRecord, pBlockData, pSchema, &pSup->colId[1],




×








UNCOV

1739



                                           pSup->numOfCols - 1);




×








UNCOV

1740



  if (code != TSDB_CODE_SUCCESS) {





×







1741



    tsdbError("%p error occurs in loading file block, global index:%d, table index:%d, brange:%" PRId64 "-%" PRId64





×







1742



              ", rows:%d, code:%s %s",










1743



              pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pBlockInfo->firstKey, pBlockInfo->lastKey,










1744



              pBlockInfo->numRow, tstrerror(code), pReader->idStr);










1745



    TSDB_CHECK_CODE(code, lino, _end);





×







1746



  }










1747













UNCOV

1748



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




×







1749













UNCOV

1750



  tsdbDebug("%p load file block into buffer, global index:%d, index in table block list:%d, brange:%" PRId64 "-%" PRId64





×







1751



            ", rows:%d, minVer:%" PRId64 ", maxVer:%" PRId64 ", elapsed time:%.2f ms, %s",










1752



            pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pRecord->firstKey.key.ts, pRecord->lastKey.key.ts,










1753



            pRecord->numRow, pRecord->minVer, pRecord->maxVer, elapsedTime, pReader->idStr);










1754













UNCOV

1755



  pReader->cost.blockLoadTime += elapsedTime;




×








UNCOV

1756



  pDumpInfo->allDumped = false;




×







1757













UNCOV

1758



_end:




×








UNCOV

1759



  if (code != TSDB_CODE_SUCCESS) {





×







1760



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





×







1761



  }











UNCOV

1762



  return code;




×







1763



}










1764












1765



/**










1766



 * This is an two rectangles overlap cases.










1767



 */











UNCOV

1768



static int32_t dataBlockPartiallyRequired(STimeWindow* pWindow, SVersionRange* pVerRange, SFileDataBlockInfo* pBlock) {




×








UNCOV

1769



  return (pWindow->ekey < pBlock->lastKey && pWindow->ekey >= pBlock->firstKey) ||





×








UNCOV

1770



         (pWindow->skey > pBlock->firstKey && pWindow->skey <= pBlock->lastKey) ||





×








UNCOV

1771



         (pVerRange->minVer > pBlock->minVer && pVerRange->minVer <= pBlock->maxVer) ||





×








UNCOV

1772



         (pVerRange->maxVer < pBlock->maxVer && pVerRange->maxVer >= pBlock->minVer);





×







1773



}










1774













UNCOV

1775



static int32_t getNeighborBlockOfTable(SDataBlockIter* pBlockIter, SFileDataBlockInfo* pBlockInfo,




×







1776



                                       STableBlockScanInfo* pScanInfo, int32_t* nextIndex, int32_t order,










1777



                                       SBrinRecord* pRecord, SBlockLoadSuppInfo* pSupInfo, bool* res) {











UNCOV

1778



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

1779



  int32_t             lino = 0;




×








UNCOV

1780



  bool                asc = false;




×








UNCOV

1781



  int32_t             step = 0;




×








UNCOV

1782



  STableDataBlockIdx* pTableDataBlockIdx = NULL;




×








UNCOV

1783



  SFileDataBlockInfo* p = NULL;




×







1784













UNCOV

1785



  TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1786



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1787



  TSDB_CHECK_NULL(res, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1788













UNCOV

1789



  *res = false;




×








UNCOV

1790



  asc = ASCENDING_TRAVERSE(order);




×








UNCOV

1791



  step = asc ? 1 : -1;





×







1792













UNCOV

1793



  if (asc && pBlockInfo->tbBlockIdx >= taosArrayGetSize(pScanInfo->pBlockIdxList) - 1) {





×








UNCOV

1794



    *res = false;




×








UNCOV

1795



  } else if (!asc && pBlockInfo->tbBlockIdx == 0) {





×








UNCOV

1796



    *res = false;




×







1797



  } else {











UNCOV

1798



    TSDB_CHECK_NULL(pBlockIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1799



    TSDB_CHECK_NULL(nextIndex, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1800



    TSDB_CHECK_NULL(pRecord, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1801



    TSDB_CHECK_NULL(pSupInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1802













UNCOV

1803



    pTableDataBlockIdx = taosArrayGet(pScanInfo->pBlockIdxList, pBlockInfo->tbBlockIdx + step);




×








UNCOV

1804



    TSDB_CHECK_NULL(pTableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1805













UNCOV

1806



    p = taosArrayGet(pBlockIter->blockList, pTableDataBlockIdx->globalIndex);




×








UNCOV

1807



    TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1808













UNCOV

1809



    blockInfoToRecord(pRecord, p, pSupInfo);




×







1810













UNCOV

1811



    *nextIndex = pBlockInfo->tbBlockIdx + step;




×








UNCOV

1812



    *res = true;




×







1813



  }










1814













UNCOV

1815



_end:




×








UNCOV

1816



  if (code != TSDB_CODE_SUCCESS) {





×







1817



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





×







1818



  }











UNCOV

1819



  return code;




×







1820



}










1821













UNCOV

1822



static int32_t setFileBlockActiveInBlockIter(STsdbReader* pReader, SDataBlockIter* pBlockIter, int32_t index,




×







1823



                                             int32_t step) {











UNCOV

1824



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

1825



  int32_t              lino = 0;




×








UNCOV

1826



  const void*          p = NULL;




×







1827



  SFileDataBlockInfo   fblock;











UNCOV

1828



  SFileDataBlockInfo*  pBlockInfo = NULL;




×








UNCOV

1829



  STableBlockScanInfo* pBlockScanInfo = NULL;




×








UNCOV

1830



  STableDataBlockIdx*  pTableDataBlockIdx = NULL;




×







1831













UNCOV

1832



  TSDB_CHECK_NULL(pBlockIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1833



  TSDB_CHECK_CONDITION((index >= 0) && (index < pBlockIter->numOfBlocks), code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1834













UNCOV

1835



  p = taosArrayGet(pBlockIter->blockList, index);




×








UNCOV

1836



  TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1837













UNCOV

1838



  fblock = *(SFileDataBlockInfo*)p;




×








UNCOV

1839



  pBlockIter->index += step;




×







1840













UNCOV

1841



  if (index != pBlockIter->index) {





×







1842



    if (index > pBlockIter->index) {





×







1843



      for (int32_t i = index - 1; i >= pBlockIter->index; --i) {





×







1844



        pBlockInfo = taosArrayGet(pBlockIter->blockList, i);




×







1845



        TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1846












1847



        code = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);




×







1848



        TSDB_CHECK_CODE(code, lino, _end);





×







1849












1850



        pTableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, pBlockInfo->tbBlockIdx);




×







1851



        TSDB_CHECK_NULL(pTableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1852












1853



        pTableDataBlockIdx->globalIndex = i + 1;




×







1854












1855



        taosArraySet(pBlockIter->blockList, i + 1, pBlockInfo);




×







1856



      }










1857



    } else if (index < pBlockIter->index) {





×







1858



      for (int32_t i = index + 1; i <= pBlockIter->index; ++i) {





×







1859



        pBlockInfo = taosArrayGet(pBlockIter->blockList, i);




×







1860



        TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1861












1862



        code = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);




×







1863



        TSDB_CHECK_CODE(code, lino, _end);





×







1864












1865



        pTableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, pBlockInfo->tbBlockIdx);




×







1866



        TSDB_CHECK_NULL(pTableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1867












1868



        pTableDataBlockIdx->globalIndex = i - 1;




×







1869



        taosArraySet(pBlockIter->blockList, i - 1, pBlockInfo);




×







1870



      }










1871



    }










1872












1873



    taosArraySet(pBlockIter->blockList, pBlockIter->index, &fblock);




×







1874



    pBlockScanInfo = NULL;




×







1875



    code = getTableBlockScanInfo(pReader->status.pTableMap, fblock.uid, &pBlockScanInfo, pReader->idStr);




×







1876



    TSDB_CHECK_CODE(code, lino, _end);





×







1877












1878



    pTableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, fblock.tbBlockIdx);




×







1879



    TSDB_CHECK_NULL(pTableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1880












1881



    pTableDataBlockIdx->globalIndex = pBlockIter->index;




×







1882



  }










1883













UNCOV

1884



_end:




×








UNCOV

1885



  if (code != TSDB_CODE_SUCCESS) {





×







1886



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





×







1887



  }











UNCOV

1888



  return code;




×







1889



}










1890












1891



// todo: this attribute could be acquired during extractin the global ordered block list.











UNCOV

1892



static bool overlapWithNeighborBlock2(SFileDataBlockInfo* pBlock, SBrinRecord* pRec, int32_t order, int32_t pkType,




×







1893



                                      int32_t numOfPk) {










1894



  // it is the last block in current file, no chance to overlap with neighbor blocks.











UNCOV

1895



  if (ASCENDING_TRAVERSE(order)) {





×








UNCOV

1896



    if (pBlock->lastKey == pRec->firstKey.key.ts) {





×








UNCOV

1897



      if (numOfPk > 0) {





×








UNCOV

1898



        SValue v1 = {.type = pkType};




×








UNCOV

1899



        if (IS_VAR_DATA_TYPE(pkType)) {





×







1900



          v1.pData = (uint8_t*)varDataVal(pBlock->lastPk.pData), v1.nData = varDataLen(pBlock->lastPk.pData);




×







1901



        } else {











UNCOV

1902



          v1.val = pBlock->lastPk.val;




×







1903



        }











UNCOV

1904



        return (tValueCompare(&v1, &pRec->firstKey.key.pks[0]) == 0);




×







1905



      } else {  // no pk











UNCOV

1906



        return true;




×







1907



      }










1908



    } else {











UNCOV

1909



      return false;




×







1910



    }










1911



  } else {











UNCOV

1912



    if (pBlock->firstKey == pRec->lastKey.key.ts) {





×








UNCOV

1913



      if (numOfPk > 0) {





×








UNCOV

1914



        SValue v1 = {.type = pkType};




×








UNCOV

1915



        if (IS_VAR_DATA_TYPE(pkType)) {





×







1916



          v1.pData = (uint8_t*)varDataVal(pBlock->firstPk.pData), v1.nData = varDataLen(pBlock->firstPk.pData);




×







1917



        } else {











UNCOV

1918



          v1.val = pBlock->firstPk.val;




×







1919



        }











UNCOV

1920



        return (tValueCompare(&v1, &pRec->lastKey.key.pks[0]) == 0);




×







1921



      } else {  // no pk










1922



        return true;




×







1923



      }










1924



    } else {











UNCOV

1925



      return false;




×







1926



    }










1927



  }










1928



}










1929













UNCOV

1930



static int64_t getBoarderKeyInFiles(SFileDataBlockInfo* pBlock, STableBlockScanInfo* pScanInfo, int32_t order) {




×








UNCOV

1931



  bool ascScan = ASCENDING_TRAVERSE(order);




×







1932













UNCOV

1933



  int64_t key = 0;




×








UNCOV

1934



  if (pScanInfo->sttKeyInfo.status == STT_FILE_HAS_DATA) {





×








UNCOV

1935



    int64_t keyInStt = pScanInfo->sttKeyInfo.nextProcKey.ts;




×








UNCOV

1936



    key = ascScan ? TMIN(pBlock->firstKey, keyInStt) : TMAX(pBlock->lastKey, keyInStt);





×







1937



  } else {











UNCOV

1938



    key = ascScan ? pBlock->firstKey : pBlock->lastKey;





×







1939



  }










1940













UNCOV

1941



  return key;




×







1942



}










1943













UNCOV

1944



static bool bufferDataInFileBlockGap(TSDBKEY keyInBuf, SFileDataBlockInfo* pBlock, STableBlockScanInfo* pScanInfo,




×







1945



                                     int32_t order) {











UNCOV

1946



  bool    ascScan = ASCENDING_TRAVERSE(order);




×








UNCOV

1947



  int64_t key = getBoarderKeyInFiles(pBlock, pScanInfo, order);




×







1948













UNCOV

1949



  return (ascScan && (keyInBuf.ts != TSKEY_INITIAL_VAL && keyInBuf.ts < key)) ||





×








UNCOV

1950



         (!ascScan && (keyInBuf.ts != TSKEY_INITIAL_VAL && keyInBuf.ts > key));





×







1951



}










1952













UNCOV

1953



static bool keyOverlapFileBlock(TSDBKEY key, SFileDataBlockInfo* pBlock, SVersionRange* pVerRange) {




×








UNCOV

1954



  return (key.ts >= pBlock->firstKey && key.ts <= pBlock->lastKey) && (pBlock->maxVer >= pVerRange->minVer) &&





×








UNCOV

1955



         (pBlock->minVer <= pVerRange->maxVer);





×







1956



}










1957













UNCOV

1958



static int32_t getBlockToLoadInfo(SDataBlockToLoadInfo* pInfo, SFileDataBlockInfo* pBlockInfo,




×







1959



                                  STableBlockScanInfo* pScanInfo, TSDBKEY keyInBuf, STsdbReader* pReader) {











UNCOV

1960



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

1961



  int32_t             lino = 0;




×








UNCOV

1962



  SBrinRecord         rec = {0};




×








UNCOV

1963



  int32_t             neighborIndex = 0;




×








UNCOV

1964



  int32_t             order = 0;




×








UNCOV

1965



  SBlockLoadSuppInfo* pSupInfo = NULL;




×







1966



  SBrinRecord         pRecord;











UNCOV

1967



  bool                hasNeighbor = false;




×







1968













UNCOV

1969



  TSDB_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

1970



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







1971













UNCOV

1972



  order = pReader->info.order;




×








UNCOV

1973



  pSupInfo = &pReader->suppInfo;




×







1974













UNCOV

1975



  code = getNeighborBlockOfTable(&pReader->status.blockIter, pBlockInfo, pScanInfo, &neighborIndex, order, &rec,




×







1976



                                 pSupInfo, &hasNeighbor);











UNCOV

1977



  TSDB_CHECK_CODE(code, lino, _end);





×







1978












1979



  // overlap with neighbor











UNCOV

1980



  if (hasNeighbor) {





×








UNCOV

1981



    pInfo->overlapWithNeighborBlock =




×








UNCOV

1982



        overlapWithNeighborBlock2(pBlockInfo, &rec, order, pSupInfo->pk.type, pSupInfo->numOfPks);




×







1983



  }










1984













UNCOV

1985



  blockInfoToRecord(&pRecord, pBlockInfo, pSupInfo);




×







1986












1987



  // has duplicated ts of different version in this block











UNCOV

1988



  pInfo->hasDupTs = (pBlockInfo->numRow > pBlockInfo->count) || (pBlockInfo->count <= 0);





×








UNCOV

1989



  pInfo->overlapWithDelInfo = overlapWithDelSkyline(pScanInfo, &pRecord, order);




×







1990












1991



  // todo handle the primary key overlap case











UNCOV

1992



  if (pScanInfo->sttKeyInfo.status == STT_FILE_HAS_DATA) {





×








UNCOV

1993



    int64_t nextProcKeyInStt = pScanInfo->sttKeyInfo.nextProcKey.ts;




×








UNCOV

1994



    pInfo->overlapWithSttBlock = !(pBlockInfo->lastKey < nextProcKeyInStt || pBlockInfo->firstKey > nextProcKeyInStt);





×







1995



  }










1996













UNCOV

1997



  pInfo->moreThanCapcity = pBlockInfo->numRow > pReader->resBlockInfo.capacity;




×








UNCOV

1998



  pInfo->partiallyRequired = dataBlockPartiallyRequired(&pReader->info.window, &pReader->info.verRange, pBlockInfo);




×








UNCOV

1999



  pInfo->overlapWithKeyInBuf = keyOverlapFileBlock(keyInBuf, pBlockInfo, &pReader->info.verRange);




×







2000













UNCOV

2001



_end:




×








UNCOV

2002



  if (code != TSDB_CODE_SUCCESS) {





×







2003



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





×







2004



  }











UNCOV

2005



  return code;




×







2006



}










2007












2008



// 1. the version of all rows should be less than the endVersion










2009



// 2. current block should not overlap with next neighbor block










2010



// 3. current timestamp should not be overlap with each other










2011



// 4. output buffer should be large enough to hold all rows in current block










2012



// 5. delete info should not overlap with current block data










2013



// 6. current block should not contain the duplicated ts











UNCOV

2014



static int32_t fileBlockShouldLoad(STsdbReader* pReader, SFileDataBlockInfo* pBlockInfo, STableBlockScanInfo* pScanInfo,




×







2015



                                   TSDBKEY keyInBuf, bool* load) {











UNCOV

2016



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

2017



  int32_t              lino = 0;




×








UNCOV

2018



  SDataBlockToLoadInfo info = {0};




×







2019













UNCOV

2020



  TSDB_CHECK_NULL(load, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2021













UNCOV

2022



  *load = false;




×








UNCOV

2023



  code = getBlockToLoadInfo(&info, pBlockInfo, pScanInfo, keyInBuf, pReader);




×








UNCOV

2024



  TSDB_CHECK_CODE(code, lino, _end);





×







2025













UNCOV

2026



  *load = (info.overlapWithNeighborBlock || info.hasDupTs || info.partiallyRequired || info.overlapWithKeyInBuf ||





×








UNCOV

2027



           info.moreThanCapcity || info.overlapWithDelInfo || info.overlapWithSttBlock);





×







2028












2029



  // log the reason why load the datablock for profile











UNCOV

2030



  if (*load) {





×








UNCOV

2031



    tsdbDebug("%p uid:%" PRIu64





×







2032



              " need to load the datablock, overlapneighbor:%d, hasDup:%d, partiallyRequired:%d, "










2033



              "overlapWithKey:%d, greaterThanBuf:%d, overlapWithDel:%d, overlapWithSttBlock:%d, %s",










2034



              pReader, pBlockInfo->uid, info.overlapWithNeighborBlock, info.hasDupTs, info.partiallyRequired,










2035



              info.overlapWithKeyInBuf, info.moreThanCapcity, info.overlapWithDelInfo, info.overlapWithSttBlock,










2036



              pReader->idStr);










2037



  }










2038













UNCOV

2039



_end:




×








UNCOV

2040



  if (code != TSDB_CODE_SUCCESS) {





×







2041



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





×







2042



  }











UNCOV

2043



  return code;




×







2044



}










2045













UNCOV

2046



static int32_t isCleanFileDataBlock(STsdbReader* pReader, SFileDataBlockInfo* pBlockInfo,




×







2047



                                    STableBlockScanInfo* pScanInfo, TSDBKEY keyInBuf, bool* res) {











UNCOV

2048



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

2049



  int32_t              lino = 0;




×








UNCOV

2050



  SDataBlockToLoadInfo info = {0};




×







2051













UNCOV

2052



  TSDB_CHECK_NULL(res, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2053













UNCOV

2054



  *res = false;




×








UNCOV

2055



  code = getBlockToLoadInfo(&info, pBlockInfo, pScanInfo, keyInBuf, pReader);




×








UNCOV

2056



  TSDB_CHECK_CODE(code, lino, _end);





×







2057













UNCOV

2058



  *res = !(info.overlapWithNeighborBlock || info.hasDupTs || info.overlapWithKeyInBuf || info.overlapWithDelInfo ||





×








UNCOV

2059



           info.overlapWithSttBlock);





×







2060













UNCOV

2061



_end:




×








UNCOV

2062



  if (code != TSDB_CODE_SUCCESS) {





×







2063



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





×







2064



  }











UNCOV

2065



  return code;




×







2066



}










2067













UNCOV

2068



static int32_t initRowMergeIfNeeded(STsdbReader* pReader, int64_t uid) {




×








UNCOV

2069



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

2070



  int32_t     lino = 0;




×








UNCOV

2071



  SRowMerger* pMerger = NULL;




×








UNCOV

2072



  STSchema*   ps = NULL;




×







2073













UNCOV

2074



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2075













UNCOV

2076



  pMerger = &pReader->status.merger;




×







2077













UNCOV

2078



  if (pMerger->pArray == NULL) {





×








UNCOV

2079



    ps = getTableSchemaImpl(pReader, uid);





×








UNCOV

2080



    TSDB_CHECK_NULL(ps, code, lino, _end, terrno);





×







2081



  }










2082













UNCOV

2083



_end:




×








UNCOV

2084



  if (code != TSDB_CODE_SUCCESS) {





×







2085



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





×







2086



  }











UNCOV

2087



  return code;




×







2088



}










2089













UNCOV

2090



static int32_t buildDataBlockFromBuf(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, int64_t endKey) {




×








UNCOV

2091



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

2092



  int32_t      lino = 0;




×








UNCOV

2093



  int64_t      st = 0;




×








UNCOV

2094



  SSDataBlock* pBlock = NULL;




×







2095













UNCOV

2096



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2097













UNCOV

2098



  if (!(pBlockScanInfo->iiter.hasVal || pBlockScanInfo->iter.hasVal)) {





×








UNCOV

2099



    goto _end;




×







2100



  }










2101













UNCOV

2102



  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);




×








UNCOV

2103



  TSDB_CHECK_CODE(code, lino, _end);





×







2104













UNCOV

2105



  st = taosGetTimestampUs();




×








UNCOV

2106



  pBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

2107



  code = buildDataBlockFromBufImpl(pBlockScanInfo, endKey, pReader->resBlockInfo.capacity, pReader);




×








UNCOV

2108



  TSDB_CHECK_CODE(code, lino, _end);





×







2109













UNCOV

2110



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




×








UNCOV

2111



  updateComposedBlockInfo(pReader, el, pBlockScanInfo);




×







2112













UNCOV

2113



  tsdbDebug("%p build data block from cache completed, elapsed time:%.2f ms, numOfRows:%" PRId64 ", brange:%" PRId64





×







2114



            " - %" PRId64 ", uid:%" PRIu64 ",  %s",










2115



            pReader, el, pBlock->info.rows, pBlock->info.window.skey, pBlock->info.window.ekey, pBlockScanInfo->uid,










2116



            pReader->idStr);










2117













UNCOV

2118



  pReader->cost.buildmemBlock += el;




×







2119













UNCOV

2120



_end:




×








UNCOV

2121



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

2122



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





×







2123



  }











UNCOV

2124



  return code;




×







2125



}










2126













UNCOV

2127



static int32_t tryCopyDistinctRowFromFileBlock(STsdbReader* pReader, SBlockData* pBlockData, SRowKey* pKey,




×







2128



                                               SFileBlockDumpInfo* pDumpInfo, bool* copied) {










2129



  // opt version










2130



  // 1. it is not a border point










2131



  // 2. the direct next point is not an duplicated timestamp











UNCOV

2132



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

2133



  int32_t lino = 0;




×








UNCOV

2134



  bool    asc = false;




×







2135













UNCOV

2136



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2137



  TSDB_CHECK_NULL(pDumpInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2138



  TSDB_CHECK_NULL(copied, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2139













UNCOV

2140



  *copied = false;




×








UNCOV

2141



  asc = (pReader->info.order == TSDB_ORDER_ASC);




×








UNCOV

2142



  if ((pDumpInfo->rowIndex < pDumpInfo->totalRows - 1 && asc) || (pDumpInfo->rowIndex > 0 && (!asc))) {





×








UNCOV

2143



    int32_t step = ASCENDING_TRAVERSE(pReader->info.order) ? 1 : -1;





×







2144












2145



    SRowKey nextRowKey;











UNCOV

2146



    TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2147



    tColRowGetKey(pBlockData, pDumpInfo->rowIndex + step, &nextRowKey);





×







2148













UNCOV

2149



    if (pkCompEx(pKey, &nextRowKey) != 0) {  // merge is not needed





×








UNCOV

2150



      code = doAppendRowFromFileBlock(pReader->resBlockInfo.pResBlock, pReader, pBlockData, pDumpInfo->rowIndex);




×








UNCOV

2151



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2152



      pDumpInfo->rowIndex += step;




×








UNCOV

2153



      *copied = true;




×







2154



    }










2155



  }










2156













UNCOV

2157



_end:




×








UNCOV

2158



  if (code != TSDB_CODE_SUCCESS) {





×







2159



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





×







2160



  }











UNCOV

2161



  return code;




×







2162



}










2163













UNCOV

2164



static int32_t nextRowFromSttBlocks(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, int32_t pkSrcSlot,




×







2165



                                    SVersionRange* pVerRange) {











UNCOV

2166



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

2167



  int32_t  lino = 0;




×








UNCOV

2168



  int32_t  order = 0;




×








UNCOV

2169



  int32_t  step = 0;




×








UNCOV

2170



  SRowKey* pNextProc = NULL;




×







2171













UNCOV

2172



  TSDB_CHECK_NULL(pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2173



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2174













UNCOV

2175



  order = pSttBlockReader->order;




×








UNCOV

2176



  step = ASCENDING_TRAVERSE(order) ? 1 : -1;





×








UNCOV

2177



  pNextProc = &pScanInfo->sttKeyInfo.nextProcKey;




×







2178













UNCOV

2179



  while (1) {




×








UNCOV

2180



    bool hasVal = false;




×








UNCOV

2181



    code = tMergeTreeNext(&pSttBlockReader->mergeTree, &hasVal);




×








UNCOV

2182



    if (code) {





×







2183



      tsdbError("failed to iter the next row in stt-file merge tree, code:%s, %s", tstrerror(code),





×







2184



                pSttBlockReader->mergeTree.idStr);











UNCOV

2185



      TSDB_CHECK_CODE(code, lino, _end);





×







2186



    }










2187













UNCOV

2188



    if (!hasVal) {  // the next value will be the accessed key in stt





×








UNCOV

2189



      pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;




×







2190












2191



      // next file, the timestamps in the next file must be greater than those in current











UNCOV

2192



      pNextProc->ts += step;




×








UNCOV

2193



      if (pSttBlockReader->numOfPks > 0) {





×








UNCOV

2194



        if (IS_NUMERIC_TYPE(pNextProc->pks[0].type)) {





×








UNCOV

2195



          pNextProc->pks[0].val = INT64_MIN;




×







2196



        } else {










2197



          memset(pNextProc->pks[0].pData, 0, pNextProc->pks[0].nData);




×







2198



        }










2199



      }











UNCOV

2200



      goto _end;




×







2201



    }










2202













UNCOV

2203



    TSDBROW* pRow = tMergeTreeGetRow(&pSttBlockReader->mergeTree);




×








UNCOV

2204



    int64_t  key = pRow->pBlockData->aTSKEY[pRow->iRow];




×








UNCOV

2205



    int64_t  ver = pRow->pBlockData->aVersion[pRow->iRow];




×







2206













UNCOV

2207



    if (pSttBlockReader->numOfPks == 0) {





×








UNCOV

2208



      pSttBlockReader->currentKey.ts = key;




×







2209



    } else {











UNCOV

2210



      tColRowGetKeyDeepCopy(pRow->pBlockData, pRow->iRow, pkSrcSlot, &pSttBlockReader->currentKey);





×







2211



    }










2212













UNCOV

2213



    tColRowGetKeyDeepCopy(pRow->pBlockData, pRow->iRow, pkSrcSlot, pNextProc);





×







2214













UNCOV

2215



    if (pScanInfo->delSkyline != NULL && TARRAY_SIZE(pScanInfo->delSkyline) > 0) {





×








UNCOV

2216



      bool dropped = false;




×








UNCOV

2217



      code = hasBeenDropped(pScanInfo->delSkyline, &pScanInfo->sttBlockDelIndex, key, ver, order, pVerRange,




×








UNCOV

2218



                            pSttBlockReader->numOfPks > 0, &dropped);




×








UNCOV

2219



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2220



      if (!dropped) {





×








UNCOV

2221



        pScanInfo->sttKeyInfo.status = STT_FILE_HAS_DATA;




×








UNCOV

2222



        goto _end;




×







2223



      }










2224



    } else {











UNCOV

2225



      pScanInfo->sttKeyInfo.status = STT_FILE_HAS_DATA;




×








UNCOV

2226



      goto _end;




×







2227



    }










2228



  }










2229













UNCOV

2230



_end:




×








UNCOV

2231



  if (code != TSDB_CODE_SUCCESS) {





×







2232



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





×







2233



  }











UNCOV

2234



  return code;




×







2235



}










2236













UNCOV

2237



static void doPinSttBlock(SSttBlockReader* pSttBlockReader) { tMergeTreePinSttBlock(&pSttBlockReader->mergeTree); }




×







2238













UNCOV

2239



static void doUnpinSttBlock(SSttBlockReader* pSttBlockReader) { tMergeTreeUnpinSttBlock(&pSttBlockReader->mergeTree); }




×







2240













UNCOV

2241



static int32_t tryCopyDistinctRowFromSttBlock(TSDBROW* fRow, SSttBlockReader* pSttBlockReader,




×







2242



                                              STableBlockScanInfo* pScanInfo, SRowKey* pSttKey, STsdbReader* pReader,










2243



                                              bool* copied) {











UNCOV

2244



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

2245



  int32_t  lino = 0;




×








UNCOV

2246



  SRowKey* pNext = NULL;




×







2247













UNCOV

2248



  TSDB_CHECK_NULL(pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2249



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2250



  TSDB_CHECK_NULL(copied, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2251













UNCOV

2252



  *copied = false;




×







2253












2254



  // avoid the fetch next row replace the referenced stt block in buffer











UNCOV

2255



  doPinSttBlock(pSttBlockReader);




×








UNCOV

2256



  code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pReader->suppInfo.pkSrcSlot, &pReader->info.verRange);




×








UNCOV

2257



  doUnpinSttBlock(pSttBlockReader);




×








UNCOV

2258



  TSDB_CHECK_CODE(code, lino, _end);





×







2259













UNCOV

2260



  if (hasDataInSttBlock(pScanInfo)) {





×








UNCOV

2261



    pNext = getCurrentKeyInSttBlock(pSttBlockReader);





×








UNCOV

2262



    if (pkCompEx(pSttKey, pNext) != 0) {





×








UNCOV

2263



      code = doAppendRowFromFileBlock(pReader->resBlockInfo.pResBlock, pReader, fRow->pBlockData, fRow->iRow);




×








UNCOV

2264



      *copied = (code == TSDB_CODE_SUCCESS);




×








UNCOV

2265



      TSDB_CHECK_CODE(code, lino, _end);





×







2266



    }










2267



  } else {











UNCOV

2268



    code = doAppendRowFromFileBlock(pReader->resBlockInfo.pResBlock, pReader, fRow->pBlockData, fRow->iRow);




×








UNCOV

2269



    *copied = (code == TSDB_CODE_SUCCESS);




×








UNCOV

2270



    TSDB_CHECK_CODE(code, lino, _end);





×







2271



  }










2272













UNCOV

2273



_end:




×








UNCOV

2274



  if (code != TSDB_CODE_SUCCESS) {





×







2275



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





×







2276



  }











UNCOV

2277



  return code;




×







2278



}










2279












2280



static FORCE_INLINE STSchema* doGetSchemaForTSRow(int32_t sversion, STsdbReader* pReader, uint64_t uid) {











UNCOV

2281



  int32_t   code = TSDB_CODE_SUCCESS;




×








UNCOV

2282



  int32_t   lino = 0;




×








UNCOV

2283



  STSchema* ps = NULL;




×








UNCOV

2284



  void**    p = NULL;




×







2285













UNCOV

2286



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2287












2288



  // always set the newest schema version in pReader->info.pSchema











UNCOV

2289



  if (pReader->info.pSchema == NULL) {





×







2290



    ps = getTableSchemaImpl(pReader, uid);




×







2291



    TSDB_CHECK_NULL(ps, code, lino, _end, terrno);





×







2292



  }










2293













UNCOV

2294



  if (pReader->info.pSchema && sversion == pReader->info.pSchema->version) {





×








UNCOV

2295



    ps = pReader->info.pSchema;




×








UNCOV

2296



    goto _end;




×







2297



  }










2298













UNCOV

2299



  p = tSimpleHashGet(pReader->pSchemaMap, &sversion, sizeof(sversion));




×








UNCOV

2300



  if (p != NULL) {





×








UNCOV

2301



    ps = *(STSchema**)p;




×








UNCOV

2302



    goto _end;




×







2303



  }










2304













UNCOV

2305



  code = metaGetTbTSchemaEx(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, uid, sversion, &ps);




×








UNCOV

2306



  TSDB_CHECK_CODE(code, lino, _end);





×







2307













UNCOV

2308



  code = tSimpleHashPut(pReader->pSchemaMap, &sversion, sizeof(sversion), &ps, POINTER_BYTES);




×








UNCOV

2309



  TSDB_CHECK_CODE(code, lino, _end);





×







2310













UNCOV

2311



_end:




×








UNCOV

2312



  if (code != TSDB_CODE_SUCCESS) {





×







2313



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





×







2314



    terrno = code;




×







2315



    return NULL;




×







2316



  }











UNCOV

2317



  return ps;




×







2318



}










2319













UNCOV

2320



static int32_t doMergeBufAndFileRows(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, TSDBROW* pRow,




×







2321



                                     SIterInfo* pIter, SSttBlockReader* pSttBlockReader) {











UNCOV

2322



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

2323



  int32_t             lino = 0;




×








UNCOV

2324



  SRowMerger*         pMerger = NULL;




×








UNCOV

2325



  SRow*               pTSRow = NULL;




×








UNCOV

2326



  SBlockData*         pBlockData = NULL;




×








UNCOV

2327



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

2328



  SRowKey*            pSttKey = NULL;




×








UNCOV

2329



  int32_t             pkSrcSlot = 0;




×








UNCOV

2330



  SRowKey             k = {0};




×








UNCOV

2331



  STSchema*           pSchema = NULL;




×







2332













UNCOV

2333



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2334



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2335



  TSDB_CHECK_NULL(pRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2336













UNCOV

2337



  pMerger = &pReader->status.merger;




×








UNCOV

2338



  pBlockData = &pReader->status.fileBlockData;




×








UNCOV

2339



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

2340



  pkSrcSlot = pReader->suppInfo.pkSrcSlot;




×







2341













UNCOV

2342



  if (hasDataInSttBlock(pBlockScanInfo) && (!pBlockScanInfo->cleanSttBlocks)) {





×








UNCOV

2343



    pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);




×







2344



  }










2345













UNCOV

2346



  tRowGetKeyEx(pRow, &k);





×







2347













UNCOV

2348



  if (pRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

2349



    pSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, pBlockScanInfo->uid);





×








UNCOV

2350



    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);





×







2351



  }










2352













UNCOV

2353



  SRowKey* pfKey = &(SRowKey){0};




×








UNCOV

2354



  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {





×








UNCOV

2355



    tColRowGetKey(pBlockData, pDumpInfo->rowIndex, pfKey);





×







2356



  } else {











UNCOV

2357



    pfKey = NULL;




×







2358



  }










2359













UNCOV

2360



  TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);




×







2361












2362



  // merge is not initialized yet, due to the fact that the pReader->info.pSchema is not initialized











UNCOV

2363



  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);




×








UNCOV

2364



  TSDB_CHECK_CODE(code, lino, _end);





×







2365













UNCOV

2366



  SRowKey minKey = k;




×








UNCOV

2367



  if (pReader->info.order == TSDB_ORDER_ASC) {





×








UNCOV

2368



    if (pfKey != NULL && pkCompEx(pfKey, &minKey) < 0) {





×








UNCOV

2369



      minKey = *pfKey;




×







2370



    }










2371













UNCOV

2372



    if (pSttKey != NULL && pkCompEx(pSttKey, &minKey) < 0) {





×








UNCOV

2373



      minKey = *pSttKey;




×







2374



    }










2375



  } else {











UNCOV

2376



    if (pfKey != NULL && pkCompEx(pfKey, &minKey) > 0) {





×








UNCOV

2377



      minKey = *pfKey;




×







2378



    }










2379













UNCOV

2380



    if (pSttKey != NULL && pkCompEx(pSttKey, &minKey) > 0) {





×








UNCOV

2381



      minKey = *pSttKey;




×







2382



    }










2383



  }










2384












2385



  // copy the last key before the time of stt reader loading the next stt block, in which the underlying data block may










2386



  // be changed, resulting in the corresponding changing of the value of sttRowKey











UNCOV

2387



  tRowKeyAssign(&pBlockScanInfo->lastProcKey, &minKey);




×







2388












2389



  // file block ---> stt block -----> mem











UNCOV

2390



  if (pkCompEx(&minKey, pfKey) == 0) {





×








UNCOV

2391



    code = tsdbRowMergerAdd(pMerger, &fRow, NULL);




×








UNCOV

2392



    TSDB_CHECK_CODE(code, lino, _end);





×







2393













UNCOV

2394



    code = doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pfKey, pReader);




×








UNCOV

2395



    TSDB_CHECK_CODE(code, lino, _end);





×







2396



  }










2397













UNCOV

2398



  if (pkCompEx(&minKey, pSttKey) == 0) {





×








UNCOV

2399



    TSDBROW* fRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);




×








UNCOV

2400



    code = tsdbRowMergerAdd(pMerger, fRow1, NULL);




×








UNCOV

2401



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2402



    code = doMergeRowsInSttBlock(pSttBlockReader, pBlockScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange,




×








UNCOV

2403



                                 pReader->idStr);




×








UNCOV

2404



    TSDB_CHECK_CODE(code, lino, _end);





×







2405



  }










2406













UNCOV

2407



  if (pkCompEx(&minKey, &k) == 0) {





×








UNCOV

2408



    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);




×








UNCOV

2409



    TSDB_CHECK_CODE(code, lino, _end);





×







2410













UNCOV

2411



    code = doMergeRowsInBuf(pIter, pBlockScanInfo->uid, &k, pBlockScanInfo->delSkyline, pReader);




×








UNCOV

2412



    TSDB_CHECK_CODE(code, lino, _end);





×







2413



  }










2414













UNCOV

2415



  code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

2416



  TSDB_CHECK_CODE(code, lino, _end);





×







2417













UNCOV

2418



  code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pBlockScanInfo);




×







2419













UNCOV

2420



  taosMemoryFreeClear(pTSRow);





×








UNCOV

2421



  tsdbRowMergerClear(pMerger);




×








UNCOV

2422



  TSDB_CHECK_CODE(code, lino, _end);





×







2423













UNCOV

2424



_end:




×








UNCOV

2425



  if (code != TSDB_CODE_SUCCESS) {





×







2426



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





×







2427



  }











UNCOV

2428



  return code;




×







2429



}










2430













UNCOV

2431



static int32_t mergeFileBlockAndSttBlock(STsdbReader* pReader, SSttBlockReader* pSttBlockReader, SRowKey* pKey,




×







2432



                                         STableBlockScanInfo* pBlockScanInfo, SBlockData* pBlockData) {











UNCOV

2433



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

2434



  int32_t             lino = 0;




×








UNCOV

2435



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

2436



  SRowMerger*         pMerger = NULL;




×








UNCOV

2437



  SRow*               pTSRow = NULL;




×








UNCOV

2438



  int32_t             pkSrcSlot = 0;




×







2439













UNCOV

2440



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2441



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2442



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2443













UNCOV

2444



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

2445



  pMerger = &pReader->status.merger;




×








UNCOV

2446



  pkSrcSlot = pReader->suppInfo.pkSrcSlot;




×







2447












2448



  // merge is not initialized yet, due to the fact that the pReader->info.pSchema is not initialized











UNCOV

2449



  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);




×








UNCOV

2450



  TSDB_CHECK_CODE(code, lino, _end);





×







2451













UNCOV

2452



  bool dataInDataFile = hasDataInFileBlock(pBlockData, pDumpInfo);




×








UNCOV

2453



  bool dataInSttFile = hasDataInSttBlock(pBlockScanInfo);




×







2454













UNCOV

2455



  if (dataInDataFile && (!dataInSttFile)) {





×







2456



    // no stt file block available, only data block exists











UNCOV

2457



    code = mergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);




×








UNCOV

2458



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2459



  } else if ((!dataInDataFile) && dataInSttFile) {





×







2460



    // no data in data file exists











UNCOV

2461



    code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);




×








UNCOV

2462



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2463



  } else if (pBlockScanInfo->cleanSttBlocks && pReader->info.execMode == READER_EXEC_ROWS) {





×







2464



    // opt model for count data in stt file, which is not overlap with data blocks in files.











UNCOV

2465



    code = mergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);




×








UNCOV

2466



    TSDB_CHECK_CODE(code, lino, _end);





×







2467



  } else {











UNCOV

2468



    TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2469



    // row in both stt file blocks and data file blocks











UNCOV

2470



    TSDBROW  fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);




×








UNCOV

2471



    SRowKey* pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);





×







2472













UNCOV

2473



    int32_t ret = pkCompEx(pKey, pSttKey);




×







2474













UNCOV

2475



    if (ASCENDING_TRAVERSE(pReader->info.order)) {





×








UNCOV

2476



      if (ret < 0) {  // asc





×








UNCOV

2477



        code = mergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);




×








UNCOV

2478



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2479



      } else if (ret > 0) {





×








UNCOV

2480



        code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);




×








UNCOV

2481



        TSDB_CHECK_CODE(code, lino, _end);





×







2482



      }










2483



    } else {  // desc











UNCOV

2484



      if (ret > 0) {





×








UNCOV

2485



        code = mergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);




×








UNCOV

2486



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2487



      } else if (ret < 0) {





×








UNCOV

2488



        code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);




×








UNCOV

2489



        TSDB_CHECK_CODE(code, lino, _end);





×







2490



      }










2491



    }











UNCOV

2492



    if (ret != 0) {





×








UNCOV

2493



      goto _end;




×







2494



    }










2495












2496



    // pKey == pSttKey











UNCOV

2497



    tRowKeyAssign(&pBlockScanInfo->lastProcKey, pKey);




×







2498












2499



    // the following for key == sttKey->key.ts










2500



    // file block ------> stt  block










2501













UNCOV

2502



    code = tsdbRowMergerAdd(pMerger, &fRow, NULL);




×








UNCOV

2503



    TSDB_CHECK_CODE(code, lino, _end);





×







2504













UNCOV

2505



    code = doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);




×








UNCOV

2506



    TSDB_CHECK_CODE(code, lino, _end);





×







2507













UNCOV

2508



    TSDBROW* pRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);




×








UNCOV

2509



    code = tsdbRowMergerAdd(pMerger, pRow1, NULL);




×








UNCOV

2510



    TSDB_CHECK_CODE(code, lino, _end);





×







2511












2512



    // pSttKey will be changed when sttBlockReader iterates to the next row, so use pKey instead.











UNCOV

2513



    code = doMergeRowsInSttBlock(pSttBlockReader, pBlockScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange,




×








UNCOV

2514



                                 pReader->idStr);




×








UNCOV

2515



    TSDB_CHECK_CODE(code, lino, _end);





×







2516













UNCOV

2517



    code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

2518



    TSDB_CHECK_CODE(code, lino, _end);





×







2519













UNCOV

2520



    code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pBlockScanInfo);




×







2521













UNCOV

2522



    taosMemoryFreeClear(pTSRow);





×








UNCOV

2523



    tsdbRowMergerClear(pMerger);




×








UNCOV

2524



    TSDB_CHECK_CODE(code, lino, _end);





×







2525



  }










2526













UNCOV

2527



_end:




×








UNCOV

2528



  if (code != TSDB_CODE_SUCCESS) {





×







2529



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





×







2530



  }











UNCOV

2531



  return code;




×







2532



}










2533













UNCOV

2534



static int32_t doMergeMultiLevelRows(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo, SBlockData* pBlockData,




×







2535



                                     SSttBlockReader* pSttBlockReader) {











UNCOV

2536



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

2537



  int32_t             lino = 0;




×








UNCOV

2538



  SRowMerger*         pMerger = NULL;




×








UNCOV

2539



  SRow*               pTSRow = NULL;




×








UNCOV

2540



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

2541



  SArray*             pDelList = NULL;




×








UNCOV

2542



  int32_t             pkSrcSlot = 0;




×








UNCOV

2543



  TSDBROW*            pRow = NULL;




×








UNCOV

2544



  TSDBROW*            piRow = NULL;




×








UNCOV

2545



  SRowKey*            pSttKey = NULL;




×







2546













UNCOV

2547



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2548



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2549



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2550













UNCOV

2551



  pMerger = &pReader->status.merger;




×








UNCOV

2552



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

2553



  pDelList = pBlockScanInfo->delSkyline;




×








UNCOV

2554



  pkSrcSlot = pReader->suppInfo.pkSrcSlot;




×







2555













UNCOV

2556



  code = getValidMemRow(&pBlockScanInfo->iter, pDelList, pReader, &pRow);




×








UNCOV

2557



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2558



  code = getValidMemRow(&pBlockScanInfo->iiter, pDelList, pReader, &piRow);




×








UNCOV

2559



  TSDB_CHECK_CODE(code, lino, _end);





×







2560













UNCOV

2561



  if (hasDataInSttBlock(pBlockScanInfo) && (!pBlockScanInfo->cleanSttBlocks)) {





×








UNCOV

2562



    pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);




×







2563



  }










2564













UNCOV

2565



  SRowKey* pfKey = &(SRowKey){0};




×








UNCOV

2566



  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {





×







2567



    tColRowGetKey(pBlockData, pDumpInfo->rowIndex, pfKey);





×







2568



  } else {











UNCOV

2569



    pfKey = NULL;




×







2570



  }










2571













UNCOV

2572



  SRowKey k = {0}, ik = {0};




×








UNCOV

2573



  tRowGetKeyEx(pRow, &k);





×








UNCOV

2574



  tRowGetKeyEx(piRow, &ik);





×







2575













UNCOV

2576



  STSchema* pSchema = NULL;




×








UNCOV

2577



  if (pRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

2578



    pSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, pBlockScanInfo->uid);





×








UNCOV

2579



    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);





×







2580



  }










2581













UNCOV

2582



  STSchema* piSchema = NULL;




×








UNCOV

2583



  if (piRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

2584



    piSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(piRow), pReader, pBlockScanInfo->uid);





×








UNCOV

2585



    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);





×







2586



  }










2587












2588



  // merge is not initialized yet, due to the fact that the pReader->info.pSchema is not initialized











UNCOV

2589



  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);




×








UNCOV

2590



  TSDB_CHECK_CODE(code, lino, _end);





×







2591













UNCOV

2592



  SRowKey minKey = k;




×








UNCOV

2593



  if (ASCENDING_TRAVERSE(pReader->info.order)) {





×








UNCOV

2594



    if (pkCompEx(&ik, &minKey) < 0) {  // minKey > ik.key.ts) {





×








UNCOV

2595



      minKey = ik;




×







2596



    }










2597













UNCOV

2598



    if ((pfKey != NULL) && (pkCompEx(pfKey, &minKey) < 0)) {





×







2599



      minKey = *pfKey;




×







2600



    }










2601













UNCOV

2602



    if ((pSttKey != NULL) && (pkCompEx(pSttKey, &minKey) < 0)) {





×








UNCOV

2603



      minKey = *pSttKey;




×







2604



    }










2605



  } else {










2606



    if (pkCompEx(&ik, &minKey) > 0) {





×







2607



      minKey = ik;




×







2608



    }










2609












2610



    if ((pfKey != NULL) && (pkCompEx(pfKey, &minKey) > 0)) {





×







2611



      minKey = *pfKey;




×







2612



    }










2613












2614



    if ((pSttKey != NULL) && (pkCompEx(pSttKey, &minKey) > 0)) {





×







2615



      minKey = *pSttKey;




×







2616



    }










2617



  }










2618













UNCOV

2619



  tRowKeyAssign(&pBlockScanInfo->lastProcKey, &minKey);




×







2620












2621



  // file block -----> stt block -----> imem -----> mem











UNCOV

2622



  if (pkCompEx(&minKey, pfKey) == 0) {





×







2623



    TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);




×







2624



    code = tsdbRowMergerAdd(pMerger, &fRow, NULL);




×







2625



    TSDB_CHECK_CODE(code, lino, _end);





×







2626












2627



    code = doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pfKey, pReader);




×







2628



    TSDB_CHECK_CODE(code, lino, _end);





×







2629



  }










2630













UNCOV

2631



  if (pkCompEx(&minKey, pSttKey) == 0) {





×








UNCOV

2632



    TSDBROW* pRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);




×








UNCOV

2633



    code = tsdbRowMergerAdd(pMerger, pRow1, NULL);




×








UNCOV

2634



    TSDB_CHECK_CODE(code, lino, _end);





×







2635













UNCOV

2636



    code = doMergeRowsInSttBlock(pSttBlockReader, pBlockScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange,




×








UNCOV

2637



                                 pReader->idStr);




×








UNCOV

2638



    TSDB_CHECK_CODE(code, lino, _end);





×







2639



  }










2640













UNCOV

2641



  if (pkCompEx(&minKey, &ik) == 0) {





×







2642



    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);




×







2643



    TSDB_CHECK_CODE(code, lino, _end);





×







2644












2645



    code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, &ik, pBlockScanInfo->delSkyline, pReader);




×







2646



    TSDB_CHECK_CODE(code, lino, _end);





×







2647



  }










2648













UNCOV

2649



  if (pkCompEx(&minKey, &k) == 0) {





×







2650



    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);




×







2651



    TSDB_CHECK_CODE(code, lino, _end);





×







2652












2653



    code = doMergeRowsInBuf(&pBlockScanInfo->iter, pBlockScanInfo->uid, &k, pBlockScanInfo->delSkyline, pReader);




×







2654



    TSDB_CHECK_CODE(code, lino, _end);





×







2655



  }










2656













UNCOV

2657



  code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

2658



  TSDB_CHECK_CODE(code, lino, _end);





×







2659













UNCOV

2660



  code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pBlockScanInfo);




×







2661













UNCOV

2662



  taosMemoryFreeClear(pTSRow);





×








UNCOV

2663



  tsdbRowMergerClear(pMerger);




×








UNCOV

2664



  TSDB_CHECK_CODE(code, lino, _end);





×







2665













UNCOV

2666



_end:




×








UNCOV

2667



  if (code != TSDB_CODE_SUCCESS) {





×







2668



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





×







2669



  }











UNCOV

2670



  return code;




×







2671



}










2672













UNCOV

2673



int32_t doInitMemDataIter(STsdbReader* pReader, STbData** pData, STableBlockScanInfo* pBlockScanInfo, STsdbRowKey* pKey,




×







2674



                          SMemTable* pMem, SIterInfo* pIter, const char* type) {











UNCOV

2675



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

2676



  int32_t lino = 0;




×








UNCOV

2677



  int32_t backward = false;




×







2678













UNCOV

2679



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2680



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2681



  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2682



  TSDB_CHECK_NULL(type, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2683













UNCOV

2684



  backward = (!ASCENDING_TRAVERSE(pReader->info.order));




×








UNCOV

2685



  pIter->hasVal = false;




×







2686













UNCOV

2687



  if (pMem != NULL) {





×








UNCOV

2688



    TSDB_CHECK_NULL(pData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2689



    *pData = tsdbGetTbDataFromMemTable(pMem, pReader->info.suid, pBlockScanInfo->uid);




×







2690













UNCOV

2691



    if ((*pData) != NULL) {





×








UNCOV

2692



      code = tsdbTbDataIterCreate((*pData), pKey, backward, &pIter->iter);




×








UNCOV

2693



      if (code == TSDB_CODE_SUCCESS) {





×








UNCOV

2694



        pIter->hasVal = (tsdbTbDataIterGet(pIter->iter) != NULL);





×







2695













UNCOV

2696



        tsdbDebug("%p uid:%" PRIu64 ", check data in %s from skey:%" PRId64 ", order:%d, ts range in buf:%" PRId64





×







2697



                  "-%" PRId64 " %s",










2698



                  pReader, pBlockScanInfo->uid, type, pKey->key.ts, pReader->info.order, (*pData)->minKey,










2699



                  (*pData)->maxKey, pReader->idStr);










2700



      } else {










2701



        tsdbError("%p uid:%" PRIu64 ", failed to create iterator for %s, code:%s, %s", pReader, pBlockScanInfo->uid,





×







2702



                  type, tstrerror(code), pReader->idStr);










2703



        TSDB_CHECK_CODE(code, lino, _end);





×







2704



      }










2705



    }










2706



  } else {











UNCOV

2707



    tsdbDebug("%p uid:%" PRIu64 ", no data in %s, %s", pReader, pBlockScanInfo->uid, type, pReader->idStr);





×







2708



  }










2709













UNCOV

2710



_end:




×








UNCOV

2711



  if (code != TSDB_CODE_SUCCESS) {





×







2712



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





×







2713



  }











UNCOV

2714



  return code;




×







2715



}










2716













UNCOV

2717



static int32_t doForwardDataIter(SRowKey* pKey, SIterInfo* pIter, STableBlockScanInfo* pBlockScanInfo,




×







2718



                                 STsdbReader* pReader) {











UNCOV

2719



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

2720



  int32_t  lino = 0;




×








UNCOV

2721



  SRowKey  rowKey = {0};




×








UNCOV

2722



  TSDBROW* pRow = NULL;




×







2723













UNCOV

2724



  while (1) {




×








UNCOV

2725



    code = getValidMemRow(pIter, pBlockScanInfo->delSkyline, pReader, &pRow);




×








UNCOV

2726



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2727



    if (!pIter->hasVal) {





×








UNCOV

2728



      break;




×







2729



    }










2730













UNCOV

2731



    tRowGetKeyEx(pRow, &rowKey);





×








UNCOV

2732



    int32_t ret = pkCompEx(pKey, &rowKey);




×








UNCOV

2733



    if (ret == 0) {





×







2734



      pIter->hasVal = tsdbTbDataIterNext(pIter->iter);




×







2735



    } else {











UNCOV

2736



      break;




×







2737



    }










2738



  }










2739













UNCOV

2740



_end:




×








UNCOV

2741



  if (code != TSDB_CODE_SUCCESS) {





×







2742



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





×







2743



  }











UNCOV

2744



  return code;




×







2745



}










2746












2747



// handle the open interval issue. Find the first row key that is greater than the given one.











UNCOV

2748



static int32_t forwardDataIter(SRowKey* pKey, STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader) {




×








UNCOV

2749



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

2750



  int32_t lino = 0;




×







2751













UNCOV

2752



  TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2753



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2754













UNCOV

2755



  code = doForwardDataIter(pKey, &pBlockScanInfo->iter, pBlockScanInfo, pReader);




×








UNCOV

2756



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2757



  code = doForwardDataIter(pKey, &pBlockScanInfo->iiter, pBlockScanInfo, pReader);




×








UNCOV

2758



  TSDB_CHECK_CODE(code, lino, _end);





×







2759













UNCOV

2760



_end:




×








UNCOV

2761



  if (code != TSDB_CODE_SUCCESS) {





×







2762



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





×







2763



  }











UNCOV

2764



  return code;




×







2765



}










2766













UNCOV

2767



static int32_t initMemDataIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader) {




×








UNCOV

2768



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

2769



  int32_t        lino = 0;




×








UNCOV

2770



  STbData*       d = NULL;




×








UNCOV

2771



  STbData*       di = NULL;




×








UNCOV

2772



  bool           asc = false;




×








UNCOV

2773



  bool           forward = true;




×








UNCOV

2774



  STsdbReadSnap* pSnap = NULL;




×








UNCOV

2775



  STimeWindow*   pWindow = NULL;




×







2776



  STsdbRowKey    startKey;










2777













UNCOV

2778



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2779



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2780













UNCOV

2781



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

2782



  pSnap = pReader->pReadSnap;




×








UNCOV

2783



  pWindow = &pReader->info.window;




×







2784













UNCOV

2785



  if (pBlockScanInfo->iterInit) {





×








UNCOV

2786



    goto _end;




×







2787



  }










2788













UNCOV

2789



  startKey.key = pBlockScanInfo->lastProcKey;




×








UNCOV

2790



  startKey.version = asc ? pReader->info.verRange.minVer : pReader->info.verRange.maxVer;





×








UNCOV

2791



  if ((asc && (startKey.key.ts < pWindow->skey)) || ((!asc) && startKey.key.ts > pWindow->ekey)) {





×








UNCOV

2792



    startKey.key.ts = asc ? pWindow->skey : pWindow->ekey;





×








UNCOV

2793



    forward = false;




×







2794



  }










2795













UNCOV

2796



  code = doInitMemDataIter(pReader, &d, pBlockScanInfo, &startKey, pSnap->pMem, &pBlockScanInfo->iter, "mem");




×








UNCOV

2797



  TSDB_CHECK_CODE(code, lino, _end);





×







2798













UNCOV

2799



  code = doInitMemDataIter(pReader, &di, pBlockScanInfo, &startKey, pSnap->pIMem, &pBlockScanInfo->iiter, "imem");




×








UNCOV

2800



  TSDB_CHECK_CODE(code, lino, _end);





×







2801













UNCOV

2802



  code = loadMemTombData(&pBlockScanInfo->pMemDelData, d, di, pReader->info.verRange.maxVer);




×








UNCOV

2803



  TSDB_CHECK_CODE(code, lino, _end);





×







2804













UNCOV

2805



  if (forward) {





×








UNCOV

2806



    code = forwardDataIter(&startKey.key, pBlockScanInfo, pReader);




×








UNCOV

2807



    TSDB_CHECK_CODE(code, lino, _end);





×







2808



  }










2809













UNCOV

2810



  pBlockScanInfo->iterInit = true;




×







2811













UNCOV

2812



_end:




×








UNCOV

2813



  if (code != TSDB_CODE_SUCCESS) {





×







2814



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





×







2815



  }











UNCOV

2816



  return code;




×







2817



}










2818













UNCOV

2819



static int32_t isValidFileBlockRow(SBlockData* pBlockData, int32_t rowIndex, STableBlockScanInfo* pBlockScanInfo,




×







2820



                                   bool asc, STsdbReaderInfo* pInfo, STsdbReader* pReader, bool* valid) {











UNCOV

2821



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

2822



  int32_t lino = 0;




×







2823













UNCOV

2824



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2825



  TSDB_CHECK_NULL(valid, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2826













UNCOV

2827



  *valid = false;




×







2828



  // it is an multi-table data block











UNCOV

2829



  if (pBlockData->aUid != NULL) {





×







2830



    uint64_t uid = pBlockData->aUid[rowIndex];




×







2831



    if (uid != pBlockScanInfo->uid) {  // move to next row





×







2832



      *valid = false;




×







2833



      goto _end;




×







2834



    }










2835



  }










2836













UNCOV

2837



  TSDB_CHECK_NULL(pInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2838



  // check for version and time range











UNCOV

2839



  int64_t ver = pBlockData->aVersion[rowIndex];




×








UNCOV

2840



  if (ver > pInfo->verRange.maxVer || ver < pInfo->verRange.minVer) {





×







2841



    *valid = false;




×







2842



    goto _end;




×







2843



  }










2844













UNCOV

2845



  int64_t ts = pBlockData->aTSKEY[rowIndex];




×








UNCOV

2846



  if (ts > pInfo->window.ekey || ts < pInfo->window.skey) {





×








UNCOV

2847



    *valid = false;




×








UNCOV

2848



    goto _end;




×







2849



  }










2850













UNCOV

2851



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2852



  if ((asc && (ts < pBlockScanInfo->lastProcKey.ts)) || ((!asc) && (ts > pBlockScanInfo->lastProcKey.ts))) {





×







2853



    *valid = false;




×







2854



    goto _end;




×







2855



  }










2856













UNCOV

2857



  if (ts == pBlockScanInfo->lastProcKey.ts) {  // todo opt perf





×







2858



    SRowKey nextRowKey;                        // lazy eval











UNCOV

2859



    tColRowGetKey(pBlockData, rowIndex, &nextRowKey);





×








UNCOV

2860



    if (pkCompEx(&pBlockScanInfo->lastProcKey, &nextRowKey) == 0) {





×







2861



      *valid = false;




×







2862



      goto _end;




×







2863



    }










2864



  }










2865













UNCOV

2866



  if (pBlockScanInfo->delSkyline != NULL && TARRAY_SIZE(pBlockScanInfo->delSkyline) > 0) {





×








UNCOV

2867



    bool dropped = false;




×








UNCOV

2868



    code = hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->fileDelIndex, ts, ver, pInfo->order,




×








UNCOV

2869



                          &pInfo->verRange, pReader->suppInfo.numOfPks > 0, &dropped);




×








UNCOV

2870



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2871



    if (dropped) {





×








UNCOV

2872



      *valid = false;




×








UNCOV

2873



      goto _end;




×







2874



    }










2875



  }










2876













UNCOV

2877



  *valid = true;




×







2878













UNCOV

2879



_end:




×








UNCOV

2880



  if (code != TSDB_CODE_SUCCESS) {





×







2881



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





×







2882



  }











UNCOV

2883



  return code;




×







2884



}










2885













UNCOV

2886



static void initSttBlockReader(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, STsdbReader* pReader) {




×








UNCOV

2887



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

2888



  int32_t              lino = 0;




×








UNCOV

2889



  int32_t              order = 0;




×








UNCOV

2890



  bool                 asc = false;




×








UNCOV

2891



  int64_t              st = 0;




×








UNCOV

2892



  SSttDataInfoForTable info = (SSttDataInfoForTable){0};




×







2893













UNCOV

2894



  TSDB_CHECK_NULL(pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2895



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

2896



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







2897













UNCOV

2898



  order = pReader->info.order;




×








UNCOV

2899



  asc = ASCENDING_TRAVERSE(order);




×







2900












2901



  // the stt block reader has been initialized for this table.











UNCOV

2902



  if (pSttBlockReader->uid == pScanInfo->uid) {





×








UNCOV

2903



    goto _end;




×







2904



  }










2905













UNCOV

2906



  if (pSttBlockReader->uid != 0) {





×








UNCOV

2907



    tMergeTreeClose(&pSttBlockReader->mergeTree);




×







2908



  }










2909













UNCOV

2910



  pSttBlockReader->uid = pScanInfo->uid;




×







2911












2912



  // second or third time init stt block reader











UNCOV

2913



  if (pScanInfo->cleanSttBlocks && (pReader->info.execMode == READER_EXEC_ROWS)) {





×







2914



    // only allowed to retrieve clean stt blocks for count once










2915



    if (pScanInfo->sttBlockReturned) {





×







2916



      pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;




×







2917



      tsdbDebug("uid:%" PRIu64 " set no stt-file data after stt-block retrieved, %s", pScanInfo->uid, pReader->idStr);





×







2918



    }










2919



    goto _end;




×







2920



  }










2921













UNCOV

2922



  STimeWindow w = pSttBlockReader->window;




×








UNCOV

2923



  if (asc) {





×








UNCOV

2924



    w.skey = pScanInfo->sttKeyInfo.nextProcKey.ts;




×







2925



  } else {











UNCOV

2926



    w.ekey = pScanInfo->sttKeyInfo.nextProcKey.ts;




×







2927



  }










2928













UNCOV

2929



  st = taosGetTimestampUs();




×








UNCOV

2930



  tsdbDebug("init stt block reader, window:%" PRId64 "-%" PRId64 ", uid:%" PRIu64 ", %s", w.skey, w.ekey,





×







2931



            pScanInfo->uid, pReader->idStr);










2932













UNCOV

2933



  SMergeTreeConf conf = {




×








UNCOV

2934



      .uid = pScanInfo->uid,




×








UNCOV

2935



      .suid = pReader->info.suid,




×








UNCOV

2936



      .pTsdb = pReader->pTsdb,




×







2937



      .timewindow = w,










2938



      .verRange = pSttBlockReader->verRange,










2939



      .strictTimeRange = false,











UNCOV

2940



      .pSchema = pReader->info.pSchema,




×








UNCOV

2941



      .pCurrentFileset = pReader->status.pCurrentFileset,




×








UNCOV

2942



      .backward = (pSttBlockReader->order == TSDB_ORDER_DESC),




×








UNCOV

2943



      .pSttFileBlockIterArray = pReader->status.pLDataIterArray,




×








UNCOV

2944



      .pCols = pReader->suppInfo.colId,




×








UNCOV

2945



      .numOfCols = pReader->suppInfo.numOfCols,




×







2946



      .loadTombFn = loadSttTombDataForAll,











UNCOV

2947



      .pCurRowKey = &pScanInfo->sttKeyInfo.nextProcKey,




×







2948



      .pReader = pReader,











UNCOV

2949



      .idstr = pReader->idStr,




×








UNCOV

2950



      .rspRows = (pReader->info.execMode == READER_EXEC_ROWS),




×







2951



  };










2952













UNCOV

2953



  info.pKeyRangeList = taosArrayInit(4, sizeof(SSttKeyRange));




×








UNCOV

2954



  TSDB_CHECK_NULL(info.pKeyRangeList, code, lino, _end, terrno);





×







2955













UNCOV

2956



  code = tMergeTreeOpen2(&pSttBlockReader->mergeTree, &conf, &info);




×








UNCOV

2957



  TSDB_CHECK_CODE(code, lino, _end);





×







2958













UNCOV

2959



  code = initMemDataIterator(pScanInfo, pReader);




×








UNCOV

2960



  TSDB_CHECK_CODE(code, lino, _end);





×







2961













UNCOV

2962



  code = initDelSkylineIterator(pScanInfo, pReader->info.order, &pReader->cost);




×








UNCOV

2963



  TSDB_CHECK_CODE(code, lino, _end);





×







2964













UNCOV

2965



  if (conf.rspRows) {





×








UNCOV

2966



    pScanInfo->cleanSttBlocks = isCleanSttBlock(info.pKeyRangeList, &pReader->info.window, pScanInfo, order);




×








UNCOV

2967



    if (pScanInfo->cleanSttBlocks) {





×








UNCOV

2968



      pScanInfo->numOfRowsInStt = info.numOfRows;




×







2969












2970



      // calculate the time window for data in stt files











UNCOV

2971



      for (int32_t i = 0; i < taosArrayGetSize(info.pKeyRangeList); ++i) {





×








UNCOV

2972



        SSttKeyRange* pKeyRange = taosArrayGet(info.pKeyRangeList, i);




×








UNCOV

2973



        if (pKeyRange == NULL) {





×







2974



          continue;




×







2975



        }










2976













UNCOV

2977



        if (pkCompEx(&pScanInfo->sttRange.skey, &pKeyRange->skey) > 0) {





×








UNCOV

2978



          tRowKeyAssign(&pScanInfo->sttRange.skey, &pKeyRange->skey);




×







2979



        }










2980













UNCOV

2981



        if (pkCompEx(&pScanInfo->sttRange.ekey, &pKeyRange->ekey) < 0) {





×








UNCOV

2982



          tRowKeyAssign(&pScanInfo->sttRange.ekey, &pKeyRange->ekey);




×







2983



        }










2984



      }










2985













UNCOV

2986



      pScanInfo->sttKeyInfo.status = taosArrayGetSize(info.pKeyRangeList) ? STT_FILE_HAS_DATA : STT_FILE_NO_DATA;





×







2987













UNCOV

2988



      SRowKey* p = asc ? &pScanInfo->sttRange.skey : &pScanInfo->sttRange.ekey;





×








UNCOV

2989



      tRowKeyAssign(&pScanInfo->sttKeyInfo.nextProcKey, p);




×







2990



    } else {                                // not clean stt blocks











UNCOV

2991



      INIT_KEYRANGE(&pScanInfo->sttRange);  // reset the time window




×








UNCOV

2992



      code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pReader->suppInfo.pkSrcSlot, &pReader->info.verRange);




×








UNCOV

2993



      if (code != TSDB_CODE_SUCCESS) {





×







2994



        pScanInfo->sttBlockReturned = false;




×







2995



        TSDB_CHECK_CODE(code, lino, _end);





×







2996



      }










2997



    }










2998



  } else {











UNCOV

2999



    pScanInfo->cleanSttBlocks = false;




×








UNCOV

3000



    INIT_KEYRANGE(&pScanInfo->sttRange);  // reset the time window




×








UNCOV

3001



    code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pReader->suppInfo.pkSrcSlot, &pReader->info.verRange);




×








UNCOV

3002



    if (code != TSDB_CODE_SUCCESS) {





×







3003



      pScanInfo->sttBlockReturned = false;




×







3004



      TSDB_CHECK_CODE(code, lino, _end);





×







3005



    }










3006



  }










3007













UNCOV

3008



  pScanInfo->sttBlockReturned = false;




×








UNCOV

3009



  int64_t el = taosGetTimestampUs() - st;




×








UNCOV

3010



  pReader->cost.initSttBlockReader += (el / 1000.0);




×







3011













UNCOV

3012



  tsdbDebug("init stt block reader completed, elapsed time:%" PRId64 "us %s", el, pReader->idStr);





×







3013













UNCOV

3014



_end:




×








UNCOV

3015



  if (code != TSDB_CODE_SUCCESS) {





×







3016



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





×







3017



    if (pReader) {





×







3018



      pReader->code = code;




×







3019



    }










3020



  }











UNCOV

3021



  taosArrayDestroy(info.pKeyRangeList);




×








UNCOV

3022



}




×







3023













UNCOV

3024



static bool hasDataInSttBlock(STableBlockScanInfo* pInfo) { return pInfo->sttKeyInfo.status == STT_FILE_HAS_DATA; }




×







3025













UNCOV

3026



bool hasDataInFileBlock(const SBlockData* pBlockData, const SFileBlockDumpInfo* pDumpInfo) {




×








UNCOV

3027



  if ((pBlockData->nRow > 0) && (pBlockData->nRow != pDumpInfo->totalRows)) {





×







3028



    return false;  // this is an invalid result.




×







3029



  }











UNCOV

3030



  return pBlockData->nRow > 0 && (!pDumpInfo->allDumped);





×







3031



}










3032













UNCOV

3033



int32_t mergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pBlockScanInfo, SRowKey* pKey,




×







3034



                              STsdbReader* pReader) {











UNCOV

3035



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

3036



  int32_t             lino = 0;




×








UNCOV

3037



  SRow*               pTSRow = NULL;




×








UNCOV

3038



  SRowMerger*         pMerger = NULL;




×








UNCOV

3039



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

3040



  bool                copied = false;




×







3041













UNCOV

3042



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3043



  TSDB_CHECK_NULL(pKey, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3044



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3045













UNCOV

3046



  pMerger = &pReader->status.merger;




×








UNCOV

3047



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







3048













UNCOV

3049



  code = tryCopyDistinctRowFromFileBlock(pReader, pBlockData, pKey, pDumpInfo, &copied);




×








UNCOV

3050



  TSDB_CHECK_CODE(code, lino, _end);





×







3051












3052



  // merge is not initialized yet, due to the fact that the pReader->info.pSchema is not initialized











UNCOV

3053



  code = initRowMergeIfNeeded(pReader, pBlockScanInfo->uid);




×








UNCOV

3054



  TSDB_CHECK_CODE(code, lino, _end);





×







3055













UNCOV

3056



  tRowKeyAssign(&pBlockScanInfo->lastProcKey, pKey);




×







3057













UNCOV

3058



  if (copied) {





×








UNCOV

3059



    goto _end;




×







3060



  }










3061













UNCOV

3062



  TSDBROW fRow = tsdbRowFromBlockData(pBlockData, pDumpInfo->rowIndex);




×







3063













UNCOV

3064



  code = tsdbRowMergerAdd(pMerger, &fRow, NULL);




×








UNCOV

3065



  TSDB_CHECK_CODE(code, lino, _end);





×







3066













UNCOV

3067



  code = doMergeRowsInFileBlocks(pBlockData, pBlockScanInfo, pKey, pReader);




×








UNCOV

3068



  TSDB_CHECK_CODE(code, lino, _end);





×







3069













UNCOV

3070



  code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

3071



  TSDB_CHECK_CODE(code, lino, _end);





×







3072













UNCOV

3073



  code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pBlockScanInfo);




×







3074













UNCOV

3075



  taosMemoryFreeClear(pTSRow);





×








UNCOV

3076



  tsdbRowMergerClear(pMerger);




×








UNCOV

3077



  TSDB_CHECK_CODE(code, lino, _end);





×







3078













UNCOV

3079



_end:




×








UNCOV

3080



  if (code != TSDB_CODE_SUCCESS) {





×







3081



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





×







3082



  }











UNCOV

3083



  return code;




×







3084



}










3085













UNCOV

3086



int32_t mergeRowsInSttBlocks(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, STsdbReader* pReader) {




×








UNCOV

3087



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

3088



  int32_t     lino = 0;




×








UNCOV

3089



  SRow*       pTSRow = NULL;




×








UNCOV

3090



  int32_t     pkSrcSlot = 0;




×








UNCOV

3091



  SRowMerger* pMerger = NULL;




×








UNCOV

3092



  bool        copied = false;




×







3093













UNCOV

3094



  TSDB_CHECK_NULL(pSttBlockReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3095



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3096



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3097













UNCOV

3098



  pkSrcSlot = pReader->suppInfo.pkSrcSlot;




×








UNCOV

3099



  pMerger = &pReader->status.merger;




×







3100












3101



  // let's record the last processed key











UNCOV

3102



  tRowKeyAssign(&pScanInfo->lastProcKey, getCurrentKeyInSttBlock(pSttBlockReader));




×







3103













UNCOV

3104



  TSDBROW* pRow = tMergeTreeGetRow(&pSttBlockReader->mergeTree);




×








UNCOV

3105



  TSDBROW  fRow = {.iRow = pRow->iRow, .type = TSDBROW_COL_FMT, .pBlockData = pRow->pBlockData};




×







3106













UNCOV

3107



  if (IS_VAR_DATA_TYPE(pScanInfo->lastProcKey.pks[0].type)) {





×







3108



    tsdbTrace("fRow ptr:%p, %d, uid:%" PRIu64 ", ts:%" PRId64 " pk:%s %s", pRow->pBlockData, pRow->iRow,





×







3109



              pSttBlockReader->uid, fRow.pBlockData->aTSKEY[fRow.iRow], pScanInfo->lastProcKey.pks[0].pData,










3110



              pReader->idStr);










3111



  }










3112













UNCOV

3113



  code = tryCopyDistinctRowFromSttBlock(&fRow, pSttBlockReader, pScanInfo, &pScanInfo->lastProcKey, pReader, &copied);




×








UNCOV

3114



  TSDB_CHECK_CODE(code, lino, _end);





×







3115













UNCOV

3116



  if (copied) {





×








UNCOV

3117



    goto _end;




×







3118



  }










3119













UNCOV

3120



  code = tsdbRowMergerAdd(pMerger, &fRow, NULL);




×








UNCOV

3121



  TSDB_CHECK_CODE(code, lino, _end);





×







3122













UNCOV

3123



  TSDBROW* pRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);




×








UNCOV

3124



  code = tsdbRowMergerAdd(pMerger, pRow1, NULL);




×








UNCOV

3125



  TSDB_CHECK_CODE(code, lino, _end);





×







3126













UNCOV

3127



  code = doMergeRowsInSttBlock(pSttBlockReader, pScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange, pReader->idStr);




×








UNCOV

3128



  TSDB_CHECK_CODE(code, lino, _end);





×







3129













UNCOV

3130



  code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

3131



  TSDB_CHECK_CODE(code, lino, _end);





×







3132













UNCOV

3133



  code = doAppendRowFromTSRow(pReader->resBlockInfo.pResBlock, pReader, pTSRow, pScanInfo);




×







3134













UNCOV

3135



  taosMemoryFreeClear(pTSRow);





×








UNCOV

3136



  tsdbRowMergerClear(pMerger);




×








UNCOV

3137



  TSDB_CHECK_CODE(code, lino, _end);





×







3138













UNCOV

3139



_end:




×








UNCOV

3140



  if (code != TSDB_CODE_SUCCESS) {





×







3141



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





×







3142



  }











UNCOV

3143



  return code;




×







3144



}










3145













UNCOV

3146



static int32_t buildComposedDataBlockImpl(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo,




×







3147



                                          SBlockData* pBlockData, SSttBlockReader* pSttBlockReader) {











UNCOV

3148



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

3149



  int32_t             lino = 0;




×








UNCOV

3150



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

3151



  TSDBROW*            pRow = NULL;




×








UNCOV

3152



  TSDBROW*            piRow = NULL;




×








UNCOV

3153



  SRowKey*            pKey = &(SRowKey){0};




×







3154













UNCOV

3155



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3156



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3157



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3158













UNCOV

3159



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







3160













UNCOV

3161



  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {





×








UNCOV

3162



    tColRowGetKey(pBlockData, pDumpInfo->rowIndex, pKey);





×







3163



  } else {











UNCOV

3164



    pKey = NULL;




×







3165



  }










3166













UNCOV

3167



  if (pBlockScanInfo->iter.hasVal) {





×








UNCOV

3168



    code = getValidMemRow(&pBlockScanInfo->iter, pBlockScanInfo->delSkyline, pReader, &pRow);




×








UNCOV

3169



    TSDB_CHECK_CODE(code, lino, _end);





×







3170



  }










3171













UNCOV

3172



  if (pBlockScanInfo->iiter.hasVal) {





×








UNCOV

3173



    code = getValidMemRow(&pBlockScanInfo->iiter, pBlockScanInfo->delSkyline, pReader, &piRow);




×








UNCOV

3174



    TSDB_CHECK_CODE(code, lino, _end);





×







3175



  }










3176













UNCOV

3177



  if (pRow != NULL && piRow != NULL) {





×







3178



    // two levels of mem-table does contain the valid rows











UNCOV

3179



    code = doMergeMultiLevelRows(pReader, pBlockScanInfo, pBlockData, pSttBlockReader);




×








UNCOV

3180



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3181



  } else if (pBlockScanInfo->iiter.hasVal) {





×







3182



    // imem + file + stt block











UNCOV

3183



    code = doMergeBufAndFileRows(pReader, pBlockScanInfo, piRow, &pBlockScanInfo->iiter, pSttBlockReader);




×








UNCOV

3184



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3185



  } else if (pBlockScanInfo->iter.hasVal) {





×







3186



    // mem + file + stt block











UNCOV

3187



    code = doMergeBufAndFileRows(pReader, pBlockScanInfo, pRow, &pBlockScanInfo->iter, pSttBlockReader);




×








UNCOV

3188



    TSDB_CHECK_CODE(code, lino, _end);





×







3189



  } else {










3190



    // files data blocks + stt block











UNCOV

3191



    code = mergeFileBlockAndSttBlock(pReader, pSttBlockReader, pKey, pBlockScanInfo, pBlockData);




×








UNCOV

3192



    TSDB_CHECK_CODE(code, lino, _end);





×







3193



  }










3194













UNCOV

3195



_end:




×








UNCOV

3196



  if (code != TSDB_CODE_SUCCESS) {





×







3197



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





×







3198



  }











UNCOV

3199



  return code;




×







3200



}










3201













UNCOV

3202



static int32_t loadNeighborIfOverlap(SFileDataBlockInfo* pBlockInfo, STableBlockScanInfo* pBlockScanInfo,




×







3203



                                     STsdbReader* pReader, bool* loadNeighbor) {











UNCOV

3204



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

3205



  int32_t             lino = 0;




×








UNCOV

3206



  int32_t             order = 0;




×








UNCOV

3207



  SDataBlockIter*     pIter = NULL;




×








UNCOV

3208



  SBlockLoadSuppInfo* pSupInfo = NULL;




×








UNCOV

3209



  int32_t             step = 0;




×








UNCOV

3210



  int32_t             nextIndex = -1;




×








UNCOV

3211



  SBrinRecord         rec = {0};




×








UNCOV

3212



  bool                hasNeighbor = false;




×







3213













UNCOV

3214



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3215



  TSDB_CHECK_NULL(loadNeighbor, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3216













UNCOV

3217



  order = pReader->info.order;




×








UNCOV

3218



  pIter = &pReader->status.blockIter;




×








UNCOV

3219



  pSupInfo = &pReader->suppInfo;




×








UNCOV

3220



  step = ASCENDING_TRAVERSE(order) ? 1 : -1;





×







3221













UNCOV

3222



  *loadNeighbor = false;




×








UNCOV

3223



  code = getNeighborBlockOfTable(pIter, pBlockInfo, pBlockScanInfo, &nextIndex, order, &rec, pSupInfo, &hasNeighbor);




×








UNCOV

3224



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3225



  if (!hasNeighbor) {  // do nothing





×








UNCOV

3226



    goto _end;




×







3227



  }










3228












3229



  // load next block











UNCOV

3230



  if (overlapWithNeighborBlock2(pBlockInfo, &rec, order, pReader->suppInfo.pk.type, pReader->suppInfo.numOfPks)) {





×








UNCOV

3231



    SReaderStatus*  pStatus = &pReader->status;




×








UNCOV

3232



    SDataBlockIter* pBlockIter = &pStatus->blockIter;




×







3233












3234



    // 1. find the next neighbor block in the scan block list











UNCOV

3235



    STableDataBlockIdx* tableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, nextIndex);




×








UNCOV

3236



    TSDB_CHECK_NULL(tableDataBlockIdx, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3237












3238



    // 2. remove it from the scan block list











UNCOV

3239



    int32_t neighborIndex = tableDataBlockIdx->globalIndex;




×








UNCOV

3240



    code = setFileBlockActiveInBlockIter(pReader, pBlockIter, neighborIndex, step);




×








UNCOV

3241



    TSDB_CHECK_CODE(code, lino, _end);





×







3242












3243



    // 3. load the neighbor block, and set it to be the currently accessed file data block











UNCOV

3244



    code = doLoadFileBlockData(pReader, pBlockIter, &pStatus->fileBlockData, pBlockInfo->uid);




×








UNCOV

3245



    TSDB_CHECK_CODE(code, lino, _end);





×







3246












3247



    // 4. check the data values











UNCOV

3248



    code = initBlockDumpInfo(pReader, pBlockIter);




×








UNCOV

3249



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3250



    *loadNeighbor = true;




×







3251



  }










3252













UNCOV

3253



_end:




×








UNCOV

3254



  if (code != TSDB_CODE_SUCCESS) {





×







3255



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





×







3256



  }











UNCOV

3257



  return code;




×







3258



}










3259













UNCOV

3260



void updateComposedBlockInfo(STsdbReader* pReader, double el, STableBlockScanInfo* pBlockScanInfo) {




×








UNCOV

3261



  SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;




×







3262













UNCOV

3263



  pResBlock->info.id.uid = (pBlockScanInfo != NULL) ? pBlockScanInfo->uid : 0;





×








UNCOV

3264



  pResBlock->info.dataLoad = 1;




×








UNCOV

3265



  pResBlock->info.version = pReader->info.verRange.maxVer;




×







3266













UNCOV

3267



  int32_t code = blockDataUpdateTsWindow(pResBlock, pReader->suppInfo.slotId[0]);




×








UNCOV

3268



  code = blockDataUpdatePkRange(pResBlock, pReader->suppInfo.pkDstSlot, ASCENDING_TRAVERSE(pReader->info.order));




×








UNCOV

3269



  setComposedBlockFlag(pReader, true);




×







3270













UNCOV

3271



  pReader->cost.composedBlocks += 1;




×








UNCOV

3272



  pReader->cost.buildComposedBlockTime += el;




×








UNCOV

3273



}




×







3274













UNCOV

3275



static int32_t buildComposedDataBlock(STsdbReader* pReader) {




×








UNCOV

3276



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

3277



  int32_t              lino = 0;




×








UNCOV

3278



  bool                 asc = false;




×








UNCOV

3279



  int64_t              st = 0;




×








UNCOV

3280



  double               el = 0;




×








UNCOV

3281



  int32_t              step = 0;




×








UNCOV

3282



  SSDataBlock*         pResBlock = NULL;




×








UNCOV

3283



  SFileDataBlockInfo*  pBlockInfo = NULL;




×








UNCOV

3284



  SSttBlockReader*     pSttBlockReader = NULL;




×








UNCOV

3285



  SFileBlockDumpInfo*  pDumpInfo = NULL;




×








UNCOV

3286



  STableBlockScanInfo* pBlockScanInfo = NULL;




×







3287



  TSDBKEY              keyInBuf;










3288













UNCOV

3289



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3290













UNCOV

3291



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

3292



  st = taosGetTimestampUs();




×








UNCOV

3293



  step = asc ? 1 : -1;





×








UNCOV

3294



  pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

3295



  pSttBlockReader = pReader->status.fileIter.pSttBlockReader;




×








UNCOV

3296



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







3297













UNCOV

3298



  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

3299



  if (code != TSDB_CODE_SUCCESS) {





×







3300



    return 0;




×







3301



  }










3302













UNCOV

3303



  if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {





×







3304



    setBlockAllDumped(pDumpInfo, pBlockInfo->lastKey, pReader->info.order);




×







3305



    return code;




×







3306



  }










3307













UNCOV

3308



  code = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);




×








UNCOV

3309



  TSDB_CHECK_CODE(code, lino, _end);





×







3310













UNCOV

3311



  code = getCurrentKeyInBuf(pBlockScanInfo, pReader, &keyInBuf);




×








UNCOV

3312



  TSDB_CHECK_CODE(code, lino, _end);





×







3313












3314



  // it is a clean block, load it directly











UNCOV

3315



  int64_t cap = pReader->resBlockInfo.capacity;




×








UNCOV

3316



  bool    isClean = false;




×








UNCOV

3317



  code = isCleanFileDataBlock(pReader, pBlockInfo, pBlockScanInfo, keyInBuf, &isClean);




×








UNCOV

3318



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3319



  bool directCopy = isClean && (pBlockInfo->numRow <= cap) && (pBlockScanInfo->sttKeyInfo.status == STT_FILE_NO_DATA) &&





×








UNCOV

3320



                    ((asc && ((pBlockInfo->lastKey < keyInBuf.ts) || (keyInBuf.ts == INT64_MIN))) ||





×








UNCOV

3321



                     (!asc && (pBlockInfo->lastKey > keyInBuf.ts)));





×








UNCOV

3322



  if (directCopy) {





×








UNCOV

3323



    code = copyBlockDataToSDataBlock(pReader, &pBlockScanInfo->lastProcKey);




×








UNCOV

3324



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3325



    goto _end;




×







3326



  }










3327













UNCOV

3328



  SBlockData* pBlockData = &pReader->status.fileBlockData;




×








UNCOV

3329



  initSttBlockReader(pSttBlockReader, pBlockScanInfo, pReader);




×








UNCOV

3330



  code = pReader->code;




×








UNCOV

3331



  TSDB_CHECK_CODE(code, lino, _end);





×







3332













UNCOV

3333



  while (1) {




×








UNCOV

3334



    bool hasBlockData = false;




×







3335



    {











UNCOV

3336



      while (pBlockData->nRow > 0 && pBlockData->uid == pBlockScanInfo->uid) {





×







3337



        // find the first qualified row in data block











UNCOV

3338



        bool valid = false;




×







3339



        code =











UNCOV

3340



            isValidFileBlockRow(pBlockData, pDumpInfo->rowIndex, pBlockScanInfo, asc, &pReader->info, pReader, &valid);




×








UNCOV

3341



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3342



        if (valid) {





×








UNCOV

3343



          hasBlockData = true;




×








UNCOV

3344



          break;




×







3345



        }










3346













UNCOV

3347



        pDumpInfo->rowIndex += step;




×







3348













UNCOV

3349



        if (pDumpInfo->rowIndex >= pBlockData->nRow || pDumpInfo->rowIndex < 0) {





×







3350



          // NOTE: get the new block info










3351



          code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

3352



          TSDB_CHECK_CODE(code, lino, _end);





×







3353












3354



          // continue check for the next file block if the last ts in the current block










3355



          // is overlapped with the next neighbor block











UNCOV

3356



          bool loadNeighbor = false;




×








UNCOV

3357



          code = loadNeighborIfOverlap(pBlockInfo, pBlockScanInfo, pReader, &loadNeighbor);




×








UNCOV

3358



          if ((!loadNeighbor) || (code != 0)) {





×








UNCOV

3359



            lino = __LINE__;




×








UNCOV

3360



            setBlockAllDumped(pDumpInfo, pBlockInfo->lastKey, pReader->info.order);




×








UNCOV

3361



            break;




×







3362



          }










3363



        }










3364



      }










3365



    }










3366












3367



    // no data in last block and block, no need to proceed.











UNCOV

3368



    if (hasBlockData == false) {





×








UNCOV

3369



      break;




×







3370



    }










3371













UNCOV

3372



    code = buildComposedDataBlockImpl(pReader, pBlockScanInfo, pBlockData, pSttBlockReader);




×








UNCOV

3373



    TSDB_CHECK_CODE(code, lino, _end);





×







3374












3375



    // currently loaded file data block is consumed











UNCOV

3376



    if ((pBlockData->nRow > 0) && (pDumpInfo->rowIndex >= pBlockData->nRow || pDumpInfo->rowIndex < 0)) {





×








UNCOV

3377



      setBlockAllDumped(pDumpInfo, pBlockInfo->lastKey, pReader->info.order);




×








UNCOV

3378



      break;




×







3379



    }










3380













UNCOV

3381



    if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {





×








UNCOV

3382



      break;




×







3383



    }










3384



  }










3385













UNCOV

3386



_end:




×








UNCOV

3387



  if (pReader) {





×








UNCOV

3388



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




×








UNCOV

3389



    updateComposedBlockInfo(pReader, el, pBlockScanInfo);




×







3390



  }










3391













UNCOV

3392



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





×








UNCOV

3393



    tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64





×







3394



              ", elapsed time:%.2f ms %s",










3395



              pReader, pResBlock->info.id.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,










3396



              pResBlock->info.rows, el, pReader->idStr);










3397



  }










3398













UNCOV

3399



  if (code != TSDB_CODE_SUCCESS) {





×







3400



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





×







3401



  }











UNCOV

3402



  return code;




×







3403



}










3404













UNCOV

3405



void setComposedBlockFlag(STsdbReader* pReader, bool composed) { pReader->status.composedDataBlock = composed; }




×







3406













UNCOV

3407



int32_t getInitialDelIndex(const SArray* pDelSkyline, int32_t order) {




×








UNCOV

3408



  if (pDelSkyline == NULL) {





×







3409



    return 0;




×







3410



  }










3411













UNCOV

3412



  return ASCENDING_TRAVERSE(order) ? 0 : taosArrayGetSize(pDelSkyline) - 1;





×







3413



}










3414













UNCOV

3415



int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, int32_t order, SReadCostSummary* pCost) {




×








UNCOV

3416



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

3417



  int32_t lino = 0;




×








UNCOV

3418



  int32_t newDelDataInFile = 0;




×








UNCOV

3419



  int64_t st = 0;




×








UNCOV

3420



  SArray* pSource = NULL;




×







3421













UNCOV

3422



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3423













UNCOV

3424



  newDelDataInFile = taosArrayGetSize(pBlockScanInfo->pFileDelData);




×








UNCOV

3425



  if (newDelDataInFile == 0 &&





×








UNCOV

3426



      ((pBlockScanInfo->delSkyline != NULL) || (TARRAY_SIZE(pBlockScanInfo->pMemDelData) == 0))) {





×








UNCOV

3427



    goto _end;




×







3428



  }










3429













UNCOV

3430



  st = taosGetTimestampUs();




×







3431













UNCOV

3432



  if (pBlockScanInfo->delSkyline != NULL) {





×








UNCOV

3433



    taosArrayClear(pBlockScanInfo->delSkyline);




×







3434



  } else {











UNCOV

3435



    pBlockScanInfo->delSkyline = taosArrayInit(4, sizeof(TSDBKEY));




×








UNCOV

3436



    TSDB_CHECK_NULL(pBlockScanInfo->delSkyline, code, lino, _end, terrno);





×







3437



  }










3438













UNCOV

3439



  pSource = pBlockScanInfo->pFileDelData;




×








UNCOV

3440



  if (pSource == NULL) {





×








UNCOV

3441



    pSource = pBlockScanInfo->pMemDelData;




×







3442



  } else {











UNCOV

3443



    const void* p1 = taosArrayAddAll(pSource, pBlockScanInfo->pMemDelData);




×








UNCOV

3444



    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);





×







3445



  }










3446













UNCOV

3447



  code = tsdbBuildDeleteSkyline(pSource, 0, taosArrayGetSize(pSource) - 1, pBlockScanInfo->delSkyline);




×







3448













UNCOV

3449



  taosArrayClear(pBlockScanInfo->pFileDelData);




×








UNCOV

3450



  int32_t index = getInitialDelIndex(pBlockScanInfo->delSkyline, order);




×







3451













UNCOV

3452



  pBlockScanInfo->iter.index = index;




×








UNCOV

3453



  pBlockScanInfo->iiter.index = index;




×








UNCOV

3454



  pBlockScanInfo->fileDelIndex = index;




×








UNCOV

3455



  pBlockScanInfo->sttBlockDelIndex = index;




×








UNCOV

3456



  TSDB_CHECK_CODE(code, lino, _end);





×







3457













UNCOV

3458



  TSDB_CHECK_NULL(pCost, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3459



  double el = taosGetTimestampUs() - st;




×








UNCOV

3460



  pCost->createSkylineIterTime = el / 1000.0;




×







3461













UNCOV

3462



_end:




×








UNCOV

3463



  if (code != TSDB_CODE_SUCCESS) {





×







3464



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





×







3465



  }











UNCOV

3466



  return code;




×







3467



}










3468













UNCOV

3469



int32_t getCurrentKeyInBuf(STableBlockScanInfo* pScanInfo, STsdbReader* pReader, TSDBKEY* pkey) {




×








UNCOV

3470



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

3471



  int32_t  lino = 0;




×








UNCOV

3472



  bool     asc = false;




×








UNCOV

3473



  bool     hasKey = false;




×








UNCOV

3474



  bool     hasIKey = false;




×








UNCOV

3475



  TSDBROW* pRow = NULL;




×








UNCOV

3476



  TSDBROW* pIRow = NULL;




×








UNCOV

3477



  TSDBKEY  key = {.ts = TSKEY_INITIAL_VAL};




×








UNCOV

3478



  TSDBKEY  ikey = {.ts = TSKEY_INITIAL_VAL};




×







3479













UNCOV

3480



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3481



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3482



  TSDB_CHECK_NULL(pkey, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3483













UNCOV

3484



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×







3485













UNCOV

3486



  code = getValidMemRow(&pScanInfo->iter, pScanInfo->delSkyline, pReader, &pRow);




×








UNCOV

3487



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3488



  if (pRow != NULL) {





×








UNCOV

3489



    hasKey = true;




×








UNCOV

3490



    key = TSDBROW_KEY(pRow);





×







3491



  }










3492













UNCOV

3493



  code = getValidMemRow(&pScanInfo->iiter, pScanInfo->delSkyline, pReader, &pIRow);




×








UNCOV

3494



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3495



  if (pIRow != NULL) {





×








UNCOV

3496



    hasIKey = true;




×








UNCOV

3497



    ikey = TSDBROW_KEY(pIRow);





×







3498



  }










3499













UNCOV

3500



  if (hasKey) {





×








UNCOV

3501



    if (hasIKey) {  // has data in mem & imem





×








UNCOV

3502



      if (asc) {





×








UNCOV

3503



        *pkey = key.ts <= ikey.ts ? key : ikey;





×







3504



      } else {










3505



        *pkey = key.ts <= ikey.ts ? ikey : key;





×







3506



      }










3507



    } else {  // no data in imem











UNCOV

3508



      *pkey = key;




×







3509



    }










3510



  } else {










3511



    // no data in mem & imem, return the initial value










3512



    // only imem has data, return ikey











UNCOV

3513



    *pkey = ikey;




×







3514



  }










3515













UNCOV

3516



_end:




×








UNCOV

3517



  if (code != TSDB_CODE_SUCCESS) {





×







3518



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





×







3519



  }











UNCOV

3520



  return code;




×







3521



}










3522













UNCOV

3523



static void prepareDurationForNextFileSet(STsdbReader* pReader) {




×








UNCOV

3524



  if (pReader->status.bProcMemFirstFileset) {





×








UNCOV

3525



    pReader->status.prevFilesetStartKey = INT64_MIN;




×








UNCOV

3526



    pReader->status.prevFilesetEndKey = INT64_MAX;




×








UNCOV

3527



    pReader->status.bProcMemFirstFileset = false;




×







3528



  }










3529













UNCOV

3530



  int32_t     fid = pReader->status.pCurrentFileset->fid;




×








UNCOV

3531



  STimeWindow winFid = {0};




×








UNCOV

3532



  tsdbFidKeyRange(fid, pReader->pTsdb->keepCfg.days, pReader->pTsdb->keepCfg.precision, &winFid.skey, &winFid.ekey);




×







3533













UNCOV

3534



  if (ASCENDING_TRAVERSE(pReader->info.order)) {





×








UNCOV

3535



    pReader->status.bProcMemPreFileset = !(pReader->status.memTableMaxKey < pReader->status.prevFilesetStartKey ||





×








UNCOV

3536



                                           (winFid.skey - 1) < pReader->status.memTableMinKey);





×







3537



  } else {











UNCOV

3538



    pReader->status.bProcMemPreFileset = !(pReader->status.memTableMaxKey < (winFid.ekey + 1) ||





×








UNCOV

3539



                                           pReader->status.prevFilesetEndKey < pReader->status.memTableMinKey);





×







3540



  }










3541













UNCOV

3542



  if (pReader->status.bProcMemPreFileset) {





×








UNCOV

3543



    tsdbDebug("will start pre-fileset %d buffer processing. %s", fid, pReader->idStr);





×








UNCOV

3544



    pReader->status.procMemUidList.tableUidList = pReader->status.uidList.tableUidList;




×








UNCOV

3545



    resetPreFilesetMemTableListIndex(&pReader->status);




×







3546



  }










3547













UNCOV

3548



  if (!pReader->status.bProcMemPreFileset) {





×








UNCOV

3549



    if (pReader->notifyFn) {





×








UNCOV

3550



      STsdReaderNotifyInfo info = {0};




×








UNCOV

3551



      info.duration.filesetId = fid;




×








UNCOV

3552



      pReader->notifyFn(TSD_READER_NOTIFY_DURATION_START, &info, pReader->notifyParam);




×








UNCOV

3553



      tsdbDebug("new duration %d start notification when no buffer preceeding fileset, %s", fid, pReader->idStr);





×







3554



    }










3555



  }










3556













UNCOV

3557



  pReader->status.prevFilesetStartKey = winFid.skey;




×








UNCOV

3558



  pReader->status.prevFilesetEndKey = winFid.ekey;




×








UNCOV

3559



}




×







3560













UNCOV

3561



static int32_t moveToNextFile(STsdbReader* pReader, SBlockNumber* pBlockNum, SArray* pTableList) {




×








UNCOV

3562



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

3563



  int32_t        lino = 0;




×








UNCOV

3564



  SReaderStatus* pStatus = NULL;




×








UNCOV

3565



  SArray*        pIndexList = NULL;




×








UNCOV

3566



  size_t         numOfTables = 0;




×







3567













UNCOV

3568



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3569



  TSDB_CHECK_NULL(pBlockNum, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3570













UNCOV

3571



  pStatus = &pReader->status;




×








UNCOV

3572



  pBlockNum->numOfBlocks = 0;




×








UNCOV

3573



  pBlockNum->numOfSttFiles = 0;




×







3574













UNCOV

3575



  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);




×








UNCOV

3576



  pIndexList = taosArrayInit(numOfTables, sizeof(SBrinBlk));




×








UNCOV

3577



  TSDB_CHECK_NULL(pIndexList, code, lino, _end, terrno);





×







3578













UNCOV

3579



  while (1) {




×







3580



    // only check here, since the iterate data in memory is very fast.











UNCOV

3581



    if (pReader->code != TSDB_CODE_SUCCESS) {





×







3582



      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);





×







3583



      code = pReader->code;




×







3584



      TSDB_CHECK_CODE(code, lino, _end);





×







3585



    }










3586













UNCOV

3587



    bool hasNext = false;




×








UNCOV

3588



    code = filesetIteratorNext(&pStatus->fileIter, pReader, &hasNext);




×








UNCOV

3589



    TSDB_CHECK_CODE(code, lino, _end);





×







3590













UNCOV

3591



    if (!hasNext) {  // no data files on disk





×








UNCOV

3592



      break;




×







3593



    }










3594













UNCOV

3595



    taosArrayClear(pIndexList);




×








UNCOV

3596



    code = doLoadBlockIndex(pReader, pReader->pFileReader, pIndexList);




×








UNCOV

3597



    TSDB_CHECK_CODE(code, lino, _end);





×







3598













UNCOV

3599



    if (taosArrayGetSize(pIndexList) > 0 || pReader->status.pCurrentFileset->lvlArr->size > 0) {





×








UNCOV

3600



      code = loadFileBlockBrinInfo(pReader, pIndexList, pBlockNum, pTableList);




×








UNCOV

3601



      TSDB_CHECK_CODE(code, lino, _end);





×







3602













UNCOV

3603



      if (pBlockNum->numOfBlocks + pBlockNum->numOfSttFiles > 0) {





×








UNCOV

3604



        if (pReader->bFilesetDelimited) {





×








UNCOV

3605



          prepareDurationForNextFileSet(pReader);




×







3606



        }











UNCOV

3607



        break;




×







3608



      }










3609



    }










3610












3611



    // no blocks in current file, try next files










3612



  }










3613













UNCOV

3614



  code = loadDataFileTombDataForAll(pReader);




×








UNCOV

3615



  TSDB_CHECK_CODE(code, lino, _end);





×







3616













UNCOV

3617



_end:




×








UNCOV

3618



  if (code != TSDB_CODE_SUCCESS) {





×







3619



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





×







3620



  }











UNCOV

3621



  if (pIndexList) {





×








UNCOV

3622



    taosArrayDestroy(pIndexList);




×







3623



  }











UNCOV

3624



  return code;




×







3625



}










3626












3627



// pTableIter can be NULL, no need to handle the return value











UNCOV

3628



static int32_t resetTableListIndex(SReaderStatus* pStatus, const char* id) {




×








UNCOV

3629



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

3630



  int32_t        lino = 0;




×








UNCOV

3631



  STableUidList* pList = NULL;




×







3632













UNCOV

3633



  TSDB_CHECK_NULL(pStatus, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3634













UNCOV

3635



  pList = &pStatus->uidList;




×







3636













UNCOV

3637



  pList->currentIndex = 0;




×








UNCOV

3638



  uint64_t uid = pList->tableUidList[0];




×








UNCOV

3639



  pStatus->pTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));




×








UNCOV

3640



  if (pStatus->pTableIter == NULL) {





×







3641



    tsdbError("%s failed to load tableBlockScanInfo for uid:%" PRId64 ", code: internal error", id, uid);





×







3642



    TSDB_CHECK_NULL(pStatus->pTableIter, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);





×







3643



  }










3644













UNCOV

3645



_end:




×








UNCOV

3646



  if (code != TSDB_CODE_SUCCESS) {





×







3647



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





×







3648



  }











UNCOV

3649



  return code;




×







3650



}










3651













UNCOV

3652



static void resetPreFilesetMemTableListIndex(SReaderStatus* pStatus) {




×








UNCOV

3653



  STableUidList* pList = &pStatus->procMemUidList;




×







3654













UNCOV

3655



  pList->currentIndex = 0;




×








UNCOV

3656



  uint64_t uid = pList->tableUidList[0];




×








UNCOV

3657



  pStatus->pProcMemTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));




×








UNCOV

3658



}




×







3659













UNCOV

3660



static bool moveToNextTable(STableUidList* pOrderedCheckInfo, SReaderStatus* pStatus) {




×








UNCOV

3661



  pOrderedCheckInfo->currentIndex += 1;




×








UNCOV

3662



  if (pOrderedCheckInfo->currentIndex >= tSimpleHashGetSize(pStatus->pTableMap)) {





×








UNCOV

3663



    pStatus->pTableIter = NULL;




×








UNCOV

3664



    return false;




×







3665



  }










3666













UNCOV

3667



  uint64_t uid = pOrderedCheckInfo->tableUidList[pOrderedCheckInfo->currentIndex];




×








UNCOV

3668



  pStatus->pTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));




×








UNCOV

3669



  return (pStatus->pTableIter != NULL);




×







3670



}










3671













UNCOV

3672



static bool moveToNextTableForPreFileSetMem(SReaderStatus* pStatus) {




×








UNCOV

3673



  STableUidList* pUidList = &pStatus->procMemUidList;




×








UNCOV

3674



  pUidList->currentIndex += 1;




×








UNCOV

3675



  if (pUidList->currentIndex >= tSimpleHashGetSize(pStatus->pTableMap)) {





×








UNCOV

3676



    pStatus->pProcMemTableIter = NULL;




×








UNCOV

3677



    return false;




×







3678



  }










3679













UNCOV

3680



  uint64_t uid = pUidList->tableUidList[pUidList->currentIndex];




×








UNCOV

3681



  pStatus->pProcMemTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));




×








UNCOV

3682



  return (pStatus->pProcMemTableIter != NULL);




×







3683



}










3684













UNCOV

3685



static int32_t buildCleanBlockFromSttFiles(STsdbReader* pReader, STableBlockScanInfo* pScanInfo) {




×








UNCOV

3686



  int32_t          code = TSDB_CODE_SUCCESS;




×








UNCOV

3687



  int32_t          lino = 0;




×








UNCOV

3688



  SReaderStatus*   pStatus = NULL;




×








UNCOV

3689



  SSttBlockReader* pSttBlockReader = NULL;




×








UNCOV

3690



  SSDataBlock*     pResBlock = NULL;




×








UNCOV

3691



  SDataBlockInfo*  pInfo = NULL;




×








UNCOV

3692



  bool             asc = false;




×







3693













UNCOV

3694



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3695



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3696













UNCOV

3697



  pStatus = &pReader->status;




×








UNCOV

3698



  pSttBlockReader = pStatus->fileIter.pSttBlockReader;




×








UNCOV

3699



  pResBlock = pReader->resBlockInfo.pResBlock;




×







3700













UNCOV

3701



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

3702



  code = blockDataEnsureCapacity(pResBlock, pScanInfo->numOfRowsInStt);




×








UNCOV

3703



  TSDB_CHECK_CODE(code, lino, _end);





×







3704













UNCOV

3705



  pInfo = &pResBlock->info;




×








UNCOV

3706



  pInfo->rows = pScanInfo->numOfRowsInStt;




×








UNCOV

3707



  pInfo->id.uid = pScanInfo->uid;




×








UNCOV

3708



  pInfo->dataLoad = 1;




×








UNCOV

3709



  pInfo->window.skey = pScanInfo->sttRange.skey.ts;




×








UNCOV

3710



  pInfo->window.ekey = pScanInfo->sttRange.ekey.ts;




×







3711













UNCOV

3712



  setComposedBlockFlag(pReader, true);




×







3713













UNCOV

3714



  pScanInfo->sttKeyInfo.nextProcKey.ts = asc ? pScanInfo->sttRange.ekey.ts + 1 : pScanInfo->sttRange.skey.ts - 1;





×








UNCOV

3715



  pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;




×







3716













UNCOV

3717



  if (asc) {





×








UNCOV

3718



    tRowKeyAssign(&pScanInfo->lastProcKey, &pScanInfo->sttRange.ekey);




×







3719



  } else {










3720



    tRowKeyAssign(&pScanInfo->lastProcKey, &pScanInfo->sttRange.skey);




×







3721



  }










3722













UNCOV

3723



  pScanInfo->sttBlockReturned = true;




×








UNCOV

3724



  pSttBlockReader->mergeTree.pIter = NULL;




×







3725













UNCOV

3726



  tsdbDebug("%p uid:%" PRId64 " return clean stt block as one, brange:%" PRId64 "-%" PRId64 " rows:%" PRId64 " %s",





×







3727



            pReader, pResBlock->info.id.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,










3728



            pResBlock->info.rows, pReader->idStr);










3729













UNCOV

3730



_end:




×








UNCOV

3731



  if (code != TSDB_CODE_SUCCESS) {





×







3732



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





×







3733



  }











UNCOV

3734



  return code;




×







3735



}










3736













UNCOV

3737



static int32_t buildCleanBlockFromDataFiles(STsdbReader* pReader, STableBlockScanInfo* pScanInfo,




×







3738



                                            SFileDataBlockInfo* pBlockInfo, int32_t blockIndex) {











UNCOV

3739



  int32_t         code = TSDB_CODE_SUCCESS;




×








UNCOV

3740



  int32_t         lino = 0;




×








UNCOV

3741



  SReaderStatus*  pStatus = NULL;




×








UNCOV

3742



  SDataBlockInfo* pInfo = NULL;




×








UNCOV

3743



  bool            asc = false;




×







3744













UNCOV

3745



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3746



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

3747



  TSDB_CHECK_NULL(pBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3748












3749



  // whole data block is required, return it directly











UNCOV

3750



  pStatus = &pReader->status;




×








UNCOV

3751



  pInfo = &pReader->resBlockInfo.pResBlock->info;




×








UNCOV

3752



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×







3753













UNCOV

3754



  pInfo->rows = pBlockInfo->numRow;




×








UNCOV

3755



  pInfo->id.uid = pScanInfo->uid;




×








UNCOV

3756



  pInfo->dataLoad = 0;




×








UNCOV

3757



  pInfo->version = pReader->info.verRange.maxVer;




×








UNCOV

3758



  pInfo->window = (STimeWindow){.skey = pBlockInfo->firstKey, .ekey = pBlockInfo->lastKey};




×







3759













UNCOV

3760



  if (pReader->suppInfo.numOfPks > 0) {





×








UNCOV

3761



    if (IS_NUMERIC_TYPE(pReader->suppInfo.pk.type)) {





×








UNCOV

3762



      pInfo->pks[0].val = pBlockInfo->firstPk.val;




×








UNCOV

3763



      pInfo->pks[1].val = pBlockInfo->lastPk.val;




×







3764



    } else {










3765



      (void)memcpy(pInfo->pks[0].pData, varDataVal(pBlockInfo->firstPk.pData), varDataLen(pBlockInfo->firstPk.pData));




×







3766



      (void)memcpy(pInfo->pks[1].pData, varDataVal(pBlockInfo->lastPk.pData), varDataLen(pBlockInfo->lastPk.pData));




×







3767












3768



      pInfo->pks[0].nData = varDataLen(pBlockInfo->firstPk.pData);




×







3769



      pInfo->pks[1].nData = varDataLen(pBlockInfo->lastPk.pData);




×







3770



    }










3771



  }










3772












3773



  // update the last key for the corresponding table











UNCOV

3774



  setComposedBlockFlag(pReader, false);




×








UNCOV

3775



  setBlockAllDumped(&pStatus->fBlockDumpInfo, pBlockInfo->lastKey, pReader->info.order);




×








UNCOV

3776



  code = updateLastKeyInfo(&pScanInfo->lastProcKey, pBlockInfo, pInfo, pReader->suppInfo.numOfPks, asc);




×








UNCOV

3777



  TSDB_CHECK_CODE(code, lino, _end);





×







3778













UNCOV

3779



  tsdbDebug("%p uid:%" PRIu64





×







3780



            " clean file block retrieved from file, global index:%d, "










3781



            "table index:%d, rows:%d, brange:%" PRId64 "-%" PRId64 ", %s",










3782



            pReader, pScanInfo->uid, blockIndex, pBlockInfo->tbBlockIdx, pBlockInfo->numRow, pBlockInfo->firstKey,










3783



            pBlockInfo->lastKey, pReader->idStr);










3784













UNCOV

3785



_end:




×








UNCOV

3786



  if (code != TSDB_CODE_SUCCESS) {





×







3787



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





×







3788



  }











UNCOV

3789



  return code;




×







3790



}










3791













UNCOV

3792



static int32_t doLoadSttBlockSequentially(STsdbReader* pReader) {




×








UNCOV

3793



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

3794



  int32_t              lino = 0;




×








UNCOV

3795



  SReaderStatus*       pStatus = NULL;




×








UNCOV

3796



  SSttBlockReader*     pSttBlockReader = NULL;




×








UNCOV

3797



  STableUidList*       pUidList = NULL;




×








UNCOV

3798



  SSDataBlock*         pResBlock = NULL;




×








UNCOV

3799



  STableBlockScanInfo* pScanInfo = NULL;




×







3800













UNCOV

3801



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3802













UNCOV

3803



  pStatus = &pReader->status;




×








UNCOV

3804



  pSttBlockReader = pStatus->fileIter.pSttBlockReader;




×








UNCOV

3805



  pUidList = &pStatus->uidList;




×







3806













UNCOV

3807



  if (tSimpleHashGetSize(pStatus->pTableMap) == 0) {





×







3808



    goto _end;




×







3809



  }










3810













UNCOV

3811



  pResBlock = pReader->resBlockInfo.pResBlock;




×







3812













UNCOV

3813



  while (1) {




×








UNCOV

3814



    if (pReader->code != TSDB_CODE_SUCCESS) {





×







3815



      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);





×







3816



      code = pReader->code;




×







3817



      TSDB_CHECK_CODE(code, lino, _end);





×







3818



    }










3819












3820



    // load the last data block of current table











UNCOV

3821



    if (pStatus->pTableIter == NULL) {





×







3822



      tsdbError("table Iter is null, invalid pScanInfo, try next table %s", pReader->idStr);





×







3823



      bool hasNexTable = moveToNextTable(pUidList, pStatus);




×







3824



      if (!hasNexTable) {





×







3825



        break;




×







3826



      }










3827












3828



      continue;




×







3829



    } else {











UNCOV

3830



      pScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;




×







3831



    }










3832













UNCOV

3833



    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pScanInfo->uid, sizeof(pScanInfo->uid))) {





×







3834



      // reset the index in last block when handing a new file











UNCOV

3835



      bool hasNexTable = moveToNextTable(pUidList, pStatus);




×








UNCOV

3836



      if (!hasNexTable) {





×








UNCOV

3837



        break;




×







3838



      }










3839













UNCOV

3840



      continue;




×







3841



    }










3842













UNCOV

3843



    initSttBlockReader(pSttBlockReader, pScanInfo, pReader);




×








UNCOV

3844



    code = pReader->code;




×








UNCOV

3845



    TSDB_CHECK_CODE(code, lino, _end);





×







3846













UNCOV

3847



    if (!hasDataInSttBlock(pScanInfo)) {





×








UNCOV

3848



      bool hasNexTable = moveToNextTable(pUidList, pStatus);




×








UNCOV

3849



      if (!hasNexTable) {





×








UNCOV

3850



        break;




×







3851



      }










3852













UNCOV

3853



      continue;




×







3854



    }










3855












3856



    // if only require the total rows, no need to load data from stt file if it is clean stt blocks











UNCOV

3857



    if (pReader->info.execMode == READER_EXEC_ROWS && pScanInfo->cleanSttBlocks) {





×








UNCOV

3858



      code = buildCleanBlockFromSttFiles(pReader, pScanInfo);




×








UNCOV

3859



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3860



      break;




×







3861



    }










3862













UNCOV

3863



    int64_t st = taosGetTimestampUs();




×







3864



    while (1) {










3865



      // no data in stt block and block, no need to proceed.











UNCOV

3866



      if (!hasDataInSttBlock(pScanInfo)) {





×








UNCOV

3867



        break;




×







3868



      }










3869













UNCOV

3870



      code = buildComposedDataBlockImpl(pReader, pScanInfo, &pReader->status.fileBlockData, pSttBlockReader);




×








UNCOV

3871



      TSDB_CHECK_CODE(code, lino, _end);





×







3872













UNCOV

3873



      if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {





×








UNCOV

3874



        break;




×







3875



      }










3876



    }










3877













UNCOV

3878



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




×








UNCOV

3879



    updateComposedBlockInfo(pReader, el, pScanInfo);




×







3880













UNCOV

3881



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





×








UNCOV

3882



      tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64





×







3883



                ", elapsed time:%.2f ms %s",










3884



                pReader, pResBlock->info.id.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,










3885



                pResBlock->info.rows, el, pReader->idStr);











UNCOV

3886



      break;




×







3887



    }










3888












3889



    // current table is exhausted, let's try next table










3890



    bool hasNexTable = moveToNextTable(pUidList, pStatus);




×







3891



    if (!hasNexTable) {





×







3892



      break;




×







3893



    }










3894



  }










3895













UNCOV

3896



_end:




×








UNCOV

3897



  if (code != TSDB_CODE_SUCCESS) {





×







3898



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





×







3899



  }











UNCOV

3900



  return code;




×







3901



}










3902












3903



// current active data block not overlap with the stt-files/stt-blocks











UNCOV

3904



static bool notOverlapWithFiles(SFileDataBlockInfo* pBlockInfo, STableBlockScanInfo* pScanInfo, bool asc) {




×








UNCOV

3905



  if ((!hasDataInSttBlock(pScanInfo)) || (pScanInfo->cleanSttBlocks == true)) {





×








UNCOV

3906



    return true;




×







3907



  } else {











UNCOV

3908



    int64_t keyInStt = pScanInfo->sttKeyInfo.nextProcKey.ts;




×








UNCOV

3909



    return (asc && pBlockInfo->lastKey < keyInStt) || (!asc && pBlockInfo->firstKey > keyInStt);





×







3910



  }










3911



}










3912













UNCOV

3913



static int32_t doBuildDataBlock(STsdbReader* pReader) {




×








UNCOV

3914



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

3915



  int32_t              lino = 0;




×








UNCOV

3916



  SReaderStatus*       pStatus = NULL;




×








UNCOV

3917



  SDataBlockIter*      pBlockIter = NULL;




×








UNCOV

3918



  STableBlockScanInfo* pScanInfo = NULL;




×








UNCOV

3919



  SFileDataBlockInfo*  pBlockInfo = NULL;




×








UNCOV

3920



  SSttBlockReader*     pSttBlockReader = NULL;




×







3921



  TSDBKEY              keyInBuf;











UNCOV

3922



  bool                 asc = false;




×







3923













UNCOV

3924



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







3925













UNCOV

3926



  pStatus = &pReader->status;




×








UNCOV

3927



  pBlockIter = &pStatus->blockIter;




×








UNCOV

3928



  pSttBlockReader = pReader->status.fileIter.pSttBlockReader;




×








UNCOV

3929



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×







3930













UNCOV

3931



  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

3932



  TSDB_CHECK_CODE(code, lino, _end);





×







3933













UNCOV

3934



  if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {





×







3935



    setBlockAllDumped(&pStatus->fBlockDumpInfo, pBlockInfo->lastKey, pReader->info.order);




×








UNCOV

3936



    goto _end;




×







3937



  }










3938













UNCOV

3939



  code = pReader->code;




×








UNCOV

3940



  TSDB_CHECK_CODE(code, lino, _end);





×







3941













UNCOV

3942



  code = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, &pScanInfo, pReader->idStr);




×








UNCOV

3943



  TSDB_CHECK_CODE(code, lino, _end);





×







3944













UNCOV

3945



  if (pScanInfo->sttKeyInfo.status == STT_FILE_READER_UNINIT) {





×








UNCOV

3946



    initSttBlockReader(pSttBlockReader, pScanInfo, pReader);




×








UNCOV

3947



    code = pReader->code;




×








UNCOV

3948



    TSDB_CHECK_CODE(code, lino, _end);





×







3949



  }










3950













UNCOV

3951



  code = getCurrentKeyInBuf(pScanInfo, pReader, &keyInBuf);




×








UNCOV

3952



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3953



  bool load = false;




×








UNCOV

3954



  code = fileBlockShouldLoad(pReader, pBlockInfo, pScanInfo, keyInBuf, &load);




×








UNCOV

3955



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3956



  if (load) {





×








UNCOV

3957



    code = doLoadFileBlockData(pReader, pBlockIter, &pStatus->fileBlockData, pScanInfo->uid);




×








UNCOV

3958



    TSDB_CHECK_CODE(code, lino, _end);





×







3959












3960



    // build composed data block











UNCOV

3961



    code = buildComposedDataBlock(pReader);




×








UNCOV

3962



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3963



  } else if (bufferDataInFileBlockGap(keyInBuf, pBlockInfo, pScanInfo, pReader->info.order)) {





×







3964



    // data in memory that are earlier than current file block and stt blocks










3965



    // rows in buffer should be less than the file block in asc, greater than file block in desc











UNCOV

3966



    int64_t endKey = getBoarderKeyInFiles(pBlockInfo, pScanInfo, pReader->info.order);




×








UNCOV

3967



    code = buildDataBlockFromBuf(pReader, pScanInfo, endKey);




×








UNCOV

3968



    TSDB_CHECK_CODE(code, lino, _end);





×







3969



  } else {











UNCOV

3970



    if (notOverlapWithFiles(pBlockInfo, pScanInfo, asc)) {





×








UNCOV

3971



      int64_t keyInStt = pScanInfo->sttKeyInfo.nextProcKey.ts;




×







3972













UNCOV

3973



      if ((!hasDataInSttBlock(pScanInfo)) || (asc && pBlockInfo->lastKey < keyInStt) ||





×







3974



          (!asc && pBlockInfo->firstKey > keyInStt)) {





×







3975



        // the stt blocks may located in the gap of different data block, but the whole sttRange may overlap with the










3976



        // data block, so the overlap check is invalid actually.











UNCOV

3977



        code = buildCleanBlockFromDataFiles(pReader, pScanInfo, pBlockInfo, pBlockIter->index);




×








UNCOV

3978



        TSDB_CHECK_CODE(code, lino, _end);





×







3979



      } else {  // clean stt block










3980



        TSDB_CHECK_CONDITION((pReader->info.execMode == READER_EXEC_ROWS) && (pSttBlockReader->mergeTree.pIter == NULL),





×







3981



                             code, lino, _end, TSDB_CODE_INTERNAL_ERROR);










3982



        code = buildCleanBlockFromSttFiles(pReader, pScanInfo);




×







3983



        TSDB_CHECK_CODE(code, lino, _end);





×







3984



      }










3985



    } else {











UNCOV

3986



      SBlockData* pBData = &pReader->status.fileBlockData;




×








UNCOV

3987



      tBlockDataReset(pBData);




×







3988













UNCOV

3989



      SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;




×







3990













UNCOV

3991



      tsdbDebug("load data in stt block firstly %s", pReader->idStr);





×








UNCOV

3992



      int64_t st = taosGetTimestampUs();




×







3993












3994



      // let's load data from stt files, make sure clear the cleanStt block flag before load the data from stt files











UNCOV

3995



      initSttBlockReader(pSttBlockReader, pScanInfo, pReader);




×








UNCOV

3996



      code = pReader->code;




×








UNCOV

3997



      TSDB_CHECK_CODE(code, lino, _end);





×







3998












3999



      // no data in stt block, no need to proceed.











UNCOV

4000



      while (hasDataInSttBlock(pScanInfo)) {





×








UNCOV

4001



        TSDB_CHECK_CONDITION(pScanInfo->sttKeyInfo.status == STT_FILE_HAS_DATA, code, lino, _end,





×







4002



                             TSDB_CODE_INTERNAL_ERROR);










4003













UNCOV

4004



        code = buildComposedDataBlockImpl(pReader, pScanInfo, &pReader->status.fileBlockData, pSttBlockReader);




×








UNCOV

4005



        TSDB_CHECK_CODE(code, lino, _end);





×







4006













UNCOV

4007



        if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {





×








UNCOV

4008



          break;




×







4009



        }










4010












4011



        // data in stt now overlaps with current active file data block, need to composed with file data block.











UNCOV

4012



        SRowKey* pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);




×








UNCOV

4013



        if ((pSttKey->ts >= pBlockInfo->firstKey && asc) || (pSttKey->ts <= pBlockInfo->lastKey && (!asc))) {





×







4014



          tsdbDebug("%p lastKeyInStt:%" PRId64 ", overlap with file block, brange:%" PRId64 "-%" PRId64 " %s", pReader,





×







4015



                    pSttKey->ts, pBlockInfo->firstKey, pBlockInfo->lastKey, pReader->idStr);










4016



          break;




×







4017



        }










4018



      }










4019













UNCOV

4020



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




×








UNCOV

4021



      updateComposedBlockInfo(pReader, el, pScanInfo);




×







4022













UNCOV

4023



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





×








UNCOV

4024



        tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64





×







4025



                  ", elapsed time:%.2f ms %s",










4026



                  pReader, pResBlock->info.id.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,










4027



                  pResBlock->info.rows, el, pReader->idStr);










4028



      }










4029



    }










4030



  }










4031













UNCOV

4032



  code = pReader->code;




×








UNCOV

4033



  TSDB_CHECK_CODE(code, lino, _end);





×







4034













UNCOV

4035



_end:




×








UNCOV

4036



  if (code != TSDB_CODE_SUCCESS) {





×







4037



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





×







4038



  }











UNCOV

4039



  return code;




×







4040



}










4041













UNCOV

4042



static int32_t buildBlockFromBufferSeqForPreFileset(STsdbReader* pReader, int64_t endKey) {




×








UNCOV

4043



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

4044



  int32_t        lino = 0;




×








UNCOV

4045



  SReaderStatus* pStatus = NULL;




×







4046













UNCOV

4047



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4048













UNCOV

4049



  pStatus = &pReader->status;




×







4050













UNCOV

4051



  tsdbDebug("seq load data blocks from cache that preceeds fileset %d, %s", pReader->status.pCurrentFileset->fid,





×







4052



            pReader->idStr);










4053













UNCOV

4054



  while (1) {




×








UNCOV

4055



    if (pReader->code != TSDB_CODE_SUCCESS) {





×







4056



      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);





×







4057



      code = pReader->code;




×







4058



      TSDB_CHECK_CODE(code, lino, _end);





×







4059



    }










4060













UNCOV

4061



    STableBlockScanInfo** pBlockScanInfo = pStatus->pProcMemTableIter;




×








UNCOV

4062



    if (pReader->pIgnoreTables &&





×








UNCOV

4063



        taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {




×








UNCOV

4064



      bool hasNexTable = moveToNextTableForPreFileSetMem(pStatus);




×








UNCOV

4065



      if (!hasNexTable) {





×







4066



        break;




×







4067



      }











UNCOV

4068



      continue;




×







4069



    }










4070













UNCOV

4071



    code = initMemDataIterator(*pBlockScanInfo, pReader);




×








UNCOV

4072



    TSDB_CHECK_CODE(code, lino, _end);





×







4073













UNCOV

4074



    code = initDelSkylineIterator(*pBlockScanInfo, pReader->info.order, &pReader->cost);




×








UNCOV

4075



    TSDB_CHECK_CODE(code, lino, _end);





×







4076













UNCOV

4077



    code = buildDataBlockFromBuf(pReader, *pBlockScanInfo, endKey);




×








UNCOV

4078



    TSDB_CHECK_CODE(code, lino, _end);





×







4079













UNCOV

4080



    if (pReader->resBlockInfo.pResBlock->info.rows > 0) {





×








UNCOV

4081



      break;




×







4082



    }










4083












4084



    // current table is exhausted, let's try next table











UNCOV

4085



    bool hasNexTable = moveToNextTableForPreFileSetMem(pStatus);




×








UNCOV

4086



    if (!hasNexTable) {





×








UNCOV

4087



      break;




×







4088



    }










4089



  }










4090













UNCOV

4091



_end:




×








UNCOV

4092



  if (code != TSDB_CODE_SUCCESS) {





×







4093



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





×







4094



  }











UNCOV

4095



  return code;




×







4096



}










4097













UNCOV

4098



static int32_t buildBlockFromBufferSequentially(STsdbReader* pReader, int64_t endKey) {




×








UNCOV

4099



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

4100



  int32_t        lino = 0;




×








UNCOV

4101



  SReaderStatus* pStatus = NULL;




×








UNCOV

4102



  STableUidList* pUidList = NULL;




×







4103













UNCOV

4104



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4105













UNCOV

4106



  pStatus = &pReader->status;




×








UNCOV

4107



  pUidList = &pStatus->uidList;




×







4108













UNCOV

4109



  tsdbDebug("seq load data blocks from cache, %s", pReader->idStr);





×







4110













UNCOV

4111



  while (1) {




×








UNCOV

4112



    if (pReader->code != TSDB_CODE_SUCCESS) {





×







4113



      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);





×







4114



      code = pReader->code;




×







4115



      TSDB_CHECK_CODE(code, lino, _end);





×







4116



    }










4117













UNCOV

4118



    STableBlockScanInfo** pBlockScanInfo = pStatus->pTableIter;




×








UNCOV

4119



    if (pBlockScanInfo == NULL || *pBlockScanInfo == NULL) {





×







4120



      break;










4121



    }










4122













UNCOV

4123



    if (pReader->pIgnoreTables &&





×








UNCOV

4124



        taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {




×








UNCOV

4125



      bool hasNexTable = moveToNextTable(pUidList, pStatus);




×








UNCOV

4126



      if (!hasNexTable) {





×








UNCOV

4127



        break;




×







4128



      }











UNCOV

4129



      continue;




×







4130



    }










4131













UNCOV

4132



    code = initMemDataIterator(*pBlockScanInfo, pReader);




×








UNCOV

4133



    TSDB_CHECK_CODE(code, lino, _end);





×







4134













UNCOV

4135



    code = initDelSkylineIterator(*pBlockScanInfo, pReader->info.order, &pReader->cost);




×








UNCOV

4136



    TSDB_CHECK_CODE(code, lino, _end);





×







4137













UNCOV

4138



    code = buildDataBlockFromBuf(pReader, *pBlockScanInfo, endKey);




×








UNCOV

4139



    TSDB_CHECK_CODE(code, lino, _end);





×







4140













UNCOV

4141



    if (pReader->resBlockInfo.pResBlock->info.rows > 0) {





×








UNCOV

4142



      break;




×







4143



    }










4144












4145



    // current table is exhausted, let's try next table











UNCOV

4146



    bool hasNexTable = moveToNextTable(pUidList, pStatus);




×








UNCOV

4147



    if (!hasNexTable) {





×








UNCOV

4148



      break;




×







4149



    }










4150



  }










4151












4152



_end:




×








UNCOV

4153



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

4154



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





×







4155



  }











UNCOV

4156



  return code;




×







4157



}










4158












4159



// set the correct start position in case of the first/last file block, according to the query time window











UNCOV

4160



static int32_t initBlockDumpInfo(STsdbReader* pReader, SDataBlockIter* pBlockIter) {




×








UNCOV

4161



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

4162



  int32_t             lino = 0;




×








UNCOV

4163



  SFileDataBlockInfo* pBlockInfo = NULL;




×








UNCOV

4164



  SReaderStatus*      pStatus = NULL;




×








UNCOV

4165



  SFileBlockDumpInfo* pDumpInfo = NULL;




×







4166













UNCOV

4167



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4168













UNCOV

4169



  pStatus = &pReader->status;




×








UNCOV

4170



  pDumpInfo = &pStatus->fBlockDumpInfo;




×







4171













UNCOV

4172



  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

4173



  if (code == TSDB_CODE_SUCCESS) {





×








UNCOV

4174



    pDumpInfo->totalRows = pBlockInfo->numRow;




×








UNCOV

4175



    pDumpInfo->rowIndex = ASCENDING_TRAVERSE(pReader->info.order) ? 0 : pBlockInfo->numRow - 1;





×







4176



  } else {











UNCOV

4177



    pDumpInfo->totalRows = 0;




×








UNCOV

4178



    pDumpInfo->rowIndex = 0;




×








UNCOV

4179



    code = TSDB_CODE_SUCCESS;




×







4180



  }










4181













UNCOV

4182



  pDumpInfo->allDumped = false;




×







4183













UNCOV

4184



_end:




×








UNCOV

4185



  if (code != TSDB_CODE_SUCCESS) {





×







4186



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





×







4187



  }











UNCOV

4188



  return code;




×







4189



}










4190













UNCOV

4191



static int32_t initForFirstBlockInFile(STsdbReader* pReader, SDataBlockIter* pBlockIter) {




×








UNCOV

4192



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

4193



  int32_t      lino = 0;




×








UNCOV

4194



  SBlockNumber num = {0};




×








UNCOV

4195



  SArray*      pTableList = NULL;




×







4196













UNCOV

4197



  pTableList = taosArrayInit(40, POINTER_BYTES);




×








UNCOV

4198



  TSDB_CHECK_NULL(pTableList, code, lino, _end, terrno);





×







4199













UNCOV

4200



  code = moveToNextFile(pReader, &num, pTableList);




×








UNCOV

4201



  TSDB_CHECK_CODE(code, lino, _end);





×







4202












4203



  // all data files are consumed, try data in buffer











UNCOV

4204



  if (num.numOfBlocks + num.numOfSttFiles == 0) {





×








UNCOV

4205



    pReader->status.loadFromFile = false;




×








UNCOV

4206



    goto _end;




×







4207



  }










4208












4209



  // initialize the block iterator for a new fileset











UNCOV

4210



  if (num.numOfBlocks > 0) {





×








UNCOV

4211



    code = initBlockIterator(pReader, pBlockIter, num.numOfBlocks, pTableList);




×








UNCOV

4212



    TSDB_CHECK_CODE(code, lino, _end);





×







4213



  } else {  // no block data, only last block exists











UNCOV

4214



    tBlockDataReset(&pReader->status.fileBlockData);




×








UNCOV

4215



    code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), pReader->idStr);




×








UNCOV

4216



    TSDB_CHECK_CODE(code, lino, _end);





×







4217













UNCOV

4218



    code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

4219



    TSDB_CHECK_CODE(code, lino, _end);





×







4220



  }










4221













UNCOV

4222



  code = initBlockDumpInfo(pReader, pBlockIter);




×








UNCOV

4223



  TSDB_CHECK_CODE(code, lino, _end);





×







4224













UNCOV

4225



_end:




×








UNCOV

4226



  if (code != TSDB_CODE_SUCCESS) {





×







4227



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





×







4228



  }











UNCOV

4229



  if (pTableList) {





×








UNCOV

4230



    taosArrayDestroy(pTableList);




×







4231



  }











UNCOV

4232



  return code;




×







4233



}










4234













UNCOV

4235



static bool fileBlockPartiallyRead(SFileBlockDumpInfo* pDumpInfo, bool asc) {




×








UNCOV

4236



  return (!pDumpInfo->allDumped) &&





×








UNCOV

4237



         ((pDumpInfo->rowIndex > 0 && asc) || (pDumpInfo->rowIndex < (pDumpInfo->totalRows - 1) && (!asc)));





×







4238



}










4239












4240



typedef enum {










4241



  TSDB_READ_RETURN = 0x1,










4242



  TSDB_READ_CONTINUE = 0x2,










4243



} ERetrieveType;










4244













UNCOV

4245



static int32_t doReadDataFromSttFiles(STsdbReader* pReader, ERetrieveType* pReturnType) {




×








UNCOV

4246



  int32_t         code = TSDB_CODE_SUCCESS;




×








UNCOV

4247



  int32_t         lino = 0;




×








UNCOV

4248



  SSDataBlock*    pResBlock = NULL;




×








UNCOV

4249



  SDataBlockIter* pBlockIter = NULL;




×







4250













UNCOV

4251



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4252



  TSDB_CHECK_NULL(pReturnType, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4253













UNCOV

4254



  pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

4255



  pBlockIter = &pReader->status.blockIter;




×







4256













UNCOV

4257



  *pReturnType = TSDB_READ_RETURN;




×







4258













UNCOV

4259



  tsdbDebug("seq load data blocks from stt files %s", pReader->idStr);





×







4260












4261



  while (1) {











UNCOV

4262



    code = doLoadSttBlockSequentially(pReader);




×








UNCOV

4263



    TSDB_CHECK_CODE(code, lino, _end);





×







4264













UNCOV

4265



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





×








UNCOV

4266



      goto _end;




×







4267



    }










4268












4269



    // all data blocks are checked in this stt file, now let's try the next file set











UNCOV

4270



    TSDB_CHECK_CONDITION(pReader->status.pTableIter == NULL, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);





×







4271













UNCOV

4272



    code = initForFirstBlockInFile(pReader, pBlockIter);




×








UNCOV

4273



    TSDB_CHECK_CODE(code, lino, _end);





×







4274












4275



    // all the data files are completely checked











UNCOV

4276



    if (pReader->status.loadFromFile == false) {





×








UNCOV

4277



      goto _end;




×







4278



    }










4279













UNCOV

4280



    if (pReader->status.bProcMemPreFileset) {





×








UNCOV

4281



      code = buildFromPreFilesetBuffer(pReader);




×








UNCOV

4282



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4283



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





×








UNCOV

4284



        pReader->status.processingMemPreFileSet = true;




×








UNCOV

4285



        goto _end;




×







4286



      }










4287



    }










4288













UNCOV

4289



    if (pBlockIter->numOfBlocks > 0) {  // there are data blocks existed.





×








UNCOV

4290



      *pReturnType = TSDB_READ_CONTINUE;




×








UNCOV

4291



      goto _end;




×







4292



    } else {  // all blocks in data file are checked, let's check the data in stt-files











UNCOV

4293



      code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

4294



      TSDB_CHECK_CODE(code, lino, _end);





×







4295



    }










4296



  }










4297













UNCOV

4298



_end:




×








UNCOV

4299



  if (code != TSDB_CODE_SUCCESS) {





×







4300



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





×







4301



  }











UNCOV

4302



  return code;




×







4303



}










4304













UNCOV

4305



static int32_t buildBlockFromFiles(STsdbReader* pReader) {




×








UNCOV

4306



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

4307



  int32_t             lino = 0;




×








UNCOV

4308



  SDataBlockIter*     pBlockIter = NULL;




×








UNCOV

4309



  SSDataBlock*        pResBlock = NULL;




×








UNCOV

4310



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

4311



  SBlockData*         pBlockData = NULL;




×








UNCOV

4312



  const char*         id = NULL;




×








UNCOV

4313



  bool                asc = false;




×







4314













UNCOV

4315



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4316













UNCOV

4317



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×







4318













UNCOV

4319



  pBlockIter = &pReader->status.blockIter;




×








UNCOV

4320



  pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

4321



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

4322



  pBlockData = &pReader->status.fileBlockData;




×








UNCOV

4323



  id = pReader->idStr;




×







4324













UNCOV

4325



  if (pBlockIter->numOfBlocks == 0) {





×







4326



    // let's try to extract data from stt files.











UNCOV

4327



    ERetrieveType type = 0;




×








UNCOV

4328



    code = doReadDataFromSttFiles(pReader, &type);




×








UNCOV

4329



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4330



    if (type == TSDB_READ_RETURN) {





×








UNCOV

4331



      goto _end;




×







4332



    }










4333












4334



    code = doBuildDataBlock(pReader);




×








UNCOV

4335



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4336



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





×








UNCOV

4337



      goto _end;




×







4338



    }










4339



  }










4340












4341



  while (1) {











UNCOV

4342



    if (fileBlockPartiallyRead(pDumpInfo, asc)) {  // file data block is partially loaded





×








UNCOV

4343



      code = buildComposedDataBlock(pReader);




×








UNCOV

4344



      TSDB_CHECK_CODE(code, lino, _end);





×







4345



    } else {










4346



      // current block are exhausted, try the next file block











UNCOV

4347



      if (pDumpInfo->allDumped) {





×







4348



        // try next data block in current file











UNCOV

4349



        bool hasNext = blockIteratorNext(&pReader->status.blockIter);




×








UNCOV

4350



        if (hasNext) {  // check for the next block in the block accessed order list





×








UNCOV

4351



          code = initBlockDumpInfo(pReader, pBlockIter);




×








UNCOV

4352



          TSDB_CHECK_CODE(code, lino, _end);





×







4353



        } else {










4354



          // all data blocks in files are checked, let's check the data in last files.










4355



          // data blocks in current file are exhausted, let's try the next file now











UNCOV

4356



          if (pBlockData->uid != 0) {





×








UNCOV

4357



            tBlockDataClear(pBlockData);




×







4358



          }










4359













UNCOV

4360



          tBlockDataReset(pBlockData);




×








UNCOV

4361



          code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), id);




×








UNCOV

4362



          TSDB_CHECK_CODE(code, lino, _end);





×







4363













UNCOV

4364



          code = resetTableListIndex(&pReader->status, id);




×








UNCOV

4365



          TSDB_CHECK_CODE(code, lino, _end);





×







4366













UNCOV

4367



          ERetrieveType type = 0;




×








UNCOV

4368



          code = doReadDataFromSttFiles(pReader, &type);




×








UNCOV

4369



          TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4370



          if (type == TSDB_READ_RETURN) {





×








UNCOV

4371



            break;




×







4372



          }










4373



        }










4374



      }










4375













UNCOV

4376



      code = doBuildDataBlock(pReader);




×








UNCOV

4377



      TSDB_CHECK_CODE(code, lino, _end);





×







4378



    }










4379













UNCOV

4380



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





×








UNCOV

4381



      break;




×







4382



    }










4383



  }










4384













UNCOV

4385



_end:




×








UNCOV

4386



  if (code != TSDB_CODE_SUCCESS) {





×







4387



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





×







4388



  }











UNCOV

4389



  return code;




×







4390



}










4391













UNCOV

4392



static void getTsdbByRetentions(SVnode* pVnode, SQueryTableDataCond* pCond, SRetention* retentions, const char* idStr,




×







4393



                                int8_t* pLevel, STsdb** pTsdb) {











UNCOV

4394



  if (pTsdb == NULL) {





×







4395



    return;




×







4396



  }










4397













UNCOV

4398



  *pTsdb = NULL;




×








UNCOV

4399



  if (VND_IS_RSMA(pVnode) && !pCond->skipRollup) {





×








UNCOV

4400



    int8_t  level = 0;




×








UNCOV

4401



    int8_t  precision = pVnode->config.tsdbCfg.precision;




×








UNCOV

4402



    int64_t now = taosGetTimestamp(precision);





×








UNCOV

4403



    int64_t offset = tsQueryRsmaTolerance * ((precision == TSDB_TIME_PRECISION_MILLI)   ? 1L




×








UNCOV

4404



                                             : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000L





×







4405



                                                                                        : 1000000L);





×







4406













UNCOV

4407



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





×








UNCOV

4408



      SRetention* pRetention = retentions + level;




×








UNCOV

4409



      if (pRetention->keep <= 0) {





×







4410



        if (level > 0) {





×







4411



          --level;




×







4412



        }










4413



        break;




×







4414



      }











UNCOV

4415



      if ((now - pRetention->keep) <= (pCond->twindows.skey + offset)) {





×








UNCOV

4416



        break;




×







4417



      }











UNCOV

4418



      ++level;




×







4419



    }










4420













UNCOV

4421



    const char* str = (idStr != NULL) ? idStr : "";





×







4422













UNCOV

4423



    if (level == TSDB_RETENTION_L0) {





×








UNCOV

4424



      *pLevel = TSDB_RETENTION_L0;




×








UNCOV

4425



      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L0, str);





×








UNCOV

4426



      *pTsdb = VND_RSMA0(pVnode);




×








UNCOV

4427



      return;




×








UNCOV

4428



    } else if (level == TSDB_RETENTION_L1) {





×








UNCOV

4429



      *pLevel = TSDB_RETENTION_L1;




×








UNCOV

4430



      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L1, str);





×








UNCOV

4431



      *pTsdb = VND_RSMA1(pVnode);




×








UNCOV

4432



      return;




×







4433



    } else {











UNCOV

4434



      *pLevel = TSDB_RETENTION_L2;




×








UNCOV

4435



      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L2, str);





×








UNCOV

4436



      *pTsdb = VND_RSMA2(pVnode);




×








UNCOV

4437



      return;




×







4438



    }










4439



  }










4440













UNCOV

4441



  *pTsdb = VND_TSDB(pVnode);




×







4442



}










4443













UNCOV

4444



SVersionRange getQueryVerRange(SVnode* pVnode, SQueryTableDataCond* pCond, int8_t level) {




×








UNCOV

4445



  int64_t startVer = (pCond->startVersion == -1) ? 0 : pCond->startVersion;





×







4446













UNCOV

4447



  int64_t endVer = 0;




×








UNCOV

4448



  if (pCond->endVersion == -1) {





×







4449



    // user not specified end version, set current maximum version of vnode as the endVersion











UNCOV

4450



    endVer = pVnode->state.applied;




×







4451



  } else {











UNCOV

4452



    endVer = (pCond->endVersion > pVnode->state.applied) ? pVnode->state.applied : pCond->endVersion;




×







4453



  }










4454













UNCOV

4455



  return (SVersionRange){.minVer = startVer, .maxVer = endVer};




×







4456



}










4457













UNCOV

4458



static int32_t reverseSearchStartPos(const SArray* pDelList, int32_t index, int64_t key, bool asc, int32_t* start) {




×








UNCOV

4459



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

4460



  int32_t lino = 0;




×








UNCOV

4461



  size_t  num = 0;




×







4462













UNCOV

4463



  num = taosArrayGetSize(pDelList);




×








UNCOV

4464



  *start = index;




×







4465













UNCOV

4466



  if (asc) {





×








UNCOV

4467



    if (*start >= num - 1) {





×








UNCOV

4468



      *start = num - 1;




×







4469



    }










4470













UNCOV

4471



    TSDBKEY* p = taosArrayGet(pDelList, *start);




×








UNCOV

4472



    TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4473













UNCOV

4474



    while (p->ts >= key && *start > 0) {





×








UNCOV

4475



      *start -= 1;




×







4476



    }










4477



  } else {











UNCOV

4478



    if (index <= 0) {





×







4479



      *start = 0;




×







4480



    }










4481













UNCOV

4482



    TSDBKEY* p = taosArrayGet(pDelList, *start);




×








UNCOV

4483



    TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4484













UNCOV

4485



    while (p->ts <= key && *start < num - 1) {





×








UNCOV

4486



      *start += 1;




×







4487



    }










4488



  }










4489













UNCOV

4490



_end:




×








UNCOV

4491



  if (code != TSDB_CODE_SUCCESS) {





×







4492



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





×







4493



  }











UNCOV

4494



  return code;




×







4495



}










4496













UNCOV

4497



int32_t hasBeenDropped(const SArray* pDelList, int32_t* index, int64_t key, int64_t ver, int32_t order,




×







4498



                       SVersionRange* pVerRange, bool hasPk, bool* dropped) {











UNCOV

4499



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

4500



  int32_t lino = 0;




×








UNCOV

4501



  size_t  num = 0;




×








UNCOV

4502



  int32_t step = 0;




×








UNCOV

4503



  bool    asc = false;




×







4504













UNCOV

4505



  *dropped = false;




×







4506













UNCOV

4507



  if (pDelList == NULL || (TARRAY_SIZE(pDelList) == 0)) {





×







4508



    goto _end;




×







4509



  }










4510













UNCOV

4511



  num = taosArrayGetSize(pDelList);




×








UNCOV

4512



  asc = ASCENDING_TRAVERSE(order);




×








UNCOV

4513



  step = asc ? 1 : -1;





×







4514













UNCOV

4515



  if (hasPk) {  // handle the case where duplicated timestamps existed.





×








UNCOV

4516



    code = reverseSearchStartPos(pDelList, *index, key, asc, index);




×








UNCOV

4517



    TSDB_CHECK_CODE(code, lino, _end);





×







4518



  }










4519













UNCOV

4520



  if (asc) {





×








UNCOV

4521



    if (*index >= num - 1) {





×








UNCOV

4522



      TSDBKEY* last = taosArrayGetLast(pDelList);




×








UNCOV

4523



      if (last == NULL) {





×







4524



        goto _end;




×







4525



      }










4526













UNCOV

4527



      if (key > last->ts) {





×








UNCOV

4528



        goto _end;




×







4529



      } else if (key == last->ts) {





×








UNCOV

4530



        TSDBKEY* prev = taosArrayGet(pDelList, num - 2);




×








UNCOV

4531



        if (prev == NULL) {





×







4532



          goto _end;




×







4533



        }










4534













UNCOV

4535



        *dropped = (prev->version >= ver && prev->version <= pVerRange->maxVer && prev->version >= pVerRange->minVer);





×







4536



      }










4537



    } else {











UNCOV

4538



      TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);




×








UNCOV

4539



      TSDBKEY* pNext = taosArrayGet(pDelList, (*index) + 1);




×








UNCOV

4540



      if (pCurrent == NULL || pNext == NULL) {





×







4541



        goto _end;




×







4542



      }










4543













UNCOV

4544



      if (key < pCurrent->ts) {





×








UNCOV

4545



        goto _end;




×







4546



      }










4547













UNCOV

4548



      if (pCurrent->ts <= key && pNext->ts >= key && pCurrent->version >= ver &&





×








UNCOV

4549



          pVerRange->maxVer >= pCurrent->version) {





×








UNCOV

4550



        *dropped = true;




×








UNCOV

4551



        goto _end;




×







4552



      }










4553













UNCOV

4554



      while (pNext->ts <= key && (*index) < num - 1) {





×








UNCOV

4555



        (*index) += 1;




×







4556













UNCOV

4557



        if ((*index) < num - 1) {





×








UNCOV

4558



          pCurrent = taosArrayGet(pDelList, *index);




×








UNCOV

4559



          pNext = taosArrayGet(pDelList, (*index) + 1);




×








UNCOV

4560



          if (pCurrent == NULL || pNext == NULL) {





×







4561



            break;










4562



          }










4563












4564



          // it is not a consecutive deletion range, ignore it











UNCOV

4565



          if (pCurrent->version == 0 && pNext->version > 0) {





×








UNCOV

4566



            continue;




×







4567



          }










4568













UNCOV

4569



          if (pCurrent->ts <= key && pNext->ts >= key && pCurrent->version >= ver &&





×








UNCOV

4570



              pVerRange->maxVer >= pCurrent->version) {





×








UNCOV

4571



            *dropped = true;




×








UNCOV

4572



            break;




×







4573



          }










4574



        }










4575



      }










4576



    }










4577



  } else {











UNCOV

4578



    if (*index <= 0) {





×







4579



      TSDBKEY* pFirst = taosArrayGet(pDelList, 0);




×







4580



      if (pFirst == NULL) {





×







4581



        goto _end;




×







4582



      }










4583












4584



      if (key < pFirst->ts) {





×







4585



        goto _end;




×







4586



      } else if (key == pFirst->ts) {





×







4587



        *dropped = pFirst->version >= ver;




×







4588



      } else {










4589



        tsdbError("unexpected error, key:%" PRId64 ", first:%" PRId64, key, pFirst->ts);





×







4590



      }










4591



    } else {











UNCOV

4592



      TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);




×








UNCOV

4593



      TSDBKEY* pPrev = taosArrayGet(pDelList, (*index) - 1);




×








UNCOV

4594



      if (pCurrent == NULL || pPrev == NULL) {





×







4595



        goto _end;




×







4596



      }










4597













UNCOV

4598



      if (key > pCurrent->ts) {





×








UNCOV

4599



        goto _end;




×







4600



      }










4601













UNCOV

4602



      if (pPrev->ts <= key && pCurrent->ts >= key && pPrev->version >= ver) {





×








UNCOV

4603



        *dropped = true;




×








UNCOV

4604



        goto _end;




×







4605



      }










4606













UNCOV

4607



      while (pPrev->ts >= key && (*index) > 1) {





×








UNCOV

4608



        (*index) += step;




×







4609













UNCOV

4610



        if ((*index) >= 1) {





×








UNCOV

4611



          pCurrent = taosArrayGet(pDelList, *index);




×








UNCOV

4612



          pPrev = taosArrayGet(pDelList, (*index) - 1);




×








UNCOV

4613



          if (pCurrent == NULL || pPrev == NULL) {





×







4614



            break;










4615



          }










4616












4617



          // it is not a consecutive deletion range, ignore it











UNCOV

4618



          if (pCurrent->version > 0 && pPrev->version == 0) {





×








UNCOV

4619



            continue;




×







4620



          }










4621













UNCOV

4622



          if (pPrev->ts <= key && pCurrent->ts >= key && pPrev->version >= ver) {





×








UNCOV

4623



            *dropped = true;




×








UNCOV

4624



            break;




×







4625



          }










4626



        }










4627



      }










4628



    }










4629



  }










4630













UNCOV

4631



_end:




×








UNCOV

4632



  if (code != TSDB_CODE_SUCCESS) {





×







4633



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





×







4634



  }











UNCOV

4635



  return code;




×







4636



}










4637












4638



FORCE_INLINE int32_t getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader, TSDBROW** pRes) {











UNCOV

4639



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

4640



  int32_t  lino = 0;




×








UNCOV

4641



  int32_t  order = 0;




×








UNCOV

4642



  TSDBROW* pRow = NULL;




×







4643



  TSDBKEY  key;










4644













UNCOV

4645



  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4646



  TSDB_CHECK_NULL(pRes, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4647













UNCOV

4648



  *pRes = NULL;




×







4649













UNCOV

4650



  if (!pIter->hasVal) {





×








UNCOV

4651



    goto _end;




×







4652



  }










4653













UNCOV

4654



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4655



  order = pReader->info.order;




×








UNCOV

4656



  pRow = tsdbTbDataIterGet(pIter->iter);





×







4657













UNCOV

4658



  TSDBROW_INIT_KEY(pRow, key);





×








UNCOV

4659



  if (outOfTimeWindow(key.ts, &pReader->info.window)) {





×







4660



    pIter->hasVal = false;




×







4661



    goto _end;




×







4662



  }










4663












4664



  // it is a valid data version











UNCOV

4665



  if (key.version <= pReader->info.verRange.maxVer && key.version >= pReader->info.verRange.minVer) {





×








UNCOV

4666



    if (pDelList == NULL || TARRAY_SIZE(pDelList) == 0) {





×








UNCOV

4667



      *pRes = pRow;




×








UNCOV

4668



      goto _end;




×







4669



    } else {











UNCOV

4670



      bool dropped = false;




×








UNCOV

4671



      code = hasBeenDropped(pDelList, &pIter->index, key.ts, key.version, order, &pReader->info.verRange,




×








UNCOV

4672



                            pReader->suppInfo.numOfPks > 0, &dropped);




×








UNCOV

4673



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4674



      if (!dropped) {





×








UNCOV

4675



        *pRes = pRow;




×








UNCOV

4676



        goto _end;




×







4677



      }










4678



    }










4679



  }










4680












4681



  while (1) {











UNCOV

4682



    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);




×








UNCOV

4683



    if (!pIter->hasVal) {





×








UNCOV

4684



      goto _end;




×







4685



    }










4686













UNCOV

4687



    pRow = tsdbTbDataIterGet(pIter->iter);





×







4688













UNCOV

4689



    TSDBROW_INIT_KEY(pRow, key);





×








UNCOV

4690



    if (outOfTimeWindow(key.ts, &pReader->info.window)) {





×








UNCOV

4691



      pIter->hasVal = false;




×








UNCOV

4692



      goto _end;




×







4693



    }










4694













UNCOV

4695



    if (key.version <= pReader->info.verRange.maxVer && key.version >= pReader->info.verRange.minVer) {





×








UNCOV

4696



      if (pDelList == NULL || TARRAY_SIZE(pDelList) == 0) {





×








UNCOV

4697



        *pRes = pRow;




×








UNCOV

4698



        goto _end;




×







4699



      } else {











UNCOV

4700



        bool dropped = false;




×








UNCOV

4701



        code = hasBeenDropped(pDelList, &pIter->index, key.ts, key.version, order, &pReader->info.verRange,




×








UNCOV

4702



                              pReader->suppInfo.numOfPks > 0, &dropped);




×








UNCOV

4703



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4704



        if (!dropped) {





×








UNCOV

4705



          *pRes = pRow;




×








UNCOV

4706



          goto _end;




×







4707



        }










4708



      }










4709



    }










4710



  }










4711













UNCOV

4712



_end:




×








UNCOV

4713



  if (code != TSDB_CODE_SUCCESS) {





×







4714



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





×







4715



  }











UNCOV

4716



  return code;




×







4717



}










4718













UNCOV

4719



int32_t doMergeRowsInBuf(SIterInfo* pIter, uint64_t uid, SRowKey* pCurKey, SArray* pDelList, STsdbReader* pReader) {




×








UNCOV

4720



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

4721



  int32_t     lino = 0;




×








UNCOV

4722



  SRowMerger* pMerger = NULL;




×







4723













UNCOV

4724



  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4725



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4726













UNCOV

4727



  pMerger = &pReader->status.merger;




×







4728













UNCOV

4729



  while (1) {




×








UNCOV

4730



    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);




×








UNCOV

4731



    if (!pIter->hasVal) {





×








UNCOV

4732



      break;




×







4733



    }










4734












4735



    // data exists but not valid











UNCOV

4736



    TSDBROW* pRow = NULL;





×








UNCOV

4737



    code = getValidMemRow(pIter, pDelList, pReader, &pRow);




×








UNCOV

4738



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4739



    if (pRow == NULL) {





×








UNCOV

4740



      break;




×







4741



    }










4742












4743



    // ts is not identical, quit











UNCOV

4744



    if (TSDBROW_TS(pRow) != pCurKey->ts) {





×








UNCOV

4745



      break;




×







4746



    }










4747













UNCOV

4748



    if (pCurKey->numOfPKs > 0) {





×








UNCOV

4749



      SRowKey nextKey = {0};




×








UNCOV

4750



      tRowGetKeyEx(pRow, &nextKey);





×








UNCOV

4751



      if (pkCompEx(pCurKey, &nextKey) != 0) {





×








UNCOV

4752



        break;




×







4753



      }










4754



    }










4755













UNCOV

4756



    STSchema* pTSchema = NULL;




×








UNCOV

4757



    if (pRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

4758



      pTSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, uid);





×








UNCOV

4759



      TSDB_CHECK_NULL(pTSchema, code, lino, _end, terrno);





×







4760



    }










4761













UNCOV

4762



    code = tsdbRowMergerAdd(pMerger, pRow, pTSchema);




×








UNCOV

4763



    TSDB_CHECK_CODE(code, lino, _end);





×







4764



  }










4765













UNCOV

4766



_end:




×








UNCOV

4767



  if (code != TSDB_CODE_SUCCESS) {





×







4768



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





×







4769



  }











UNCOV

4770



  return code;




×







4771



}










4772













UNCOV

4773



static int32_t doMergeRowsInFileBlockImpl(SBlockData* pBlockData, int32_t* rowIndex, SRowKey* pKey, SRowMerger* pMerger,




×







4774



                                          SVersionRange* pVerRange, int32_t step) {











UNCOV

4775



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

4776



  int32_t lino = 0;




×







4777













UNCOV

4778



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4779



  TSDB_CHECK_NULL(rowIndex, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4780













UNCOV

4781



  while ((*rowIndex) < pBlockData->nRow && (*rowIndex) >= 0) {





×







4782



    SRowKey cur;











UNCOV

4783



    tColRowGetKey(pBlockData, (*rowIndex), &cur);





×








UNCOV

4784



    if (pkCompEx(&cur, pKey) != 0) {





×








UNCOV

4785



      break;




×







4786



    }










4787













UNCOV

4788



    if (pBlockData->aVersion[(*rowIndex)] > pVerRange->maxVer ||





×








UNCOV

4789



        pBlockData->aVersion[(*rowIndex)] < pVerRange->minVer) {





×








UNCOV

4790



      (*rowIndex) += step;




×








UNCOV

4791



      continue;




×







4792



    }










4793













UNCOV

4794



    TSDBROW fRow = tsdbRowFromBlockData(pBlockData, (*rowIndex));




×








UNCOV

4795



    code = tsdbRowMergerAdd(pMerger, &fRow, NULL);




×








UNCOV

4796



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4797



    (*rowIndex) += step;




×







4798



  }










4799













UNCOV

4800



_end:




×








UNCOV

4801



  if (code != TSDB_CODE_SUCCESS) {





×







4802



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





×







4803



  }











UNCOV

4804



  return code;




×







4805



}










4806












4807



typedef enum {










4808



  CHECK_FILEBLOCK_CONT = 0x1,










4809



  CHECK_FILEBLOCK_QUIT = 0x2,










4810



} CHECK_FILEBLOCK_STATE;










4811













UNCOV

4812



static int32_t checkForNeighborFileBlock(STsdbReader* pReader, STableBlockScanInfo* pScanInfo,




×







4813



                                         SFileDataBlockInfo* pFBlock, SRowMerger* pMerger, SRowKey* pKey,










4814



                                         CHECK_FILEBLOCK_STATE* state) {











UNCOV

4815



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

4816



  int32_t             lino = 0;




×








UNCOV

4817



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

4818



  SBlockData*         pBlockData = NULL;




×








UNCOV

4819



  bool                asc = false;




×








UNCOV

4820



  SVersionRange*      pVerRange = NULL;




×








UNCOV

4821



  bool                loadNeighbor = true;




×








UNCOV

4822



  int32_t             step = 0;




×







4823













UNCOV

4824



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4825



  TSDB_CHECK_NULL(state, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4826













UNCOV

4827



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

4828



  pBlockData = &pReader->status.fileBlockData;




×








UNCOV

4829



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

4830



  pVerRange = &pReader->info.verRange;




×








UNCOV

4831



  step = ASCENDING_TRAVERSE(pReader->info.order) ? 1 : -1;





×







4832













UNCOV

4833



  *state = CHECK_FILEBLOCK_QUIT;




×








UNCOV

4834



  code = loadNeighborIfOverlap(pFBlock, pScanInfo, pReader, &loadNeighbor);




×








UNCOV

4835



  TSDB_CHECK_CODE(code, lino, _end);





×







4836













UNCOV

4837



  if (loadNeighbor) {





×








UNCOV

4838



    code = doMergeRowsInFileBlockImpl(pBlockData, &pDumpInfo->rowIndex, pKey, pMerger, pVerRange, step);




×








UNCOV

4839



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4840



    if ((pDumpInfo->rowIndex >= pDumpInfo->totalRows && asc) || (pDumpInfo->rowIndex < 0 && !asc)) {





×







4841



      *state = CHECK_FILEBLOCK_CONT;




×







4842



    }










4843



  }










4844













UNCOV

4845



_end:




×








UNCOV

4846



  if (code != TSDB_CODE_SUCCESS) {





×







4847



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





×







4848



  }











UNCOV

4849



  return code;




×







4850



}










4851













UNCOV

4852



int32_t doMergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pScanInfo, SRowKey* pKey,




×







4853



                                STsdbReader* pReader) {











UNCOV

4854



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

4855



  int32_t             lino = 0;




×








UNCOV

4856



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

4857



  SRowMerger*         pMerger = NULL;




×








UNCOV

4858



  bool                asc = false;




×








UNCOV

4859



  int32_t             step = 0;




×








UNCOV

4860



  SVersionRange*      pRange = NULL;




×







4861













UNCOV

4862



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4863



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4864













UNCOV

4865



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

4866



  pMerger = &pReader->status.merger;




×








UNCOV

4867



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

4868



  step = asc ? 1 : -1;





×








UNCOV

4869



  pRange = &pReader->info.verRange;




×







4870













UNCOV

4871



  pDumpInfo->rowIndex += step;




×








UNCOV

4872



  if ((pDumpInfo->rowIndex <= pBlockData->nRow - 1 && asc) || (pDumpInfo->rowIndex >= 0 && !asc)) {





×








UNCOV

4873



    code = doMergeRowsInFileBlockImpl(pBlockData, &pDumpInfo->rowIndex, pKey, pMerger, pRange, step);




×








UNCOV

4874



    TSDB_CHECK_CODE(code, lino, _end);





×







4875



  }










4876












4877



  // all rows are consumed, let's try next file block











UNCOV

4878



  if ((pDumpInfo->rowIndex >= pBlockData->nRow && asc) || (pDumpInfo->rowIndex < 0 && !asc)) {





×







4879



    while (1) {




×








UNCOV

4880



      SFileDataBlockInfo* pFileBlockInfo = NULL;




×








UNCOV

4881



      code = getCurrentBlockInfo(&pReader->status.blockIter, &pFileBlockInfo, pReader->idStr);




×








UNCOV

4882



      TSDB_CHECK_CODE(code, lino, _end);





×







4883













UNCOV

4884



      if (pFileBlockInfo == NULL) {





×








UNCOV

4885



        break;




×







4886



      }










4887













UNCOV

4888



      CHECK_FILEBLOCK_STATE st = CHECK_FILEBLOCK_QUIT;




×








UNCOV

4889



      code = checkForNeighborFileBlock(pReader, pScanInfo, pFileBlockInfo, pMerger, pKey, &st);




×








UNCOV

4890



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4891



      if (st == CHECK_FILEBLOCK_QUIT) {





×








UNCOV

4892



        break;




×







4893



      }










4894



    }










4895



  }










4896













UNCOV

4897



_end:




×








UNCOV

4898



  if (code != TSDB_CODE_SUCCESS) {





×







4899



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





×







4900



  }











UNCOV

4901



  return code;




×







4902



}










4903













UNCOV

4904



int32_t doMergeRowsInSttBlock(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, SRowMerger* pMerger,




×







4905



                              int32_t pkSrcSlot, SVersionRange* pVerRange, const char* idStr) {











UNCOV

4906



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

4907



  int32_t  lino = 0;




×








UNCOV

4908



  SRowKey* pRowKey = NULL;




×








UNCOV

4909



  SRowKey* pNextKey = NULL;




×







4910













UNCOV

4911



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4912













UNCOV

4913



  pRowKey = &pScanInfo->lastProcKey;




×







4914













UNCOV

4915



  while (1) {




×








UNCOV

4916



    code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pkSrcSlot, pVerRange);




×








UNCOV

4917



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4918



    if (!hasDataInSttBlock(pScanInfo)) {





×








UNCOV

4919



      break;




×







4920



    }










4921













UNCOV

4922



    pNextKey = getCurrentKeyInSttBlock(pSttBlockReader);





×







4923













UNCOV

4924



    int32_t ret = pkCompEx(pRowKey, pNextKey);




×








UNCOV

4925



    if (ret == 0) {





×








UNCOV

4926



      TSDBROW* pRow1 = tMergeTreeGetRow(&pSttBlockReader->mergeTree);




×








UNCOV

4927



      code = tsdbRowMergerAdd(pMerger, pRow1, NULL);




×








UNCOV

4928



      TSDB_CHECK_CODE(code, lino, _end);





×







4929



    } else {











UNCOV

4930



      tsdbTrace("uid:%" PRIu64 " last del index:%d, del range:%d, lastKeyInStt:%" PRId64 ", %s", pScanInfo->uid,





×







4931



                pScanInfo->sttBlockDelIndex, (int32_t)taosArrayGetSize(pScanInfo->delSkyline),










4932



                pScanInfo->sttKeyInfo.nextProcKey.ts, idStr);











UNCOV

4933



      break;




×







4934



    }










4935



  }










4936













UNCOV

4937



_end:




×








UNCOV

4938



  if (code != TSDB_CODE_SUCCESS) {





×







4939



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





×







4940



  }











UNCOV

4941



  return code;




×







4942



}










4943













UNCOV

4944



int32_t doMergeMemTableMultiRows(TSDBROW* pRow, SRowKey* pKey, uint64_t uid, SIterInfo* pIter, SArray* pDelList,




×







4945



                                 TSDBROW* pResRow, STsdbReader* pReader, bool* freeTSRow) {











UNCOV

4946



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

4947



  int32_t     lino = 0;




×








UNCOV

4948



  SRowMerger* pMerger = NULL;




×








UNCOV

4949



  TSDBROW*    pNextRow = NULL;




×








UNCOV

4950



  STSchema*   pTSchema = NULL;




×








UNCOV

4951



  STSchema*   pTSchema1 = NULL;




×







4952



  TSDBROW     current;










4953













UNCOV

4954



  TSDB_CHECK_NULL(pRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4955



  TSDB_CHECK_NULL(pIter, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4956



  TSDB_CHECK_NULL(pResRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4957



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

4958



  TSDB_CHECK_NULL(freeTSRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







4959













UNCOV

4960



  pMerger = &pReader->status.merger;




×








UNCOV

4961



  current = *pRow;




×







4962












4963



  {  // if the timestamp of the next valid row has a different ts, return current row directly











UNCOV

4964



    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);




×







4965













UNCOV

4966



    if (!pIter->hasVal) {





×








UNCOV

4967



      *pResRow = *pRow;




×








UNCOV

4968



      *freeTSRow = false;




×








UNCOV

4969



      goto _end;




×







4970



    } else {  // has next point in mem/imem











UNCOV

4971



      code = getValidMemRow(pIter, pDelList, pReader, &pNextRow);




×








UNCOV

4972



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4973



      if (pNextRow == NULL) {





×








UNCOV

4974



        *pResRow = current;




×








UNCOV

4975



        *freeTSRow = false;




×








UNCOV

4976



        goto _end;




×







4977



      }










4978













UNCOV

4979



      if (TSDBROW_TS(&current) != TSDBROW_TS(pNextRow)) {





×








UNCOV

4980



        *pResRow = current;




×








UNCOV

4981



        *freeTSRow = false;




×








UNCOV

4982



        goto _end;




×







4983



      }










4984













UNCOV

4985



      if (pKey->numOfPKs > 0) {





×








UNCOV

4986



        SRowKey nextRowKey = {0};




×








UNCOV

4987



        tRowGetKeyEx(pNextRow, &nextRowKey);





×








UNCOV

4988



        if (pkCompEx(pKey, &nextRowKey) != 0) {





×








UNCOV

4989



          *pResRow = current;




×








UNCOV

4990



          *freeTSRow = false;




×








UNCOV

4991



          goto _end;




×







4992



        }










4993



      }










4994



    }










4995



  }










4996












4997



  // start to merge duplicated rows











UNCOV

4998



  if (current.type == TSDBROW_ROW_FMT) {  // get the correct schema for row-wise data in memory





×








UNCOV

4999



    pTSchema = doGetSchemaForTSRow(current.pTSRow->sver, pReader, uid);





×








UNCOV

5000



    TSDB_CHECK_NULL(pTSchema, code, lino, _end, terrno);





×







5001



  }










5002













UNCOV

5003



  code = tsdbRowMergerAdd(pMerger, &current, pTSchema);




×








UNCOV

5004



  TSDB_CHECK_CODE(code, lino, _end);





×







5005













UNCOV

5006



  if (pNextRow->type == TSDBROW_ROW_FMT) {  // get the correct schema for row-wise data in memory





×








UNCOV

5007



    pTSchema1 = doGetSchemaForTSRow(pNextRow->pTSRow->sver, pReader, uid);





×








UNCOV

5008



    TSDB_CHECK_NULL(pTSchema1, code, lino, _end, terrno);





×







5009



  }










5010













UNCOV

5011



  code = tsdbRowMergerAdd(pMerger, pNextRow, pTSchema1);




×








UNCOV

5012



  TSDB_CHECK_CODE(code, lino, _end);





×







5013













UNCOV

5014



  code = doMergeRowsInBuf(pIter, uid, pKey, pDelList, pReader);




×








UNCOV

5015



  TSDB_CHECK_CODE(code, lino, _end);





×







5016













UNCOV

5017



  code = tsdbRowMergerGetRow(pMerger, &pResRow->pTSRow);




×








UNCOV

5018



  TSDB_CHECK_CODE(code, lino, _end);





×







5019













UNCOV

5020



  pResRow->type = TSDBROW_ROW_FMT;




×








UNCOV

5021



  tsdbRowMergerClear(pMerger);




×








UNCOV

5022



  *freeTSRow = true;




×







5023













UNCOV

5024



_end:




×








UNCOV

5025



  if (code != TSDB_CODE_SUCCESS) {





×







5026



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





×







5027



  }











UNCOV

5028



  return code;




×







5029



}










5030













UNCOV

5031



int32_t doMergeMemIMemRows(TSDBROW* pRow, SRowKey* pRowKey, TSDBROW* piRow, SRowKey* piRowKey,




×







5032



                           STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader, SRow** pTSRow) {











UNCOV

5033



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

5034



  int32_t     lino = 0;




×








UNCOV

5035



  SRowMerger* pMerger = NULL;




×








UNCOV

5036



  STSchema*   pSchema = NULL;




×








UNCOV

5037



  STSchema*   piSchema = NULL;




×







5038













UNCOV

5039



  TSDB_CHECK_NULL(pRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5040



  TSDB_CHECK_NULL(piRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5041



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5042



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5043













UNCOV

5044



  pMerger = &pReader->status.merger;




×







5045













UNCOV

5046



  if (pRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

5047



    pSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, pBlockScanInfo->uid);





×








UNCOV

5048



    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);





×







5049



  }










5050













UNCOV

5051



  if (piRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

5052



    piSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(piRow), pReader, pBlockScanInfo->uid);





×








UNCOV

5053



    TSDB_CHECK_NULL(piSchema, code, lino, _end, terrno);





×







5054



  }










5055













UNCOV

5056



  if (ASCENDING_TRAVERSE(pReader->info.order)) {  // ascending order imem --> mem





×








UNCOV

5057



    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);




×








UNCOV

5058



    TSDB_CHECK_CODE(code, lino, _end);





×







5059













UNCOV

5060



    code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, piRowKey, pBlockScanInfo->delSkyline, pReader);




×








UNCOV

5061



    TSDB_CHECK_CODE(code, lino, _end);





×







5062













UNCOV

5063



    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);




×








UNCOV

5064



    TSDB_CHECK_CODE(code, lino, _end);





×







5065













UNCOV

5066



    code = doMergeRowsInBuf(&pBlockScanInfo->iter, pBlockScanInfo->uid, pRowKey, pBlockScanInfo->delSkyline, pReader);




×








UNCOV

5067



    TSDB_CHECK_CODE(code, lino, _end);





×







5068



  } else {










5069



    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);




×







5070



    TSDB_CHECK_CODE(code, lino, _end);





×







5071












5072



    code = doMergeRowsInBuf(&pBlockScanInfo->iter, pBlockScanInfo->uid, pRowKey, pBlockScanInfo->delSkyline, pReader);




×







5073



    TSDB_CHECK_CODE(code, lino, _end);





×







5074












5075



    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);




×







5076



    TSDB_CHECK_CODE(code, lino, _end);





×







5077












5078



    code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, piRowKey, pBlockScanInfo->delSkyline, pReader);




×







5079



    TSDB_CHECK_CODE(code, lino, _end);





×







5080



  }










5081













UNCOV

5082



  tRowKeyAssign(&pBlockScanInfo->lastProcKey, pRowKey);




×







5083













UNCOV

5084



  code = tsdbRowMergerGetRow(pMerger, pTSRow);




×








UNCOV

5085



  tsdbRowMergerClear(pMerger);




×








UNCOV

5086



  TSDB_CHECK_CODE(code, lino, _end);





×







5087













UNCOV

5088



_end:




×








UNCOV

5089



  if (code != TSDB_CODE_SUCCESS) {





×







5090



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





×







5091



  }











UNCOV

5092



  return code;




×







5093



}










5094













UNCOV

5095



static int32_t tsdbGetNextRowInMem(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader, TSDBROW* pResRow,




×







5096



                                   int64_t endKey, bool* freeTSRow) {











UNCOV

5097



  int32_t    code = TSDB_CODE_SUCCESS;




×








UNCOV

5098



  int32_t    lino = 0;




×








UNCOV

5099



  TSDBROW*   pRow = NULL;




×








UNCOV

5100



  TSDBROW*   piRow = NULL;




×








UNCOV

5101



  SArray*    pDelList = NULL;




×








UNCOV

5102



  uint64_t   uid = 0;




×








UNCOV

5103



  SIterInfo* piter = NULL;




×








UNCOV

5104



  SIterInfo* piiter = NULL;




×








UNCOV

5105



  SRowKey    rowKey = {0};




×








UNCOV

5106



  SRowKey    irowKey = {0};




×








UNCOV

5107



  bool       asc = false;




×







5108













UNCOV

5109



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5110



  TSDB_CHECK_NULL(pResRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5111



  TSDB_CHECK_NULL(freeTSRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5112













UNCOV

5113



  code = getValidMemRow(&pBlockScanInfo->iter, pBlockScanInfo->delSkyline, pReader, &pRow);





×








UNCOV

5114



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5115



  code = getValidMemRow(&pBlockScanInfo->iiter, pBlockScanInfo->delSkyline, pReader, &piRow);





×








UNCOV

5116



  TSDB_CHECK_CODE(code, lino, _end);





×







5117













UNCOV

5118



  pDelList = pBlockScanInfo->delSkyline;




×








UNCOV

5119



  uid = pBlockScanInfo->uid;




×








UNCOV

5120



  piter = &pBlockScanInfo->iter;




×








UNCOV

5121



  piiter = &pBlockScanInfo->iiter;




×







5122












5123



  // todo refactor











UNCOV

5124



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

5125



  if (piter->hasVal) {





×








UNCOV

5126



    tRowGetKeyEx(pRow, &rowKey);





×








UNCOV

5127



    if ((rowKey.ts >= endKey && asc) || (rowKey.ts <= endKey && !asc)) {





×








UNCOV

5128



      pRow = NULL;




×







5129



    }










5130



  }










5131













UNCOV

5132



  if (piiter->hasVal) {





×








UNCOV

5133



    tRowGetKeyEx(piRow, &irowKey);





×








UNCOV

5134



    if ((irowKey.ts >= endKey && asc) || (irowKey.ts <= endKey && !asc)) {





×







5135



      piRow = NULL;




×







5136



    }










5137



  }










5138













UNCOV

5139



  if (pRow != NULL && piRow != NULL) {





×








UNCOV

5140



    if (rowKey.numOfPKs == 0) {





×








UNCOV

5141



      if ((rowKey.ts > irowKey.ts && asc) || (rowKey.ts < irowKey.ts && (!asc))) {  // ik.ts < k.ts





×








UNCOV

5142



        code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5143



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5144



      } else if ((rowKey.ts < irowKey.ts && asc) || (rowKey.ts > irowKey.ts && (!asc))) {





×








UNCOV

5145



        code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5146



        TSDB_CHECK_CODE(code, lino, _end);





×







5147



      } else {  // ik.ts == k.ts











UNCOV

5148



        pResRow->type = TSDBROW_ROW_FMT;




×








UNCOV

5149



        code = doMergeMemIMemRows(pRow, &rowKey, piRow, &irowKey, pBlockScanInfo, pReader, &pResRow->pTSRow);




×








UNCOV

5150



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5151



        *freeTSRow = true;




×







5152



      }










5153



    } else {











UNCOV

5154



      int32_t ret = pkCompEx(&rowKey, &irowKey);




×








UNCOV

5155



      if (ret != 0) {





×








UNCOV

5156



        if ((ret > 0 && asc) || (ret < 0 && (!asc))) {  // ik.ts < k.ts





×








UNCOV

5157



          code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5158



          TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5159



        } else if ((ret < 0 && asc) || (ret > 0 && (!asc))) {





×








UNCOV

5160



          code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5161



          TSDB_CHECK_CODE(code, lino, _end);





×







5162



        }










5163



      } else {  // ik.ts == k.ts










5164



        pResRow->type = TSDBROW_ROW_FMT;




×







5165



        code = doMergeMemIMemRows(pRow, &rowKey, piRow, &irowKey, pBlockScanInfo, pReader, &pResRow->pTSRow);




×







5166



        TSDB_CHECK_CODE(code, lino, _end);





×







5167



        *freeTSRow = true;




×







5168



      }










5169



    }











UNCOV

5170



  } else if (piter->hasVal && pRow != NULL) {





×








UNCOV

5171



    code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5172



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5173



  } else if (piiter->hasVal && piRow != NULL) {





×








UNCOV

5174



    code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5175



    TSDB_CHECK_CODE(code, lino, _end);





×







5176



  }










5177













UNCOV

5178



_end:




×








UNCOV

5179



  if (code != TSDB_CODE_SUCCESS) {





×







5180



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





×







5181



  }











UNCOV

5182



  return code;




×







5183



}










5184













UNCOV

5185



int32_t doAppendRowFromTSRow(SSDataBlock* pBlock, STsdbReader* pReader, SRow* pTSRow, STableBlockScanInfo* pScanInfo) {




×








UNCOV

5186



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

5187



  int32_t             lino = 0;




×








UNCOV

5188



  int32_t             outputRowIndex = 0;




×








UNCOV

5189



  int64_t             uid = 0;




×








UNCOV

5190



  SBlockLoadSuppInfo* pSupInfo = NULL;




×








UNCOV

5191



  STSchema*           pSchema = NULL;




×








UNCOV

5192



  SColVal             colVal = {0};




×








UNCOV

5193



  int32_t             i = 0, j = 0;




×







5194













UNCOV

5195



  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5196



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5197



  TSDB_CHECK_NULL(pTSRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5198



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5199













UNCOV

5200



  outputRowIndex = pBlock->info.rows;




×








UNCOV

5201



  uid = pScanInfo->uid;




×







5202













UNCOV

5203



  pSupInfo = &pReader->suppInfo;




×








UNCOV

5204



  pSchema = doGetSchemaForTSRow(pTSRow->sver, pReader, uid);





×








UNCOV

5205



  TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);





×







5206













UNCOV

5207



  if (pSupInfo->colId[i] == PRIMARYKEY_TIMESTAMP_COL_ID) {





×








UNCOV

5208



    SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5209



    TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5210













UNCOV

5211



    ((int64_t*)pColData->pData)[outputRowIndex] = pTSRow->ts;




×








UNCOV

5212



    i += 1;




×







5213



  }










5214













UNCOV

5215



  while (i < pSupInfo->numOfCols && j < pSchema->numOfCols) {





×








UNCOV

5216



    col_id_t colId = pSupInfo->colId[i];




×







5217













UNCOV

5218



    if (colId == pSchema->columns[j].colId) {





×








UNCOV

5219



      SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5220



      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5221













UNCOV

5222



      code = tRowGet(pTSRow, pSchema, j, &colVal);




×








UNCOV

5223



      TSDB_CHECK_CODE(code, lino, _end);





×







5224













UNCOV

5225



      code = doCopyColVal(pColInfoData, outputRowIndex, i, &colVal, pSupInfo);




×








UNCOV

5226



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5227



      i += 1;




×








UNCOV

5228



      j += 1;




×








UNCOV

5229



    } else if (colId < pSchema->columns[j].colId) {





×







5230



      SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);




×







5231



      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5232












5233



      colDataSetNULL(pColInfoData, outputRowIndex);





×







5234



      i += 1;




×








UNCOV

5235



    } else if (colId > pSchema->columns[j].colId) {





×








UNCOV

5236



      j += 1;




×







5237



    }










5238



  }










5239












5240



  // set null value since current column does not exist in the "pSchema"











UNCOV

5241



  while (i < pSupInfo->numOfCols) {





×








UNCOV

5242



    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5243



    TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5244













UNCOV

5245



    colDataSetNULL(pColInfoData, outputRowIndex);





×








UNCOV

5246



    i += 1;




×







5247



  }










5248













UNCOV

5249



  pBlock->info.dataLoad = 1;




×








UNCOV

5250



  pBlock->info.rows += 1;




×







5251













UNCOV

5252



_end:




×








UNCOV

5253



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

5254



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





×







5255



  }











UNCOV

5256



  return code;




×







5257



}










5258













UNCOV

5259



int32_t doAppendRowFromFileBlock(SSDataBlock* pResBlock, STsdbReader* pReader, SBlockData* pBlockData,




×







5260



                                 int32_t rowIndex) {











UNCOV

5261



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

5262



  int32_t             lino = 0;




×








UNCOV

5263



  int32_t             i = 0, j = 0;




×








UNCOV

5264



  int32_t             outputRowIndex = 0;




×








UNCOV

5265



  SBlockLoadSuppInfo* pSupInfo = NULL;




×








UNCOV

5266



  SColVal             cv = {0};




×








UNCOV

5267



  int32_t             numOfInputCols = 0;




×








UNCOV

5268



  int32_t             numOfOutputCols = 0;




×







5269













UNCOV

5270



  TSDB_CHECK_NULL(pResBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5271



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5272



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5273













UNCOV

5274



  outputRowIndex = pResBlock->info.rows;




×







5275













UNCOV

5276



  pSupInfo = &pReader->suppInfo;




×








UNCOV

5277



  ((int64_t*)pReader->status.pPrimaryTsCol->pData)[outputRowIndex] = pBlockData->aTSKEY[rowIndex];




×








UNCOV

5278



  i += 1;




×







5279













UNCOV

5280



  numOfInputCols = pBlockData->nColData;




×








UNCOV

5281



  numOfOutputCols = pSupInfo->numOfCols;




×







5282













UNCOV

5283



  while (i < numOfOutputCols && j < numOfInputCols) {





×








UNCOV

5284



    SColData* pData = tBlockDataGetColDataByIdx(pBlockData, j);




×








UNCOV

5285



    if (pData->cid < pSupInfo->colId[i]) {





×








UNCOV

5286



      j += 1;




×








UNCOV

5287



      continue;




×







5288



    }










5289













UNCOV

5290



    SColumnInfoData* pCol = TARRAY_GET_ELEM(pResBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5291



    if (pData->cid == pSupInfo->colId[i]) {





×








UNCOV

5292



      code = tColDataGetValue(pData, rowIndex, &cv);




×








UNCOV

5293



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5294



      code = doCopyColVal(pCol, outputRowIndex, i, &cv, pSupInfo);




×








UNCOV

5295



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5296



      j += 1;




×







5297



    } else if (pData->cid > pCol->info.colId) {





×







5298



      // the specified column does not exist in file block, fill with null data











UNCOV

5299



      colDataSetNULL(pCol, outputRowIndex);





×







5300



    }










5301













UNCOV

5302



    i += 1;




×







5303



  }










5304













UNCOV

5305



  while (i < numOfOutputCols) {





×








UNCOV

5306



    SColumnInfoData* pCol = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5307



    TSDB_CHECK_NULL(pCol, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5308













UNCOV

5309



    colDataSetNULL(pCol, outputRowIndex);





×








UNCOV

5310



    i += 1;




×







5311



  }










5312













UNCOV

5313



  pResBlock->info.dataLoad = 1;




×








UNCOV

5314



  pResBlock->info.rows += 1;




×







5315













UNCOV

5316



_end:




×








UNCOV

5317



  if (code != TSDB_CODE_SUCCESS) {





×







5318



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





×







5319



  }











UNCOV

5320



  return code;




×







5321



}










5322













UNCOV

5323



int32_t buildDataBlockFromBufImpl(STableBlockScanInfo* pBlockScanInfo, int64_t endKey, int32_t capacity,




×







5324



                                  STsdbReader* pReader) {











UNCOV

5325



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

5326



  int32_t      lino = 0;




×








UNCOV

5327



  SSDataBlock* pBlock = NULL;




×







5328













UNCOV

5329



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5330













UNCOV

5331



  pBlock = pReader->resBlockInfo.pResBlock;




×







5332













UNCOV

5333



  do {




×








UNCOV

5334



    TSDBROW row = {.type = -1};




×








UNCOV

5335



    bool    freeTSRow = false;




×








UNCOV

5336



    code = tsdbGetNextRowInMem(pBlockScanInfo, pReader, &row, endKey, &freeTSRow);




×








UNCOV

5337



    TSDB_CHECK_CODE(code, lino, _end);





×







5338













UNCOV

5339



    if (row.type == -1) {





×








UNCOV

5340



      break;




×







5341



    }










5342













UNCOV

5343



    if (row.type == TSDBROW_ROW_FMT) {





×








UNCOV

5344



      code = doAppendRowFromTSRow(pBlock, pReader, row.pTSRow, pBlockScanInfo);




×








UNCOV

5345



      if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

5346



        if (freeTSRow) {





×







5347



          taosMemoryFreeClear(row.pTSRow);





×







5348



        }











UNCOV

5349



        TSDB_CHECK_CODE(code, lino, _end);





×







5350



      }











UNCOV

5351



      pBlockScanInfo->lastProcKey.ts = row.pTSRow->ts;




×








UNCOV

5352



      pBlockScanInfo->lastProcKey.numOfPKs = row.pTSRow->numOfPKs;




×








UNCOV

5353



      if (row.pTSRow->numOfPKs > 0) {





×








UNCOV

5354



        code = tRowGetPrimaryKeyDeepCopy(row.pTSRow, &pBlockScanInfo->lastProcKey);




×








UNCOV

5355



        if (code != TSDB_CODE_SUCCESS) {





×







5356



          if (freeTSRow) {





×







5357



            taosMemoryFreeClear(row.pTSRow);





×







5358



          }










5359



          TSDB_CHECK_CODE(code, lino, _end);





×







5360



        }










5361



      }










5362













UNCOV

5363



      if (freeTSRow) {





×








UNCOV

5364



        taosMemoryFreeClear(row.pTSRow);





×







5365



      }










5366



    } else {











UNCOV

5367



      code = doAppendRowFromFileBlock(pBlock, pReader, row.pBlockData, row.iRow);




×








UNCOV

5368



      TSDB_CHECK_CODE(code, lino, _end);





×







5369













UNCOV

5370



      tColRowGetKeyDeepCopy(row.pBlockData, row.iRow, pReader->suppInfo.pkSrcSlot, &pBlockScanInfo->lastProcKey);





×







5371



    }










5372












5373



    // no data in buffer, return immediately











UNCOV

5374



    if (!(pBlockScanInfo->iter.hasVal || pBlockScanInfo->iiter.hasVal)) {





×








UNCOV

5375



      break;




×







5376



    }










5377













UNCOV

5378



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





×








UNCOV

5379



      break;




×







5380



    }










5381



  } while (1);










5382













UNCOV

5383



_end:




×








UNCOV

5384



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

5385



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





×







5386



  }











UNCOV

5387



  return code;




×







5388



}










5389












5390



// TODO refactor: with createDataBlockScanInfo











UNCOV

5391



int32_t tsdbSetTableList2(STsdbReader* pReader, const void* pTableList, int32_t num) {




×








UNCOV

5392



  int32_t               code = TSDB_CODE_SUCCESS;




×








UNCOV

5393



  int32_t               lino = 0;




×








UNCOV

5394



  int32_t               size = 0;




×








UNCOV

5395



  STableBlockScanInfo** p = NULL;




×








UNCOV

5396



  STableUidList*        pUidList = NULL;




×








UNCOV

5397



  int32_t               iter = 0;




×








UNCOV

5398



  bool                  acquired = false;




×







5399













UNCOV

5400



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5401













UNCOV

5402



  size = tSimpleHashGetSize(pReader->status.pTableMap);




×







5403













UNCOV

5404



  code = tsdbAcquireReader(pReader);




×








UNCOV

5405



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5406



  acquired = true;




×







5407













UNCOV

5408



  while ((p = tSimpleHashIterate(pReader->status.pTableMap, p, &iter)) != NULL) {





×








UNCOV

5409



    clearBlockScanInfo(*p);




×







5410



  }










5411













UNCOV

5412



  tSimpleHashClear(pReader->status.pTableMap);




×







5413













UNCOV

5414



  if (size < num) {





×








UNCOV

5415



    code = ensureBlockScanInfoBuf(&pReader->blockInfoBuf, num);




×








UNCOV

5416



    TSDB_CHECK_CODE(code, lino, _end);





×







5417













UNCOV

5418



    char* p1 = taosMemoryRealloc(pReader->status.uidList.tableUidList, sizeof(uint64_t) * num);





×








UNCOV

5419



    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);





×







5420













UNCOV

5421



    pReader->status.uidList.tableUidList = (uint64_t*)p1;




×







5422



  }










5423













UNCOV

5424



  pUidList = &pReader->status.uidList;




×








UNCOV

5425



  pUidList->currentIndex = 0;




×







5426













UNCOV

5427



  STableKeyInfo* pList = (STableKeyInfo*)pTableList;




×








UNCOV

5428



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





×








UNCOV

5429



    pUidList->tableUidList[i] = pList[i].uid;




×







5430













UNCOV

5431



    STableBlockScanInfo* pInfo = NULL;




×








UNCOV

5432



    code = getPosInBlockInfoBuf(&pReader->blockInfoBuf, i, &pInfo);




×








UNCOV

5433



    TSDB_CHECK_CODE(code, lino, _end);





×







5434













UNCOV

5435



    code = initTableBlockScanInfo(pInfo, pList[i].uid, pReader->status.pTableMap, pReader);




×








UNCOV

5436



    TSDB_CHECK_CODE(code, lino, _end);





×







5437



  }










5438













UNCOV

5439



_end:




×








UNCOV

5440



  if (code != TSDB_CODE_SUCCESS) {





×







5441



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





×







5442



  }











UNCOV

5443



  if (acquired) {





×








UNCOV

5444



    (void)tsdbReleaseReader(pReader);




×







5445



  }











UNCOV

5446



  return code;




×







5447



}










5448












5449



uint64_t tsdbGetReaderMaxVersion2(STsdbReader* pReader) { return pReader->info.verRange.maxVer; }




×







5450













UNCOV

5451



static int32_t doOpenReaderImpl(STsdbReader* pReader) {




×








UNCOV

5452



  int32_t         code = TSDB_CODE_SUCCESS;




×








UNCOV

5453



  int32_t         lino = 0;




×








UNCOV

5454



  SReaderStatus*  pStatus = NULL;




×








UNCOV

5455



  SDataBlockIter* pBlockIter = NULL;




×







5456













UNCOV

5457



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5458













UNCOV

5459



  pStatus = &pReader->status;




×








UNCOV

5460



  pBlockIter = &pStatus->blockIter;




×







5461













UNCOV

5462



  if (pReader->bFilesetDelimited) {





×








UNCOV

5463



    getMemTableTimeRange(pReader, &pReader->status.memTableMaxKey, &pReader->status.memTableMinKey);




×








UNCOV

5464



    pReader->status.bProcMemFirstFileset = true;




×







5465



  }










5466













UNCOV

5467



  code = initFilesetIterator(&pStatus->fileIter, pReader->pReadSnap->pfSetArray, pReader);




×








UNCOV

5468



  TSDB_CHECK_CODE(code, lino, _end);





×







5469













UNCOV

5470



  code = resetDataBlockIterator(&pStatus->blockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo),




×








UNCOV

5471



                                pReader->idStr);




×








UNCOV

5472



  TSDB_CHECK_CODE(code, lino, _end);





×







5473













UNCOV

5474



  if (pStatus->fileIter.numOfFiles == 0) {





×








UNCOV

5475



    pStatus->loadFromFile = false;




×







5476



  } else {











UNCOV

5477



    code = initForFirstBlockInFile(pReader, pBlockIter);




×







5478



  }










5479













UNCOV

5480



  if (!pStatus->loadFromFile) {





×








UNCOV

5481



    code = resetTableListIndex(pStatus, pReader->idStr);




×








UNCOV

5482



    TSDB_CHECK_CODE(code, lino, _end);





×







5483



  }










5484













UNCOV

5485



_end:




×








UNCOV

5486



  if (code != TSDB_CODE_SUCCESS) {





×







5487



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





×







5488



  }











UNCOV

5489



  return code;




×







5490



}










5491













UNCOV

5492



static void freeSchemaFunc(void* param) {




×








UNCOV

5493



  void** p = (void**)param;




×








UNCOV

5494



  taosMemoryFreeClear(*p);





×








UNCOV

5495



}




×







5496













UNCOV

5497



static void clearSharedPtr(STsdbReader* p) {




×








UNCOV

5498



  if (p) {





×








UNCOV

5499



    p->status.pTableMap = NULL;




×








UNCOV

5500



    p->status.uidList.tableUidList = NULL;




×








UNCOV

5501



    p->info.pSchema = NULL;




×








UNCOV

5502



    p->pReadSnap = NULL;




×








UNCOV

5503



    p->pSchemaMap = NULL;




×







5504



  }











UNCOV

5505



}




×







5506













UNCOV

5507



static int32_t setSharedPtr(STsdbReader* pDst, const STsdbReader* pSrc) {




×








UNCOV

5508



  pDst->status.pTableMap = pSrc->status.pTableMap;




×








UNCOV

5509



  pDst->status.uidList = pSrc->status.uidList;




×








UNCOV

5510



  pDst->info.pSchema = pSrc->info.pSchema;




×








UNCOV

5511



  pDst->pSchemaMap = pSrc->pSchemaMap;




×








UNCOV

5512



  pDst->pReadSnap = pSrc->pReadSnap;




×








UNCOV

5513



  pDst->pReadSnap->pfSetArray = pSrc->pReadSnap->pfSetArray;




×







5514













UNCOV

5515



  if (pDst->info.pSchema) {





×








UNCOV

5516



    return tsdbRowMergerInit(&pDst->status.merger, pDst->info.pSchema);




×







5517



  }










5518













UNCOV

5519



  return TSDB_CODE_SUCCESS;




×







5520



}










5521












5522



// ====================================== EXPOSED APIs ======================================











UNCOV

5523



int32_t tsdbReaderOpen2(void* pVnode, SQueryTableDataCond* pCond, void* pTableList, int32_t numOfTables,




×







5524



                        SSDataBlock* pResBlock, void** ppReader, const char* idstr, SHashObj** pIgnoreTables) {











UNCOV

5525



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

5526



  int32_t      lino = 0;




×








UNCOV

5527



  STimeWindow  window = {0};




×








UNCOV

5528



  SVnodeCfg*   pConf = NULL;




×








UNCOV

5529



  STsdbReader* pReader = NULL;




×








UNCOV

5530



  int32_t      capacity = 0;




×







5531













UNCOV

5532



  window = pCond->twindows;




×








UNCOV

5533



  pConf = &(((SVnode*)pVnode)->config);




×







5534













UNCOV

5535



  capacity = pConf->tsdbCfg.maxRows;




×








UNCOV

5536



  if (pResBlock != NULL) {





×








UNCOV

5537



    code = blockDataEnsureCapacity(pResBlock, capacity);




×








UNCOV

5538



    TSDB_CHECK_CODE(code, lino, _end);





×







5539



  }










5540













UNCOV

5541



  code = tsdbReaderCreate(pVnode, pCond, ppReader, capacity, pResBlock, idstr);




×








UNCOV

5542



  TSDB_CHECK_CODE(code, lino, _end);





×







5543












5544



  // check for query time window











UNCOV

5545



  pReader = *ppReader;




×








UNCOV

5546



  if (isEmptyQueryTimeWindow(&pReader->info.window) && pCond->type == TIMEWINDOW_RANGE_CONTAINED) {





×








UNCOV

5547



    tsdbDebug("%p query window not overlaps with the data set, no result returned, %s", pReader, pReader->idStr);





×








UNCOV

5548



    goto _end;




×







5549



  }










5550













UNCOV

5551



  if (pCond->type == TIMEWINDOW_RANGE_EXTERNAL) {





×







5552



    // update the SQueryTableDataCond to create inner reader











UNCOV

5553



    int32_t order = pCond->order;




×








UNCOV

5554



    if (order == TSDB_ORDER_ASC) {





×








UNCOV

5555



      pCond->twindows = pCond->extTwindows[0];




×








UNCOV

5556



      pCond->order = TSDB_ORDER_DESC;




×







5557



    } else {










5558



      pCond->twindows = pCond->extTwindows[1];




×







5559



      pCond->order = TSDB_ORDER_ASC;




×







5560



    }










5561












5562



    // here we only need one more row, so the capacity is set to be ONE.











UNCOV

5563



    code = tsdbReaderCreate(pVnode, pCond, (void**)&((STsdbReader*)pReader)->innerReader[0], 1, pResBlock, idstr);




×








UNCOV

5564



    TSDB_CHECK_CODE(code, lino, _end);





×







5565













UNCOV

5566



    if (order == TSDB_ORDER_ASC) {





×








UNCOV

5567



      pCond->twindows = pCond->extTwindows[1];




×







5568



    } else {










5569



      pCond->twindows = pCond->extTwindows[0];




×







5570



    }











UNCOV

5571



    pCond->order = order;




×







5572













UNCOV

5573



    code = tsdbReaderCreate(pVnode, pCond, (void**)&((STsdbReader*)pReader)->innerReader[1], 1, pResBlock, idstr);




×








UNCOV

5574



    TSDB_CHECK_CODE(code, lino, _end);





×







5575



  }










5576












5577



  // NOTE: the endVersion in pCond is the data version not schema version, so pCond->endVersion is not correct here.










5578



  //  no valid error code set in metaGetTbTSchema, so let's set the error code here.










5579



  //  we should proceed in case of tmq processing.











UNCOV

5580



  if (pCond->suid != 0) {





×








UNCOV

5581



    code = metaGetTbTSchemaMaybeNull(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, -1, 1, &pReader->info.pSchema);




×








UNCOV

5582



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5583



    if (pReader->info.pSchema == NULL) {





×








UNCOV

5584



      tsdbWarn("failed to get table schema, suid:%" PRIu64 ", ver:-1, %s", pReader->info.suid, pReader->idStr);





×







5585



    }











UNCOV

5586



  } else if (numOfTables > 0) {





×








UNCOV

5587



    STableKeyInfo* pKey = pTableList;




×








UNCOV

5588



    code = metaGetTbTSchemaMaybeNull(pReader->pTsdb->pVnode->pMeta, pKey->uid, -1, 1, &pReader->info.pSchema);




×








UNCOV

5589



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5590



    if (pReader->info.pSchema == NULL) {





×







5591



      tsdbWarn("failed to get table schema, uid:%" PRIu64 ", ver:-1, %s", pKey->uid, pReader->idStr);





×







5592



    }










5593



  }










5594













UNCOV

5595



  if (pReader->info.pSchema != NULL) {





×








UNCOV

5596



    code = tsdbRowMergerInit(&pReader->status.merger, pReader->info.pSchema);




×








UNCOV

5597



    TSDB_CHECK_CODE(code, lino, _end);





×







5598



  }










5599













UNCOV

5600



  pReader->pSchemaMap = tSimpleHashInit(8, taosFastHash);




×








UNCOV

5601



  if (pReader->pSchemaMap == NULL) {





×







5602



    tsdbError("failed init schema hash for reader %s", pReader->idStr);





×







5603



    TSDB_CHECK_NULL(pReader->pSchemaMap, code, lino, _end, terrno);





×







5604



  }










5605













UNCOV

5606



  tSimpleHashSetFreeFp(pReader->pSchemaMap, freeSchemaFunc);




×








UNCOV

5607



  if (pReader->info.pSchema != NULL) {





×








UNCOV

5608



    code = updateBlockSMAInfo(pReader->info.pSchema, &pReader->suppInfo);




×








UNCOV

5609



    TSDB_CHECK_CODE(code, lino, _end);





×







5610



  }










5611













UNCOV

5612



  STsdbReader* p = (pReader->innerReader[0] != NULL) ? pReader->innerReader[0] : pReader;





×







5613













UNCOV

5614



  code = createDataBlockScanInfo(p, &pReader->blockInfoBuf, pTableList, &pReader->status.uidList, numOfTables,




×







5615



                                 &pReader->status.pTableMap);











UNCOV

5616



  TSDB_CHECK_CODE(code, lino, _end);





×







5617













UNCOV

5618



  pReader->status.pLDataIterArray = taosArrayInit(4, POINTER_BYTES);




×








UNCOV

5619



  TSDB_CHECK_NULL(pReader->status.pLDataIterArray, code, lino, _end, terrno);





×







5620













UNCOV

5621



  pReader->flag = READER_STATUS_SUSPEND;




×








UNCOV

5622



  pReader->info.execMode = pCond->notLoadData ? READER_EXEC_ROWS : READER_EXEC_DATA;





×







5623













UNCOV

5624



  pReader->pIgnoreTables = pIgnoreTables;




×








UNCOV

5625



  tsdbDebug("%p total numOfTable:%d, window:%" PRId64 " - %" PRId64 ", verRange:%" PRId64 " - %" PRId64





×







5626



            " in this query %s",










5627



            pReader, numOfTables, pReader->info.window.skey, pReader->info.window.ekey, pReader->info.verRange.minVer,










5628



            pReader->info.verRange.maxVer, pReader->idStr);










5629













UNCOV

5630



_end:




×








UNCOV

5631



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

5632



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





×








UNCOV

5633



    tsdbReaderClose2(*ppReader);




×








UNCOV

5634



    *ppReader = NULL;  // reset the pointer value.




×







5635



  }











UNCOV

5636



  return code;




×







5637



}










5638













UNCOV

5639



void tsdbReaderClose2(STsdbReader* pReader) {




×








UNCOV

5640



  if (pReader == NULL) {





×








UNCOV

5641



    return;




×







5642



  }










5643













UNCOV

5644



  int32_t code = tsdbAcquireReader(pReader);




×








UNCOV

5645



  if (code) {





×







5646



    return;




×







5647



  }










5648












5649



  {











UNCOV

5650



    if (pReader->innerReader[0] != NULL || pReader->innerReader[1] != NULL) {





×








UNCOV

5651



      STsdbReader* p = pReader->innerReader[0];




×








UNCOV

5652



      clearSharedPtr(p);




×







5653













UNCOV

5654



      p = pReader->innerReader[1];




×








UNCOV

5655



      clearSharedPtr(p);




×







5656













UNCOV

5657



      tsdbReaderClose2(pReader->innerReader[0]);




×








UNCOV

5658



      tsdbReaderClose2(pReader->innerReader[1]);




×







5659



    }










5660



  }










5661













UNCOV

5662



  SBlockLoadSuppInfo* pSupInfo = &pReader->suppInfo;




×








UNCOV

5663



  TARRAY2_DESTROY(&pSupInfo->colAggArray, NULL);





×







5664













UNCOV

5665



  if (pSupInfo->buildBuf) {





×








UNCOV

5666



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





×








UNCOV

5667



      if (pSupInfo->buildBuf[i] != NULL) {





×








UNCOV

5668



        taosMemoryFreeClear(pSupInfo->buildBuf[i]);





×







5669



      }










5670



    }










5671



  }










5672













UNCOV

5673



  if (pReader->resBlockInfo.freeBlock) {





×








UNCOV

5674



    blockDataDestroy(pReader->resBlockInfo.pResBlock);




×








UNCOV

5675



    pReader->resBlockInfo.pResBlock = NULL;




×







5676



  }










5677













UNCOV

5678



  taosMemoryFree(pSupInfo->colId);





×








UNCOV

5679



  tBlockDataDestroy(&pReader->status.fileBlockData);




×








UNCOV

5680



  cleanupDataBlockIterator(&pReader->status.blockIter, shouldFreePkBuf(&pReader->suppInfo));




×







5681













UNCOV

5682



  size_t numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);




×








UNCOV

5683



  if (pReader->status.pTableMap != NULL) {





×








UNCOV

5684



    destroyAllBlockScanInfo(&pReader->status.pTableMap);




×







5685



  }











UNCOV

5686



  clearBlockScanInfoBuf(&pReader->blockInfoBuf);




×







5687













UNCOV

5688



  if (pReader->pFileReader != NULL) {





×








UNCOV

5689



    tsdbDataFileReaderClose(&pReader->pFileReader);




×







5690



  }










5691













UNCOV

5692



  SReadCostSummary* pCost = &pReader->cost;




×








UNCOV

5693



  SFilesetIter*     pFilesetIter = &pReader->status.fileIter;




×








UNCOV

5694



  if (pFilesetIter->pSttBlockReader != NULL) {





×








UNCOV

5695



    SSttBlockReader* pSttBlockReader = pFilesetIter->pSttBlockReader;




×








UNCOV

5696



    tMergeTreeClose(&pSttBlockReader->mergeTree);




×







5697













UNCOV

5698



    clearRowKey(&pSttBlockReader->currentKey);




×








UNCOV

5699



    taosMemoryFree(pSttBlockReader);





×







5700



  }










5701













UNCOV

5702



  destroySttBlockReader(pReader->status.pLDataIterArray, &pCost->sttCost);




×








UNCOV

5703



  pReader->status.pLDataIterArray = NULL;




×








UNCOV

5704



  taosMemoryFreeClear(pReader->status.uidList.tableUidList);





×







5705













UNCOV

5706



  tsdbTrace("tsdb/reader-close: %p, untake snapshot", pReader);





×








UNCOV

5707



  void* p = pReader->pReadSnap;




×








UNCOV

5708



  if ((p == atomic_val_compare_exchange_ptr((void**)&pReader->pReadSnap, p, NULL)) && (p != NULL)) {





×








UNCOV

5709



    tsdbUntakeReadSnap2(pReader, p, true);




×








UNCOV

5710



    pReader->pReadSnap = NULL;




×







5711



  }










5712













UNCOV

5713



  (void) tsem_destroy(&pReader->resumeAfterSuspend);




×








UNCOV

5714



  (void) tsdbReleaseReader(pReader);




×








UNCOV

5715



  (void) tsdbUninitReaderLock(pReader);




×







5716













UNCOV

5717



  tsdbDebug(





×







5718



      "%p :io-cost summary: head-file:%" PRIu64 ", head-file time:%.2f ms, SMA:%" PRId64










5719



      " SMA-time:%.2f ms, fileBlocks:%" PRId64










5720



      ", fileBlocks-load-time:%.2f ms, "










5721



      "build in-memory-block-time:%.2f ms, sttBlocks:%" PRId64 ", sttBlocks-time:%.2f ms, sttStatisBlock:%" PRId64










5722



      ", stt-statis-Block-time:%.2f ms, composed-blocks:%" PRId64










5723



      ", composed-blocks-time:%.2fms, STableBlockScanInfo size:%.2f Kb, createTime:%.2f ms,createSkylineIterTime:%.2f "










5724



      "ms, initSttBlockReader:%.2fms, %s",










5725



      pReader, pCost->headFileLoad, pCost->headFileLoadTime, pCost->smaDataLoad, pCost->smaLoadTime, pCost->numOfBlocks,










5726



      pCost->blockLoadTime, pCost->buildmemBlock, pCost->sttCost.loadBlocks, pCost->sttCost.blockElapsedTime,










5727



      pCost->sttCost.loadStatisBlocks, pCost->sttCost.statisElapsedTime, pCost->composedBlocks,










5728



      pCost->buildComposedBlockTime, numOfTables * sizeof(STableBlockScanInfo) / 1000.0, pCost->createScanInfoList,










5729



      pCost->createSkylineIterTime, pCost->initSttBlockReader, pReader->idStr);










5730













UNCOV

5731



  taosMemoryFree(pReader->idStr);





×







5732













UNCOV

5733



  tsdbRowMergerCleanup(&pReader->status.merger);




×








UNCOV

5734



  taosMemoryFree(pReader->info.pSchema);





×







5735













UNCOV

5736



  tSimpleHashCleanup(pReader->pSchemaMap);




×








UNCOV

5737



  taosMemoryFreeClear(pReader);





×







5738



}










5739












5740



static int32_t doSuspendCurrentReader(STsdbReader* pCurrentReader) {




×







5741



  int32_t               code = TSDB_CODE_SUCCESS;




×







5742



  int32_t               lino = 0;




×







5743



  SReaderStatus*        pStatus = NULL;




×







5744



  STableBlockScanInfo** p = NULL;




×







5745












5746



  TSDB_CHECK_NULL(pCurrentReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5747












5748



  pStatus = &pCurrentReader->status;




×







5749












5750



  if (pStatus->loadFromFile) {





×







5751



    tsdbDataFileReaderClose(&pCurrentReader->pFileReader);




×







5752












5753



    SReadCostSummary* pCost = &pCurrentReader->cost;




×







5754



    destroySttBlockReader(pStatus->pLDataIterArray, &pCost->sttCost);




×







5755



    pStatus->pLDataIterArray = taosArrayInit(4, POINTER_BYTES);




×







5756



    TSDB_CHECK_NULL(pStatus->pLDataIterArray, code, lino, _end, terrno);





×







5757



  }










5758












5759



  // resetDataBlockScanInfo excluding lastKey










5760



  int32_t step = ASCENDING_TRAVERSE(pCurrentReader->info.order) ? 1 : -1;





×







5761



  int32_t iter = 0;




×







5762



  while ((p = tSimpleHashIterate(pStatus->pTableMap, p, &iter)) != NULL) {





×







5763



    STableBlockScanInfo* pInfo = *(STableBlockScanInfo**)p;




×







5764



    clearBlockScanInfo(pInfo);




×







5765



    //    pInfo->sttKeyInfo.nextProcKey = pInfo->lastProcKey.ts + step;










5766



    //    pInfo->sttKeyInfo.nextProcKey = pInfo->lastProcKey + step;










5767



  }










5768












5769



  pStatus->uidList.currentIndex = 0;




×







5770



  initReaderStatus(pStatus);




×







5771












5772



_end:




×







5773



  if (code != TSDB_CODE_SUCCESS) {





×







5774



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





×







5775



  }










5776



  return code;




×







5777



}










5778












5779



int32_t tsdbReaderSuspend2(STsdbReader* pReader) {




×







5780



  int32_t code = TSDB_CODE_SUCCESS;




×







5781



  int32_t lino = 0;




×







5782












5783



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5784












5785



  // save reader's base state & reset top state to be reconstructed from base state










5786



  pReader->status.suspendInvoked = true;  // record the suspend status




×







5787












5788



  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {





×







5789



    if (pReader->step == EXTERNAL_ROWS_PREV) {





×







5790



      code = doSuspendCurrentReader(pReader->innerReader[0]);




×







5791



    } else if (pReader->step == EXTERNAL_ROWS_MAIN) {





×







5792



      code = doSuspendCurrentReader(pReader);




×







5793



    } else {










5794



      code = doSuspendCurrentReader(pReader->innerReader[1]);




×







5795



    }










5796



  } else {










5797



    code = doSuspendCurrentReader(pReader);




×







5798



  }










5799












5800



  // make sure only release once










5801



  void* p = pReader->pReadSnap;




×







5802



  if ((p == atomic_val_compare_exchange_ptr((void**)&pReader->pReadSnap, p, NULL)) && (p != NULL)) {





×







5803



    tsdbUntakeReadSnap2(pReader, p, false);




×







5804



    pReader->pReadSnap = NULL;




×







5805



  }










5806












5807



  if (pReader->bFilesetDelimited) {





×







5808



    pReader->status.memTableMinKey = INT64_MAX;




×







5809



    pReader->status.memTableMaxKey = INT64_MIN;




×







5810



  }










5811



  pReader->flag = READER_STATUS_SUSPEND;




×







5812












5813



  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {





×







5814



    clearSharedPtr(pReader->innerReader[0]);




×







5815



    clearSharedPtr(pReader->innerReader[1]);




×







5816



  }










5817












5818



#if SUSPEND_RESUME_TEST










5819



  tsem_post(&pReader->resumeAfterSuspend);










5820



#endif










5821












5822



  tsdbDebug("reader: %p suspended in this query %s, step:%d", pReader, pReader->idStr, pReader->step);





×







5823












5824



_end:




×







5825



  if (code != TSDB_CODE_SUCCESS) {





×







5826



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





×







5827



  }










5828



  return code;




×







5829



}










5830












5831



static int32_t tsdbSetQueryReseek(void* pQHandle) {




×







5832



  int32_t      code = 0;




×







5833



  STsdbReader* pReader = pQHandle;




×







5834












5835



  code = tsdbTryAcquireReader(pReader);




×







5836



  if (code == 0) {





×







5837



    if (pReader->flag == READER_STATUS_SUSPEND) {





×







5838



      code = tsdbReleaseReader(pReader);




×







5839



      return code;




×







5840



    }










5841












5842



    code = tsdbReaderSuspend2(pReader);




×







5843



    (void)tsdbReleaseReader(pReader);




×







5844



    return code;




×







5845



  } else if (code == EBUSY) {





×







5846



    return TSDB_CODE_VND_QUERY_BUSY;




×







5847



  } else {










5848



    terrno = TAOS_SYSTEM_ERROR(code);




×







5849



    return TSDB_CODE_FAILED;




×







5850



  }










5851



}










5852













UNCOV

5853



int32_t tsdbReaderResume2(STsdbReader* pReader) {




×








UNCOV

5854



  int32_t               code = TSDB_CODE_SUCCESS;




×








UNCOV

5855



  int32_t               lino = 0;




×








UNCOV

5856



  STableBlockScanInfo** pBlockScanInfo = NULL;




×








UNCOV

5857



  int32_t               numOfTables = 0;




×







5858













UNCOV

5859



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5860













UNCOV

5861



  pBlockScanInfo = pReader->status.pTableIter;




×







5862












5863



  //  restore reader's state, task snapshot











UNCOV

5864



  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);




×








UNCOV

5865



  if (numOfTables > 0) {





×








UNCOV

5866



    tsdbTrace("tsdb/reader: %p, take snapshot", pReader);





×








UNCOV

5867



    code = tsdbTakeReadSnap2(pReader, tsdbSetQueryReseek, &pReader->pReadSnap, pReader->idStr);




×








UNCOV

5868



    TSDB_CHECK_CODE(code, lino, _end);





×







5869












5870



    // open reader failure may cause the flag still to be READER_STATUS_SUSPEND, which may cause suspend reader failure.










5871



    // So we need to set it A.S.A.P











UNCOV

5872



    pReader->flag = READER_STATUS_NORMAL;




×







5873













UNCOV

5874



    if (pReader->type == TIMEWINDOW_RANGE_CONTAINED) {





×








UNCOV

5875



      code = doOpenReaderImpl(pReader);




×








UNCOV

5876



      TSDB_CHECK_CODE(code, lino, _end);





×







5877



    } else {











UNCOV

5878



      STsdbReader* pPrevReader = pReader->innerReader[0];




×








UNCOV

5879



      STsdbReader* pNextReader = pReader->innerReader[1];




×







5880












5881



      // we need only one row











UNCOV

5882



      pPrevReader->resBlockInfo.capacity = 1;




×








UNCOV

5883



      code = setSharedPtr(pPrevReader, pReader);




×








UNCOV

5884



      TSDB_CHECK_CODE(code, lino, _end);





×







5885













UNCOV

5886



      pNextReader->resBlockInfo.capacity = 1;




×








UNCOV

5887



      code = setSharedPtr(pNextReader, pReader);




×








UNCOV

5888



      TSDB_CHECK_CODE(code, lino, _end);





×







5889













UNCOV

5890



      if (pReader->step == 0 || pReader->step == EXTERNAL_ROWS_PREV) {





×








UNCOV

5891



        code = doOpenReaderImpl(pPrevReader);




×








UNCOV

5892



        TSDB_CHECK_CODE(code, lino, _end);





×







5893



      } else if (pReader->step == EXTERNAL_ROWS_MAIN) {





×







5894



        code = doOpenReaderImpl(pReader);




×







5895



        TSDB_CHECK_CODE(code, lino, _end);





×







5896



      } else {










5897



        code = doOpenReaderImpl(pNextReader);




×







5898



        TSDB_CHECK_CODE(code, lino, _end);





×







5899



      }










5900



    }










5901



  }










5902













UNCOV

5903



  tsdbDebug("reader: %p resumed uid %" PRIu64 ", numOfTable:%" PRId32 ", in this query %s", pReader,





×







5904



            pBlockScanInfo ? (*pBlockScanInfo)->uid : 0, numOfTables, pReader->idStr);










5905













UNCOV

5906



_end:




×








UNCOV

5907



  if (code != TSDB_CODE_SUCCESS) {





×







5908



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





×







5909



              (pReader && pReader->idStr) ? pReader->idStr : "");










5910



  }











UNCOV

5911



  return code;




×







5912



}










5913













UNCOV

5914



static int32_t buildFromPreFilesetBuffer(STsdbReader* pReader) {




×








UNCOV

5915



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

5916



  int32_t        lino = 0;




×








UNCOV

5917



  SReaderStatus* pStatus = NULL;




×








UNCOV

5918



  SSDataBlock*   pBlock = NULL;




×








UNCOV

5919



  int32_t        fid = 0;




×








UNCOV

5920



  STimeWindow    win = {0};




×







5921













UNCOV

5922



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5923













UNCOV

5924



  pStatus = &pReader->status;




×








UNCOV

5925



  pBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

5926



  fid = pReader->status.pCurrentFileset->fid;




×








UNCOV

5927



  tsdbFidKeyRange(fid, pReader->pTsdb->keepCfg.days, pReader->pTsdb->keepCfg.precision, &win.skey, &win.ekey);




×







5928













UNCOV

5929



  int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? win.skey : win.ekey;





×








UNCOV

5930



  code = buildBlockFromBufferSeqForPreFileset(pReader, endKey);




×








UNCOV

5931



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5932



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





×








UNCOV

5933



    tsdbDebug("finished pre-fileset %d buffer processing. %s", fid, pReader->idStr);





×








UNCOV

5934



    pStatus->bProcMemPreFileset = false;




×








UNCOV

5935



    pStatus->processingMemPreFileSet = false;




×








UNCOV

5936



    if (pReader->notifyFn) {





×








UNCOV

5937



      STsdReaderNotifyInfo info = {0};




×








UNCOV

5938



      info.duration.filesetId = fid;




×








UNCOV

5939



      pReader->notifyFn(TSD_READER_NOTIFY_DURATION_START, &info, pReader->notifyParam);




×








UNCOV

5940



      tsdbDebug("new duration %d start notification when buffer pre-fileset, %s", fid, pReader->idStr);





×







5941



    }










5942



  }










5943













UNCOV

5944



_end:




×








UNCOV

5945



  if (code != TSDB_CODE_SUCCESS) {





×







5946



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





×







5947



  }











UNCOV

5948



  return code;




×







5949



}










5950













UNCOV

5951



static int32_t doTsdbNextDataBlockFilesetDelimited(STsdbReader* pReader) {




×








UNCOV

5952



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

5953



  int32_t        lino = 0;




×








UNCOV

5954



  SReaderStatus* pStatus = NULL;




×








UNCOV

5955



  SSDataBlock*   pBlock = NULL;




×







5956













UNCOV

5957



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5958













UNCOV

5959



  pStatus = &pReader->status;




×








UNCOV

5960



  pBlock = pReader->resBlockInfo.pResBlock;




×







5961













UNCOV

5962



  if (pStatus->loadFromFile) {





×








UNCOV

5963



    if (pStatus->bProcMemPreFileset) {





×








UNCOV

5964



      code = buildFromPreFilesetBuffer(pReader);




×








UNCOV

5965



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5966



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





×








UNCOV

5967



        goto _end;




×







5968



      }










5969



    }










5970













UNCOV

5971



    code = buildBlockFromFiles(pReader);




×








UNCOV

5972



    TSDB_CHECK_CODE(code, lino, _end);





×







5973













UNCOV

5974



    tsdbTrace("block from file rows: %" PRId64 ", will process pre-file set buffer: %d. %s", pBlock->info.rows,





×







5975



              pStatus->bProcMemFirstFileset, pReader->idStr);











UNCOV

5976



    if (pStatus->bProcMemPreFileset) {





×








UNCOV

5977



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





×








UNCOV

5978



        if (pReader->notifyFn && !pReader->status.processingMemPreFileSet) {





×







5979



          int32_t              fid = pReader->status.pCurrentFileset->fid;




×







5980



          STsdReaderNotifyInfo info = {0};




×







5981



          info.duration.filesetId = fid;




×







5982



          pReader->notifyFn(TSD_READER_NOTIFY_NEXT_DURATION_BLOCK, &info, pReader->notifyParam);




×







5983



        }










5984



      } else {










5985



        pStatus->bProcMemPreFileset = false;




×







5986



      }










5987



    }










5988













UNCOV

5989



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





×








UNCOV

5990



      code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

5991



      TSDB_CHECK_CODE(code, lino, _end);





×







5992













UNCOV

5993



      int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;





×








UNCOV

5994



      code = buildBlockFromBufferSequentially(pReader, endKey);




×








UNCOV

5995



      TSDB_CHECK_CODE(code, lino, _end);





×







5996



    }










5997



  } else {  // no data in files, let's try the buffer











UNCOV

5998



    int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;





×








UNCOV

5999



    code = buildBlockFromBufferSequentially(pReader, endKey);




×








UNCOV

6000



    TSDB_CHECK_CODE(code, lino, _end);





×







6001



  }










6002













UNCOV

6003



_end:




×








UNCOV

6004



  if (code != TSDB_CODE_SUCCESS) {





×







6005



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





×







6006



  }











UNCOV

6007



  return code;




×







6008



}










6009













UNCOV

6010



static int32_t doTsdbNextDataBlockFilesFirst(STsdbReader* pReader) {




×








UNCOV

6011



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

6012



  int32_t        lino = 0;




×








UNCOV

6013



  SReaderStatus* pStatus = NULL;




×








UNCOV

6014



  SSDataBlock*   pBlock = NULL;




×







6015













UNCOV

6016



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6017













UNCOV

6018



  pStatus = &pReader->status;




×








UNCOV

6019



  pBlock = pReader->resBlockInfo.pResBlock;




×







6020













UNCOV

6021



  if (pStatus->loadFromFile) {





×








UNCOV

6022



    code = buildBlockFromFiles(pReader);




×








UNCOV

6023



    TSDB_CHECK_CODE(code, lino, _end);





×







6024













UNCOV

6025



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





×








UNCOV

6026



      code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

6027



      TSDB_CHECK_CODE(code, lino, _end);





×







6028













UNCOV

6029



      int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;





×








UNCOV

6030



      code = buildBlockFromBufferSequentially(pReader, endKey);




×








UNCOV

6031



      TSDB_CHECK_CODE(code, lino, _end);





×







6032



    }










6033



  } else {  // no data in files, let's try the buffer











UNCOV

6034



    int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;





×








UNCOV

6035



    code = buildBlockFromBufferSequentially(pReader, endKey);




×








UNCOV

6036



    TSDB_CHECK_CODE(code, lino, _end);





×







6037



  }










6038













UNCOV

6039



_end:




×








UNCOV

6040



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

6041



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





×







6042



  }











UNCOV

6043



  return code;




×







6044



}










6045













UNCOV

6046



static int32_t doTsdbNextDataBlock2(STsdbReader* pReader, bool* hasNext) {




×








UNCOV

6047



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

6048



  int32_t      lino = 0;




×








UNCOV

6049



  SSDataBlock* pBlock = NULL;




×







6050













UNCOV

6051



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6052












6053



  // cleanup the data that belongs to the previous data block











UNCOV

6054



  pBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

6055



  blockDataCleanup(pBlock);




×







6056













UNCOV

6057



  *hasNext = false;




×







6058













UNCOV

6059



  SReaderStatus* pStatus = &pReader->status;




×








UNCOV

6060



  if (tSimpleHashGetSize(pStatus->pTableMap) == 0) {





×








UNCOV

6061



    goto _end;




×







6062



  }










6063













UNCOV

6064



  if (!pReader->bFilesetDelimited) {





×








UNCOV

6065



    code = doTsdbNextDataBlockFilesFirst(pReader);




×







6066



  } else {











UNCOV

6067



    code = doTsdbNextDataBlockFilesetDelimited(pReader);




×







6068



  }










6069













UNCOV

6070



  *hasNext = pBlock->info.rows > 0;




×








UNCOV

6071



  TSDB_CHECK_CODE(code, lino, _end);





×







6072













UNCOV

6073



_end:




×








UNCOV

6074



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

6075



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





×







6076



  }











UNCOV

6077



  return code;




×







6078



}










6079













UNCOV

6080



int32_t tsdbNextDataBlock2(STsdbReader* pReader, bool* hasNext) {




×








UNCOV

6081



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

6082



  int32_t        lino = 0;




×








UNCOV

6083



  SReaderStatus* pStatus = NULL;




×








UNCOV

6084



  bool           acquired = false;




×







6085













UNCOV

6086



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6087



  TSDB_CHECK_NULL(hasNext, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6088













UNCOV

6089



  *hasNext = false;




×







6090













UNCOV

6091



  code = pReader->code;




×








UNCOV

6092



  TSDB_CHECK_CODE(code, lino, _end);





×







6093













UNCOV

6094



  if (isEmptyQueryTimeWindow(&pReader->info.window) || pReader->step == EXTERNAL_ROWS_NEXT) {





×








UNCOV

6095



    goto _end;




×







6096



  }










6097













UNCOV

6098



  pStatus = &pReader->status;




×







6099












6100



  // NOTE: the following codes is used to perform test for suspend/resume for tsdbReader when it blocks the commit










6101



  // the data should be ingested in round-robin and all the child tables should be createted before ingesting data










6102



  // the version range of query will be used to identify the correctness of suspend/resume functions.










6103



  // this function will be blocked before loading the SECOND block from vnode-buffer, and restart itself from sst-files










6104



#if SUSPEND_RESUME_TEST










6105



  if (!pReader->status.suspendInvoked && !pReader->status.loadFromFile) {










6106



    tsem_wait(&pReader->resumeAfterSuspend);










6107



  }










6108



#endif










6109













UNCOV

6110



  code = tsdbAcquireReader(pReader);




×








UNCOV

6111



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6112



  acquired = true;




×







6113













UNCOV

6114



  tsdbTrace("tsdb/read: %p, take read mutex, code: %d", pReader, code);





×







6115













UNCOV

6116



  if (pReader->flag == READER_STATUS_SUSPEND) {





×








UNCOV

6117



    code = tsdbReaderResume2(pReader);




×








UNCOV

6118



    TSDB_CHECK_CODE(code, lino, _end);





×







6119



  }










6120













UNCOV

6121



  if (pReader->innerReader[0] != NULL && pReader->step == 0) {





×








UNCOV

6122



    code = doTsdbNextDataBlock2(pReader->innerReader[0], hasNext);




×








UNCOV

6123



    TSDB_CHECK_CODE(code, lino, _end);





×







6124













UNCOV

6125



    pReader->step = EXTERNAL_ROWS_PREV;




×








UNCOV

6126



    if (*hasNext) {





×








UNCOV

6127



      pStatus = &pReader->innerReader[0]->status;




×








UNCOV

6128



      if (pStatus->composedDataBlock) {





×








UNCOV

6129



        tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6130



        code = tsdbReleaseReader(pReader);




×








UNCOV

6131



        acquired = false;




×








UNCOV

6132



        TSDB_CHECK_CODE(code, lino, _end);





×







6133



      }










6134













UNCOV

6135



      return code;




×







6136



    }










6137



  }










6138













UNCOV

6139



  if (pReader->step == EXTERNAL_ROWS_PREV) {





×







6140



    // prepare for the main scan











UNCOV

6141



    if (tSimpleHashGetSize(pReader->status.pTableMap) > 0) {





×








UNCOV

6142



      code = doOpenReaderImpl(pReader);




×







6143



    }










6144













UNCOV

6145



    int32_t step = 1;




×








UNCOV

6146



    resetAllDataBlockScanInfo(pReader->status.pTableMap, pReader->innerReader[0]->info.window.ekey, step);




×








UNCOV

6147



    TSDB_CHECK_CODE(code, lino, _end);





×







6148













UNCOV

6149



    pReader->step = EXTERNAL_ROWS_MAIN;




×







6150



  }










6151













UNCOV

6152



  code = doTsdbNextDataBlock2(pReader, hasNext);




×








UNCOV

6153



  TSDB_CHECK_CODE(code, lino, _end);





×







6154













UNCOV

6155



  if (*hasNext) {





×








UNCOV

6156



    if (pStatus->composedDataBlock) {





×








UNCOV

6157



      tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6158



      code = tsdbReleaseReader(pReader);




×








UNCOV

6159



      acquired = false;




×








UNCOV

6160



      TSDB_CHECK_CODE(code, lino, _end);





×







6161



    }











UNCOV

6162



    return code;




×







6163



  }










6164













UNCOV

6165



  if (pReader->step == EXTERNAL_ROWS_MAIN && pReader->innerReader[1] != NULL) {





×







6166



    // prepare for the next row scan











UNCOV

6167



    if (tSimpleHashGetSize(pReader->status.pTableMap) > 0) {





×








UNCOV

6168



      code = doOpenReaderImpl(pReader->innerReader[1]);




×







6169



    }










6170













UNCOV

6171



    int32_t step = -1;




×








UNCOV

6172



    resetAllDataBlockScanInfo(pReader->innerReader[1]->status.pTableMap, pReader->info.window.ekey, step);




×








UNCOV

6173



    TSDB_CHECK_CODE(code, lino, _end);





×







6174













UNCOV

6175



    code = doTsdbNextDataBlock2(pReader->innerReader[1], hasNext);




×








UNCOV

6176



    TSDB_CHECK_CODE(code, lino, _end);





×







6177













UNCOV

6178



    pReader->step = EXTERNAL_ROWS_NEXT;




×








UNCOV

6179



    if (*hasNext) {





×








UNCOV

6180



      pStatus = &pReader->innerReader[1]->status;




×








UNCOV

6181



      if (pStatus->composedDataBlock) {





×








UNCOV

6182



        tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6183



        code = tsdbReleaseReader(pReader);




×








UNCOV

6184



        acquired = false;




×








UNCOV

6185



        TSDB_CHECK_CODE(code, lino, _end);





×







6186



      }










6187













UNCOV

6188



      return code;




×







6189



    }










6190



  }










6191













UNCOV

6192



  tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6193



  code = tsdbReleaseReader(pReader);




×








UNCOV

6194



  acquired = false;




×








UNCOV

6195



  TSDB_CHECK_CODE(code, lino, _end);





×







6196













UNCOV

6197



_end:




×








UNCOV

6198



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

6199



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





×







6200



  }











UNCOV

6201



  if (acquired) {





×








UNCOV

6202



    tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6203



    (void)tsdbReleaseReader(pReader);




×







6204



  }











UNCOV

6205



  return code;




×







6206



}










6207













UNCOV

6208



static int32_t doFillNullColSMA(SBlockLoadSuppInfo* pSup, int32_t numOfRows, int32_t numOfCols,




×







6209



                                SColumnDataAgg* pTsAgg) {










6210



  // do fill all null column value SMA info











UNCOV

6211



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

6212



  int32_t lino = 0;




×








UNCOV

6213



  int32_t i = 0, j = 0;




×








UNCOV

6214



  int32_t size = 0;




×







6215













UNCOV

6216



  TSDB_CHECK_NULL(pSup, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6217













UNCOV

6218



  size = (int32_t)TARRAY2_SIZE(&pSup->colAggArray);




×








UNCOV

6219



  code = TARRAY2_INSERT_PTR(&pSup->colAggArray, 0, pTsAgg);





×








UNCOV

6220



  TSDB_CHECK_CODE(code, lino, _end);





×







6221













UNCOV

6222



  size++;




×







6223













UNCOV

6224



  while (j < numOfCols && i < size) {





×








UNCOV

6225



    SColumnDataAgg* pAgg = &pSup->colAggArray.data[i];




×








UNCOV

6226



    if (pAgg->colId == pSup->colId[j]) {





×








UNCOV

6227



      i += 1;




×








UNCOV

6228



      j += 1;




×








UNCOV

6229



    } else if (pAgg->colId < pSup->colId[j]) {





×








UNCOV

6230



      i += 1;




×







6231



    } else if (pSup->colId[j] < pAgg->colId) {





×







6232



      if (pSup->colId[j] != PRIMARYKEY_TIMESTAMP_COL_ID) {





×







6233



        SColumnDataAgg nullColAgg = {.colId = pSup->colId[j], .numOfNull = numOfRows};




×







6234



        code = TARRAY2_INSERT_PTR(&pSup->colAggArray, i, &nullColAgg);





×







6235



        TSDB_CHECK_CODE(code, lino, _end);





×







6236












6237



        i += 1;




×







6238



        size++;




×







6239



      }










6240



      j += 1;




×







6241



    }










6242



  }










6243













UNCOV

6244



  while (j < numOfCols) {





×








UNCOV

6245



    if (pSup->colId[j] != PRIMARYKEY_TIMESTAMP_COL_ID) {





×








UNCOV

6246



      SColumnDataAgg nullColAgg = {.colId = pSup->colId[j], .numOfNull = numOfRows};




×








UNCOV

6247



      code = TARRAY2_INSERT_PTR(&pSup->colAggArray, i, &nullColAgg);





×








UNCOV

6248



      TSDB_CHECK_CODE(code, lino, _end);





×







6249













UNCOV

6250



      i += 1;




×







6251



    }











UNCOV

6252



    j++;




×







6253



  }










6254













UNCOV

6255



_end:




×








UNCOV

6256



  if (code != TSDB_CODE_SUCCESS) {





×







6257



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





×







6258



  }











UNCOV

6259



  return code;




×







6260



}










6261













UNCOV

6262



int32_t tsdbRetrieveDatablockSMA2(STsdbReader* pReader, SSDataBlock* pDataBlock, bool* allHave, bool* hasNullSMA) {




×








UNCOV

6263



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

6264



  int32_t             lino = 0;




×








UNCOV

6265



  SColumnDataAgg**    pBlockSMA = NULL;




×








UNCOV

6266



  SFileDataBlockInfo* pBlockInfo = NULL;




×







6267













UNCOV

6268



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6269



  TSDB_CHECK_NULL(pDataBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6270



  TSDB_CHECK_NULL(allHave, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6271













UNCOV

6272



  pBlockSMA = &pDataBlock->pBlockAgg;




×








UNCOV

6273



  *allHave = false;




×








UNCOV

6274



  *pBlockSMA = NULL;




×







6275













UNCOV

6276



  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {





×








UNCOV

6277



    goto _end;




×







6278



  }










6279












6280



  // there is no statistics data for composed block











UNCOV

6281



  if (pReader->status.composedDataBlock || (!pReader->suppInfo.smaValid)) {





×








UNCOV

6282



    goto _end;




×







6283



  }










6284













UNCOV

6285



  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

6286



  TSDB_CHECK_CODE(code, lino, _end);





×







6287













UNCOV

6288



  SBlockLoadSuppInfo* pSup = &pReader->suppInfo;




×







6289













UNCOV

6290



  SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

6291



  if (pResBlock->info.id.uid != pBlockInfo->uid) {





×







6292



    goto _end;




×







6293



  }










6294












6295



  //  int64_t st = taosGetTimestampUs();











UNCOV

6296



  TARRAY2_CLEAR(&pSup->colAggArray, 0);




×







6297












6298



  SBrinRecord pRecord;











UNCOV

6299



  blockInfoToRecord(&pRecord, pBlockInfo, pSup);




×








UNCOV

6300



  code = tsdbDataFileReadBlockSma(pReader->pFileReader, &pRecord, &pSup->colAggArray);




×








UNCOV

6301



  if (code != TSDB_CODE_SUCCESS) {





×







6302



    tsdbDebug("vgId:%d, failed to load block SMA for uid %" PRIu64 ", code:%s, %s", 0, pBlockInfo->uid, tstrerror(code),





×







6303



              pReader->idStr);










6304



    TSDB_CHECK_CODE(code, lino, _end);





×







6305



  }










6306













UNCOV

6307



  if (pSup->colAggArray.size > 0) {





×








UNCOV

6308



    *allHave = true;




×







6309



  } else {










6310



    *pBlockSMA = NULL;




×







6311



    goto _end;




×







6312



  }










6313












6314



  // always load the first primary timestamp column data











UNCOV

6315



  SColumnDataAgg* pTsAgg = &pSup->tsColAgg;




×







6316













UNCOV

6317



  pTsAgg->numOfNull = 0;




×








UNCOV

6318



  pTsAgg->colId = PRIMARYKEY_TIMESTAMP_COL_ID;




×








UNCOV

6319



  pTsAgg->min = pResBlock->info.window.skey;




×








UNCOV

6320



  pTsAgg->max = pResBlock->info.window.ekey;




×







6321












6322



  // update the number of NULL data rows











UNCOV

6323



  size_t numOfCols = pSup->numOfCols;




×







6324













UNCOV

6325



  if (pResBlock->pBlockAgg == NULL) {





×








UNCOV

6326



    size_t num = taosArrayGetSize(pResBlock->pDataBlock);




×








UNCOV

6327



    pResBlock->pBlockAgg = taosMemoryCalloc(num, sizeof(SColumnDataAgg));





×








UNCOV

6328



    TSDB_CHECK_NULL(pResBlock->pBlockAgg, code, lino, _end, terrno);





×








UNCOV

6329



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





×








UNCOV

6330



      pResBlock->pBlockAgg[i].colId = -1;




×







6331



    }










6332



  }










6333












6334



  // do fill all null column value SMA info











UNCOV

6335



  code = doFillNullColSMA(pSup, pBlockInfo->numRow, numOfCols, pTsAgg);




×








UNCOV

6336



  TSDB_CHECK_CODE(code, lino, _end);





×







6337













UNCOV

6338



  size_t size = pSup->colAggArray.size;




×







6339













UNCOV

6340



  int32_t i = 0, j = 0;




×








UNCOV

6341



  while (j < numOfCols && i < size) {





×








UNCOV

6342



    SColumnDataAgg* pAgg = &pSup->colAggArray.data[i];




×








UNCOV

6343



    if (pAgg->colId == pSup->colId[j]) {





×








UNCOV

6344



      pResBlock->pBlockAgg[pSup->slotId[j]] = *pAgg;




×








UNCOV

6345



      i += 1;




×








UNCOV

6346



      j += 1;




×








UNCOV

6347



    } else if (pAgg->colId < pSup->colId[j]) {





×








UNCOV

6348



      i += 1;




×







6349



    } else if (pSup->colId[j] < pAgg->colId) {





×







6350



      pResBlock->pBlockAgg[pSup->slotId[j]].colId = -1;




×







6351



      *allHave = false;




×







6352



      j += 1;




×







6353



    }










6354



  }










6355













UNCOV

6356



  *pBlockSMA = pResBlock->pBlockAgg;




×








UNCOV

6357



  pReader->cost.smaDataLoad += 1;




×







6358












6359



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











UNCOV

6360



  pReader->cost.smaLoadTime += 0;  // elapsedTime;




×







6361













UNCOV

6362



  tsdbDebug("vgId:%d, succeed to load block SMA for uid %" PRIu64 ", %s", 0, pBlockInfo->uid, pReader->idStr);





×







6363













UNCOV

6364



_end:




×








UNCOV

6365



  if (code != TSDB_CODE_SUCCESS) {





×







6366



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





×







6367



  }











UNCOV

6368



  return code;




×







6369



}










6370













UNCOV

6371



static int32_t doRetrieveDataBlock(STsdbReader* pReader, SSDataBlock** pBlock) {




×








UNCOV

6372



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

6373



  int32_t              lino = 0;




×








UNCOV

6374



  SReaderStatus*       pStatus = NULL;




×








UNCOV

6375



  SFileDataBlockInfo*  pBlockInfo = NULL;




×








UNCOV

6376



  STableBlockScanInfo* pBlockScanInfo = NULL;




×








UNCOV

6377



  bool                 reset = false;




×







6378













UNCOV

6379



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6380



  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6381













UNCOV

6382



  pStatus = &pReader->status;




×








UNCOV

6383



  *pBlock = NULL;




×







6384













UNCOV

6385



  code = getCurrentBlockInfo(&pStatus->blockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

6386



  TSDB_CHECK_CODE(code, lino, _end);





×







6387













UNCOV

6388



  code = pReader->code;




×








UNCOV

6389



  TSDB_CHECK_CODE(code, lino, _end);





×







6390













UNCOV

6391



  code = getTableBlockScanInfo(pStatus->pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);




×








UNCOV

6392



  TSDB_CHECK_CODE(code, lino, _end);





×







6393













UNCOV

6394



  reset = true;




×








UNCOV

6395



  code = doLoadFileBlockData(pReader, &pStatus->blockIter, &pStatus->fileBlockData, pBlockScanInfo->uid);




×








UNCOV

6396



  TSDB_CHECK_CODE(code, lino, _end);





×







6397













UNCOV

6398



  code = copyBlockDataToSDataBlock(pReader, &pBlockScanInfo->lastProcKey);




×








UNCOV

6399



  TSDB_CHECK_CODE(code, lino, _end);





×







6400













UNCOV

6401



  *pBlock = pReader->resBlockInfo.pResBlock;




×







6402













UNCOV

6403



_end:




×








UNCOV

6404



  if (code != TSDB_CODE_SUCCESS) {





×







6405



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





×







6406



    if (reset) {





×







6407



      tBlockDataReset(&pStatus->fileBlockData);




×







6408



    }










6409



  }











UNCOV

6410



  return code;




×







6411



}










6412













UNCOV

6413



int32_t tsdbRetrieveDataBlock2(STsdbReader* pReader, SSDataBlock** pBlock, SArray* pIdList) {




×








UNCOV

6414



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

6415



  int32_t      lino = 0;




×








UNCOV

6416



  STsdbReader* pTReader = NULL;




×







6417













UNCOV

6418



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6419



  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6420













UNCOV

6421



  *pBlock = NULL;




×







6422













UNCOV

6423



  pTReader = pReader;




×








UNCOV

6424



  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {





×








UNCOV

6425



    if (pReader->step == EXTERNAL_ROWS_PREV) {





×








UNCOV

6426



      pTReader = pReader->innerReader[0];




×








UNCOV

6427



    } else if (pReader->step == EXTERNAL_ROWS_NEXT) {





×








UNCOV

6428



      pTReader = pReader->innerReader[1];




×







6429



    }










6430



  }










6431













UNCOV

6432



  SReaderStatus* pStatus = &pTReader->status;




×








UNCOV

6433



  if (pStatus->composedDataBlock || pReader->info.execMode == READER_EXEC_ROWS) {





×







6434



    //    tsdbReaderSuspend2(pReader);










6435



    //    tsdbReaderResume2(pReader);











UNCOV

6436



    *pBlock = pTReader->resBlockInfo.pResBlock;




×








UNCOV

6437



    goto _end;




×







6438



  }










6439













UNCOV

6440



  code = doRetrieveDataBlock(pTReader, pBlock);




×







6441













UNCOV

6442



  tsdbTrace("tsdb/read-retrieve: %p, unlock read mutex", pReader);





×








UNCOV

6443



  (void) tsdbReleaseReader(pReader);




×








UNCOV

6444



  TSDB_CHECK_CODE(code, lino, _end);





×







6445












6446



  //  tsdbReaderSuspend2(pReader);










6447



  //  tsdbReaderResume2(pReader);











UNCOV

6448



_end:




×








UNCOV

6449



  if (code != TSDB_CODE_SUCCESS) {





×







6450



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





×







6451



  }











UNCOV

6452



  return code;




×







6453



}










6454













UNCOV

6455



int32_t tsdbReaderReset2(STsdbReader* pReader, SQueryTableDataCond* pCond) {




×








UNCOV

6456



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

6457



  int32_t lino = 0;




×








UNCOV

6458



  bool    acquired = false;




×







6459













UNCOV

6460



  tsdbTrace("tsdb/reader-reset: %p, take read mutex", pReader);





×








UNCOV

6461



  code = tsdbAcquireReader(pReader);




×








UNCOV

6462



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6463



  acquired = true;




×







6464













UNCOV

6465



  if (pReader->flag == READER_STATUS_SUSPEND) {





×








UNCOV

6466



    code = tsdbReaderResume2(pReader);




×








UNCOV

6467



    TSDB_CHECK_CODE(code, lino, _end);





×







6468



  }










6469













UNCOV

6470



  if (isEmptyQueryTimeWindow(&pReader->info.window) || pReader->pReadSnap == NULL) {





×








UNCOV

6471



    tsdbDebug("tsdb reader reset return %p, %s", pReader->pReadSnap, pReader->idStr);





×








UNCOV

6472



    code = tsdbReleaseReader(pReader);




×








UNCOV

6473



    acquired = false;




×








UNCOV

6474



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6475



    goto _end;




×







6476



  }










6477













UNCOV

6478



  SReaderStatus*  pStatus = &pReader->status;




×








UNCOV

6479



  SDataBlockIter* pBlockIter = &pStatus->blockIter;




×







6480













UNCOV

6481



  TSDB_CHECK_NULL(pCond, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6482



  pReader->info.order = pCond->order;




×








UNCOV

6483



  pReader->type = TIMEWINDOW_RANGE_CONTAINED;




×








UNCOV

6484



  code = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows, &pReader->info.window);




×








UNCOV

6485



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6486



  pStatus->loadFromFile = true;




×








UNCOV

6487



  pStatus->pTableIter = NULL;




×







6488












6489



  // allocate buffer in order to load data blocks from file











UNCOV

6490



  memset(&pReader->suppInfo.tsColAgg, 0, sizeof(SColumnDataAgg));




×







6491













UNCOV

6492



  pReader->suppInfo.tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;




×








UNCOV

6493



  tsdbDataFileReaderClose(&pReader->pFileReader);




×







6494













UNCOV

6495



  int32_t numOfTables = tSimpleHashGetSize(pStatus->pTableMap);




×







6496













UNCOV

6497



  code = initFilesetIterator(&pStatus->fileIter, pReader->pReadSnap->pfSetArray, pReader);




×








UNCOV

6498



  TSDB_CHECK_CODE(code, lino, _end);





×







6499













UNCOV

6500



  code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), pReader->idStr);




×








UNCOV

6501



  TSDB_CHECK_CODE(code, lino, _end);





×







6502













UNCOV

6503



  code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

6504



  TSDB_CHECK_CODE(code, lino, _end);





×







6505













UNCOV

6506



  bool    asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

6507



  int32_t step = asc ? 1 : -1;





×








UNCOV

6508



  int64_t ts = 0;




×








UNCOV

6509



  if (asc) {





×








UNCOV

6510



    ts = (pReader->info.window.skey > INT64_MIN) ? pReader->info.window.skey - 1 : pReader->info.window.skey;





×







6511



  } else {











UNCOV

6512



    ts = (pReader->info.window.ekey < INT64_MAX) ? pReader->info.window.ekey + 1 : pReader->info.window.ekey;





×







6513



  }











UNCOV

6514



  resetAllDataBlockScanInfo(pStatus->pTableMap, ts, step);




×







6515












6516



  // no data in files, let's try buffer in memory











UNCOV

6517



  if (pStatus->fileIter.numOfFiles == 0) {





×








UNCOV

6518



    pStatus->loadFromFile = false;




×








UNCOV

6519



    code = resetTableListIndex(pStatus, pReader->idStr);




×








UNCOV

6520



    TSDB_CHECK_CODE(code, lino, _end);





×







6521



  } else {











UNCOV

6522



    code = initForFirstBlockInFile(pReader, pBlockIter);




×








UNCOV

6523



    if (code != TSDB_CODE_SUCCESS) {





×







6524



      tsdbError("%p reset reader failed, numOfTables:%d, query range:%" PRId64 " - %" PRId64 " in query %s", pReader,





×







6525



                numOfTables, pReader->info.window.skey, pReader->info.window.ekey, pReader->idStr);










6526



      TSDB_CHECK_CODE(code, lino, _end);





×







6527



    }










6528



  }










6529













UNCOV

6530



  tsdbDebug("%p reset reader, suid:%" PRIu64 ", numOfTables:%d, skey:%" PRId64 ", query range:%" PRId64 " - %" PRId64





×







6531



            " in query %s",










6532



            pReader, pReader->info.suid, numOfTables, pCond->twindows.skey, pReader->info.window.skey,










6533



            pReader->info.window.ekey, pReader->idStr);










6534













UNCOV

6535



  code = tsdbReleaseReader(pReader);




×








UNCOV

6536



  acquired = false;




×








UNCOV

6537



  TSDB_CHECK_CODE(code, lino, _end);





×







6538













UNCOV

6539



_end:




×








UNCOV

6540



  if (code != TSDB_CODE_SUCCESS) {





×







6541



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





×







6542



  }











UNCOV

6543



  if (acquired) {





×







6544



    (void)tsdbReleaseReader(pReader);




×







6545



  }











UNCOV

6546



  return code;




×







6547



}










6548













UNCOV

6549



static int32_t getBucketIndex(int32_t startRow, int32_t bucketRange, int32_t numOfRows, int32_t numOfBucket) {




×








UNCOV

6550



  if (numOfRows < startRow) {





×







6551



    return 0;




×







6552



  }











UNCOV

6553



  int32_t bucketIndex = ((numOfRows - startRow) / bucketRange);




×








UNCOV

6554



  if (bucketIndex == numOfBucket) {





×







6555



    bucketIndex -= 1;




×







6556



  }











UNCOV

6557



  return bucketIndex;




×







6558



}










6559













UNCOV

6560



int32_t tsdbGetFileBlocksDistInfo2(STsdbReader* pReader, STableBlockDistInfo* pTableBlockInfo) {




×








UNCOV

6561



  int32_t       code = TSDB_CODE_SUCCESS;




×








UNCOV

6562



  int32_t       lino = 0;




×








UNCOV

6563



  const int32_t numOfBuckets = 20.0;




×








UNCOV

6564



  bool          acquired = false;




×







6565













UNCOV

6566



  TSDB_CHECK_NULL(pTableBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6567













UNCOV

6568



  pTableBlockInfo->totalSize = 0;




×








UNCOV

6569



  pTableBlockInfo->totalRows = 0;




×








UNCOV

6570



  pTableBlockInfo->numOfVgroups = 1;




×







6571












6572



  // find the start data block in file











UNCOV

6573



  code = tsdbAcquireReader(pReader);




×








UNCOV

6574



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6575



  acquired = true;




×







6576













UNCOV

6577



  if (pReader->flag == READER_STATUS_SUSPEND) {





×








UNCOV

6578



    code = tsdbReaderResume2(pReader);




×








UNCOV

6579



    TSDB_CHECK_CODE(code, lino, _end);





×







6580



  }










6581













UNCOV

6582



  SMergeTreeConf conf = {




×







6583



      .pReader = pReader,











UNCOV

6584



      .pSchema = pReader->info.pSchema,




×








UNCOV

6585



      .pCols = pReader->suppInfo.colId,




×








UNCOV

6586



      .numOfCols = pReader->suppInfo.numOfCols,




×








UNCOV

6587



      .suid = pReader->info.suid,




×







6588



  };










6589













UNCOV

6590



  SReaderStatus* pStatus = &pReader->status;




×








UNCOV

6591



  if (pStatus->pCurrentFileset != NULL) {





×








UNCOV

6592



    pTableBlockInfo->numOfSttRows += tsdbGetRowsInSttFiles(pStatus->pCurrentFileset, pStatus->pLDataIterArray,




×








UNCOV

6593



                                                           pReader->pTsdb, &conf, pReader->idStr);




×







6594



  }










6595













UNCOV

6596



  STsdbCfg* pc = &pReader->pTsdb->pVnode->config.tsdbCfg;




×








UNCOV

6597



  pTableBlockInfo->defMinRows = pc->minRows;




×








UNCOV

6598



  pTableBlockInfo->defMaxRows = pc->maxRows;




×







6599













UNCOV

6600



  int32_t bucketRange = ceil(((double)(pc->maxRows - pc->minRows)) / numOfBuckets);




×







6601













UNCOV

6602



  pTableBlockInfo->numOfFiles += 1;




×







6603













UNCOV

6604



  int32_t numOfTables = (int32_t)tSimpleHashGetSize(pStatus->pTableMap);




×







6605













UNCOV

6606



  SDataBlockIter* pBlockIter = &pStatus->blockIter;




×








UNCOV

6607



  pTableBlockInfo->numOfFiles += pStatus->fileIter.numOfFiles;




×







6608













UNCOV

6609



  if (pBlockIter->numOfBlocks > 0) {





×








UNCOV

6610



    pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;




×







6611



  }










6612













UNCOV

6613



  pTableBlockInfo->numOfTables = numOfTables;




×








UNCOV

6614



  bool hasNext = (pBlockIter->numOfBlocks > 0);




×







6615












6616



  while (true) {











UNCOV

6617



    if (hasNext) {





×








UNCOV

6618



      SFileDataBlockInfo* pBlockInfo = NULL;




×








UNCOV

6619



      code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

6620



      TSDB_CHECK_CODE(code, lino, _end);





×







6621













UNCOV

6622



      int32_t numOfRows = pBlockInfo->numRow;




×







6623













UNCOV

6624



      pTableBlockInfo->totalRows += numOfRows;




×







6625













UNCOV

6626



      if (numOfRows > pTableBlockInfo->maxRows) {





×








UNCOV

6627



        pTableBlockInfo->maxRows = numOfRows;




×







6628



      }










6629













UNCOV

6630



      if (numOfRows < pTableBlockInfo->minRows) {





×








UNCOV

6631



        pTableBlockInfo->minRows = numOfRows;




×







6632



      }










6633













UNCOV

6634



      pTableBlockInfo->totalSize += pBlockInfo->blockSize;




×







6635













UNCOV

6636



      int32_t bucketIndex = getBucketIndex(pTableBlockInfo->defMinRows, bucketRange, numOfRows, numOfBuckets);




×








UNCOV

6637



      pTableBlockInfo->blockRowsHisto[bucketIndex]++;




×







6638













UNCOV

6639



      hasNext = blockIteratorNext(&pStatus->blockIter);




×







6640



    } else {











UNCOV

6641



      code = initForFirstBlockInFile(pReader, pBlockIter);




×








UNCOV

6642



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6643



      if (pStatus->loadFromFile == false) {





×








UNCOV

6644



        break;




×







6645



      }










6646












6647



      // add the data in stt files of new fileset











UNCOV

6648



      if (pStatus->pCurrentFileset != NULL) {





×








UNCOV

6649



        pTableBlockInfo->numOfSttRows += tsdbGetRowsInSttFiles(pStatus->pCurrentFileset, pStatus->pLDataIterArray,




×








UNCOV

6650



                                                               pReader->pTsdb, &conf, pReader->idStr);




×







6651



      }










6652













UNCOV

6653



      pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;




×








UNCOV

6654



      hasNext = (pBlockIter->numOfBlocks > 0);




×







6655



    }










6656



  }










6657












6658



  // record the data in stt files











UNCOV

6659



_end:




×








UNCOV

6660



  if (code != TSDB_CODE_SUCCESS) {





×







6661



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





×







6662



  }











UNCOV

6663



  if (acquired) {





×








UNCOV

6664



    (void)tsdbReleaseReader(pReader);




×







6665



  }











UNCOV

6666



  return code;




×







6667



}










6668













UNCOV

6669



static void getMemTableTimeRange(STsdbReader* pReader, int64_t* pMaxKey, int64_t* pMinKey) {




×








UNCOV

6670



  SReaderStatus* pStatus = &pReader->status;




×







6671













UNCOV

6672



  int32_t iter = 0;




×








UNCOV

6673



  int64_t maxKey = INT64_MIN;




×








UNCOV

6674



  int64_t minKey = INT64_MAX;




×







6675













UNCOV

6676



  void* pHashIter = tSimpleHashIterate(pStatus->pTableMap, NULL, &iter);




×








UNCOV

6677



  while (pHashIter != NULL) {





×








UNCOV

6678



    STableBlockScanInfo* pBlockScanInfo = *(STableBlockScanInfo**)pHashIter;




×







6679













UNCOV

6680



    STbData* d = NULL;




×








UNCOV

6681



    if (pReader->pReadSnap->pMem != NULL) {





×








UNCOV

6682



      d = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pMem, pReader->info.suid, pBlockScanInfo->uid);




×








UNCOV

6683



      if (d != NULL) {





×








UNCOV

6684



        if (d->maxKey > maxKey) {





×








UNCOV

6685



          maxKey = d->maxKey;




×







6686



        }











UNCOV

6687



        if (d->minKey < minKey) {





×








UNCOV

6688



          minKey = d->minKey;




×







6689



        }










6690



      }










6691



    }










6692













UNCOV

6693



    STbData* di = NULL;




×








UNCOV

6694



    if (pReader->pReadSnap->pIMem != NULL) {





×







6695



      di = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pIMem, pReader->info.suid, pBlockScanInfo->uid);




×







6696



      if (di != NULL) {





×







6697



        if (di->maxKey > maxKey) {





×







6698



          maxKey = di->maxKey;




×







6699



        }










6700



        if (di->minKey < minKey) {





×







6701



          minKey = di->minKey;




×







6702



        }










6703



      }










6704



    }










6705












6706



    // current table is exhausted, let's try the next table











UNCOV

6707



    pHashIter = tSimpleHashIterate(pStatus->pTableMap, pHashIter, &iter);




×







6708



  }










6709













UNCOV

6710



  *pMaxKey = maxKey;




×








UNCOV

6711



  *pMinKey = minKey;




×








UNCOV

6712



}




×







6713













UNCOV

6714



int64_t tsdbGetNumOfRowsInMemTable2(STsdbReader* pReader, uint32_t* rows) {




×








UNCOV

6715



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

6716



  int32_t        lino = 0;




×








UNCOV

6717



  SReaderStatus* pStatus = NULL;




×








UNCOV

6718



  bool           acquired = false;




×







6719













UNCOV

6720



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6721



  TSDB_CHECK_NULL(rows, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6722













UNCOV

6723



  *rows = 0;




×








UNCOV

6724



  pStatus = &pReader->status;




×








UNCOV

6725



  code = tsdbAcquireReader(pReader);




×








UNCOV

6726



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6727



  acquired = true;




×







6728













UNCOV

6729



  if (pReader->flag == READER_STATUS_SUSPEND) {





×








UNCOV

6730



    code = tsdbReaderResume2(pReader);




×








UNCOV

6731



    TSDB_CHECK_CODE(code, lino, _end);





×







6732



  }










6733













UNCOV

6734



  int32_t iter = 0;




×








UNCOV

6735



  pStatus->pTableIter = tSimpleHashIterate(pStatus->pTableMap, NULL, &iter);




×







6736













UNCOV

6737



  while (pStatus->pTableIter != NULL) {





×








UNCOV

6738



    STableBlockScanInfo* pBlockScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;




×







6739













UNCOV

6740



    STbData* d = NULL;




×








UNCOV

6741



    if (pReader->pReadSnap->pMem != NULL) {





×








UNCOV

6742



      d = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pMem, pReader->info.suid, pBlockScanInfo->uid);




×








UNCOV

6743



      if (d != NULL) {





×








UNCOV

6744



        *rows += tsdbGetNRowsInTbData(d);




×







6745



      }










6746



    }










6747













UNCOV

6748



    STbData* di = NULL;




×








UNCOV

6749



    if (pReader->pReadSnap->pIMem != NULL) {





×








UNCOV

6750



      di = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pIMem, pReader->info.suid, pBlockScanInfo->uid);




×








UNCOV

6751



      if (di != NULL) {





×








UNCOV

6752



        *rows += tsdbGetNRowsInTbData(di);




×







6753



      }










6754



    }










6755












6756



    // current table is exhausted, let's try the next table











UNCOV

6757



    pStatus->pTableIter = tSimpleHashIterate(pStatus->pTableMap, pStatus->pTableIter, &iter);




×







6758



  }










6759













UNCOV

6760



_end:




×








UNCOV

6761



  if (code != TSDB_CODE_SUCCESS) {





×







6762



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





×







6763



  }











UNCOV

6764



  if (acquired) {





×








UNCOV

6765



    (void)tsdbReleaseReader(pReader);




×







6766



  }











UNCOV

6767



  return code;




×







6768



}










6769













UNCOV

6770



int32_t tsdbGetTableSchema(SMeta* pMeta, int64_t uid, STSchema** pSchema, int64_t* suid) {




×








UNCOV

6771



  SMetaReader mr = {0};




×








UNCOV

6772



  metaReaderDoInit(&mr, pMeta, META_READER_LOCK);




×








UNCOV

6773



  int32_t code = metaReaderGetTableEntryByUidCache(&mr, uid);




×








UNCOV

6774



  if (code != TSDB_CODE_SUCCESS) {





×







6775



    code = TSDB_CODE_TDB_INVALID_TABLE_ID;




×







6776



    metaReaderClear(&mr);




×







6777



    return code;




×







6778



  }










6779













UNCOV

6780



  *suid = 0;




×







6781












6782



  // only child table and ordinary table is allowed, super table is not allowed.











UNCOV

6783



  if (mr.me.type == TSDB_CHILD_TABLE) {





×








UNCOV

6784



    tDecoderClear(&mr.coder);




×








UNCOV

6785



    *suid = mr.me.ctbEntry.suid;




×








UNCOV

6786



    code = metaReaderGetTableEntryByUidCache(&mr, *suid);




×








UNCOV

6787



    if (code != TSDB_CODE_SUCCESS) {





×







6788



      code = TSDB_CODE_TDB_INVALID_TABLE_ID;




×







6789



      metaReaderClear(&mr);




×







6790



      return code;




×







6791



    }











UNCOV

6792



  } else if (mr.me.type == TSDB_NORMAL_TABLE) {  // do nothing





×







6793



  } else {










6794



    code = TSDB_CODE_INVALID_PARA;




×







6795



    tsdbError("invalid mr.me.type:%d, code:%s", mr.me.type, tstrerror(code));





×







6796



    metaReaderClear(&mr);




×







6797



    return code;




×







6798



  }










6799













UNCOV

6800



  metaReaderClear(&mr);




×







6801












6802



  // get the newest table schema version











UNCOV

6803



  code = metaGetTbTSchemaEx(pMeta, *suid, uid, -1, pSchema);




×








UNCOV

6804



  return code;




×







6805



}










6806













UNCOV

6807



int32_t tsdbTakeReadSnap2(STsdbReader* pReader, _query_reseek_func_t reseek, STsdbReadSnap** ppSnap, const char* id) {




×








UNCOV

6808



  int32_t        code = 0;




×








UNCOV

6809



  STsdb*         pTsdb = pReader->pTsdb;




×








UNCOV

6810



  SVersionRange* pRange = &pReader->info.verRange;




×








UNCOV

6811



  int32_t        lino = 0;




×








UNCOV

6812



  *ppSnap = NULL;




×







6813












6814



  // lock











UNCOV

6815



  code = taosThreadMutexLock(&pTsdb->mutex);




×








UNCOV

6816



  if (code != TSDB_CODE_SUCCESS) {





×







6817



    tsdbError("%s failed to lock tsdb, code:%s", id, tstrerror(code));





×







6818



    return code;




×







6819



  }










6820












6821



  // alloc











UNCOV

6822



  STsdbReadSnap* pSnap = (STsdbReadSnap*)taosMemoryCalloc(1, sizeof(STsdbReadSnap));





×








UNCOV

6823



  if (pSnap == NULL) {





×







6824



    (void) taosThreadMutexUnlock(&pTsdb->mutex);




×







6825



    TSDB_CHECK_NULL(pSnap, code, lino, _exit, terrno);





×







6826



  }










6827












6828



  // take snapshot











UNCOV

6829



  if (pTsdb->mem && (pRange->minVer <= pTsdb->mem->maxVer && pRange->maxVer >= pTsdb->mem->minVer)) {





×








UNCOV

6830



    pSnap->pMem = pTsdb->mem;




×








UNCOV

6831



    pSnap->pNode = taosMemoryMalloc(sizeof(*pSnap->pNode));





×








UNCOV

6832



    if (pSnap->pNode == NULL) {





×







6833



      (void) taosThreadMutexUnlock(&pTsdb->mutex);




×







6834



      TSDB_CHECK_NULL(pSnap->pNode, code, lino, _exit, terrno);





×







6835



    }










6836













UNCOV

6837



    pSnap->pNode->pQHandle = pReader;




×








UNCOV

6838



    pSnap->pNode->reseek = reseek;




×







6839













UNCOV

6840



    code = tsdbRefMemTable(pTsdb->mem, pSnap->pNode);




×








UNCOV

6841



    TSDB_CHECK_CODE(code, lino, _exit);





×







6842



  }










6843













UNCOV

6844



  if (pTsdb->imem && (pRange->minVer <= pTsdb->imem->maxVer && pRange->maxVer >= pTsdb->imem->minVer)) {





×








UNCOV

6845



    pSnap->pIMem = pTsdb->imem;




×








UNCOV

6846



    pSnap->pINode = taosMemoryMalloc(sizeof(*pSnap->pINode));





×








UNCOV

6847



    if (pSnap->pINode == NULL) {





×







6848



      code = terrno;




×







6849












6850



      if (pTsdb->mem && pSnap->pNode) {





×







6851



        tsdbUnrefMemTable(pTsdb->mem, pSnap->pNode, true);  // unref the previous refed mem




×







6852



      }










6853












6854



      (void) taosThreadMutexUnlock(&pTsdb->mutex);




×







6855



      goto _exit;




×







6856



    }










6857













UNCOV

6858



    pSnap->pINode->pQHandle = pReader;




×








UNCOV

6859



    pSnap->pINode->reseek = reseek;




×







6860













UNCOV

6861



    code = tsdbRefMemTable(pTsdb->imem, pSnap->pINode);




×








UNCOV

6862



    TSDB_CHECK_CODE(code, lino, _exit);





×







6863



  }










6864












6865



  // fs











UNCOV

6866



  code = tsdbFSCreateRefSnapshotWithoutLock(pTsdb->pFS, &pSnap->pfSetArray);




×








UNCOV

6867



  if (code) {





×







6868



    if (pSnap->pNode) {





×







6869



      tsdbUnrefMemTable(pTsdb->mem, pSnap->pNode, true);  // unref the previous refed mem




×







6870



    }










6871












6872



    if (pSnap->pINode) {





×







6873



      tsdbUnrefMemTable(pTsdb->imem, pSnap->pINode, true);




×







6874



    }










6875












6876



    (void) taosThreadMutexUnlock(&pTsdb->mutex);




×







6877



    TSDB_CHECK_CODE(code, lino, _exit);





×







6878



  }










6879












6880



  // unlock











UNCOV

6881



  (void) taosThreadMutexUnlock(&pTsdb->mutex);




×








UNCOV

6882



  *ppSnap = pSnap;




×







6883













UNCOV

6884



  tsdbTrace("%s vgId:%d, take read snapshot", id, TD_VID(pTsdb->pVnode));





×








UNCOV

6885



  return code;




×







6886












6887



_exit:




×







6888



  tsdbError("%s vgId:%d take read snapshot failed, line:%d code:%s", id, TD_VID(pTsdb->pVnode), lino, tstrerror(code));





×







6889












6890



  if (pSnap) {





×







6891



    if (pSnap->pNode) taosMemoryFree(pSnap->pNode);





×







6892



    if (pSnap->pINode) taosMemoryFree(pSnap->pINode);





×







6893



    taosMemoryFree(pSnap);





×







6894



  }










6895



  return code;




×







6896



}










6897













UNCOV

6898



void tsdbUntakeReadSnap2(STsdbReader* pReader, STsdbReadSnap* pSnap, bool proactive) {




×








UNCOV

6899



  STsdb* pTsdb = pReader->pTsdb;




×







6900













UNCOV

6901



  if (pSnap) {





×








UNCOV

6902



    if (pSnap->pMem) {





×








UNCOV

6903



      tsdbUnrefMemTable(pSnap->pMem, pSnap->pNode, proactive);




×







6904



    }










6905













UNCOV

6906



    if (pSnap->pIMem) {





×








UNCOV

6907



      tsdbUnrefMemTable(pSnap->pIMem, pSnap->pINode, proactive);




×







6908



    }










6909













UNCOV

6910



    if (pSnap->pNode) taosMemoryFree(pSnap->pNode);





×








UNCOV

6911



    if (pSnap->pINode) taosMemoryFree(pSnap->pINode);





×







6912













UNCOV

6913



    tsdbFSDestroyRefSnapshot(&pSnap->pfSetArray);




×







6914













UNCOV

6915



    taosMemoryFree(pSnap);





×







6916



  }











UNCOV

6917



  tsdbTrace("vgId:%d, untake read snapshot", TD_VID(pTsdb->pVnode));





×








UNCOV

6918



}




×







6919












6920



// if failed, do nothing











UNCOV

6921



int32_t tsdbReaderSetId(void* p, const char* idstr) {




×








UNCOV

6922



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

6923



  int32_t      lino = 0;




×








UNCOV

6924



  STsdbReader* pReader = (STsdbReader*)p;




×







6925













UNCOV

6926



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6927













UNCOV

6928



  taosMemoryFreeClear(pReader->idStr);





×








UNCOV

6929



  pReader->idStr = taosStrdup(idstr);





×








UNCOV

6930



  TSDB_CHECK_NULL(pReader->idStr, code, lino, _end, terrno);





×







6931













UNCOV

6932



  pReader->status.fileIter.pSttBlockReader->mergeTree.idStr = pReader->idStr;




×







6933













UNCOV

6934



_end:




×








UNCOV

6935



  if (code != TSDB_CODE_SUCCESS) {





×







6936



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





×







6937



  }











UNCOV

6938



  return code;




×







6939



}










6940













UNCOV

6941



void tsdbReaderSetCloseFlag(STsdbReader* pReader) { /*pReader->code = TSDB_CODE_TSC_QUERY_CANCELLED;*/ }




×







6942













UNCOV

6943



void tsdbSetFilesetDelimited(STsdbReader* pReader) { pReader->bFilesetDelimited = true; }




×







6944













UNCOV

6945



void tsdbReaderSetNotifyCb(STsdbReader* pReader, TsdReaderNotifyCbFn notifyFn, void* param) {




×








UNCOV

6946



  pReader->notifyFn = notifyFn;




×








UNCOV

6947



  pReader->notifyParam = param;




×








UNCOV

6948



}




×





















    

  • 

    •