taosdata / TDengine / #3621

coverage: 2.037% (-61.5%) from 63.573%
#3621

push

travis-ci

web-flow 
Merge pull request #29874 from taosdata/merge/mainto3.0

merge: from main to 3.0 branch

4357 of 287032 branches covered (1.52%)

Branch coverage included in aggregate %.

0 of 174 new or added lines in 18 files covered. (0.0%)

213359 existing lines in 469 files now uncovered.

7260 of 283369 relevant lines covered (2.56%)

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











UNCOV

135



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




×








UNCOV

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 {











UNCOV

271



      code = TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER;




×








UNCOV

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



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





×







614



  } else {










615



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





×







616



  }










617



  TSDB_CHECK_CODE(code, lino, _end);





×







618












619



_end:




×







620



  if (code != TSDB_CODE_SUCCESS) {





×







621



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





×







622



  }










623



  return code;




×







624



}










625













UNCOV

626



static int32_t tsdbReleaseReader(STsdbReader* pReader) {




×








UNCOV

627



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

628



  int32_t lino = 0;




×







629













UNCOV

630



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





×







631













UNCOV

632



  code = taosThreadMutexUnlock(&pReader->readerMutex);




×








UNCOV

633



  if (code != TSDB_CODE_SUCCESS) {





×







634



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





×







635



  } else {











UNCOV

636



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





×







637



  }











UNCOV

638



  TSDB_CHECK_CODE(code, lino, _end);





×







639













UNCOV

640



_end:




×








UNCOV

641



  if (code != TSDB_CODE_SUCCESS) {





×







642



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





×







643



  }











UNCOV

644



  return code;




×







645



}










646













UNCOV

647



void tsdbReleaseDataBlock2(STsdbReader* pReader) {




×








UNCOV

648



  if (pReader == NULL) return;





×







649













UNCOV

650



  SReaderStatus* pStatus = &pReader->status;




×








UNCOV

651



  if (!pStatus->composedDataBlock) {





×








UNCOV

652



    (void) tsdbReleaseReader(pReader);




×







653



  }










654



}










655













UNCOV

656



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




×







657



                                SQueryTableDataCond* pCond, SBlockLoadSuppInfo* pSup) {











UNCOV

658



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

659



  int32_t      lino = 0;




×








UNCOV

660



  SSDataBlock* p = NULL;




×







661













UNCOV

662



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





×








UNCOV

663



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





×







664













UNCOV

665



  pResBlockInfo->capacity = capacity;




×








UNCOV

666



  pResBlockInfo->pResBlock = pResBlock;




×







667













UNCOV

668



  if (pResBlockInfo->pResBlock == NULL) {





×








UNCOV

669



    pResBlockInfo->freeBlock = true;




×








UNCOV

670



    pResBlockInfo->pResBlock = NULL;




×







671













UNCOV

672



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




×








UNCOV

673



    TSDB_CHECK_CODE(code, lino, _end);





×







674













UNCOV

675



    if (pSup->numOfPks > 0) {





×







676



      p = pResBlockInfo->pResBlock;




×







677



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




×







678



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




×







679












680



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





×







681



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





×







682



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





×







683












684



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





×







685



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





×







686












687



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




×







688



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




×







689



      }










690



    }










691



  } else {











UNCOV

692



    pResBlockInfo->freeBlock = false;




×







693



  }










694













UNCOV

695



_end:




×








UNCOV

696



  if (code != TSDB_CODE_SUCCESS) {





×







697



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





×







698



  }











UNCOV

699



  return code;




×







700



}










701













UNCOV

702



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




×







703



                                SSDataBlock* pResBlock, const char* idstr) {











UNCOV

704



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

705



  int32_t             lino = 0;




×








UNCOV

706



  int8_t              level = 0;




×








UNCOV

707



  STsdbReader*        pReader = NULL;




×








UNCOV

708



  SBlockLoadSuppInfo* pSup = NULL;




×







709













UNCOV

710



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





×








UNCOV

711



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





×








UNCOV

712



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





×







713













UNCOV

714



  *ppReader = NULL;




×








UNCOV

715



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





×








UNCOV

716



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





×







717













UNCOV

718



  if (VND_IS_TSMA(pVnode)) {





×







719



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





×







720



  }










721













UNCOV

722



  initReaderStatus(&pReader->status);




×








UNCOV

723



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




×







724













UNCOV

725



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




×








UNCOV

726



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




×








UNCOV

727



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




×








UNCOV

728



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




×








UNCOV

729



  TSDB_CHECK_CODE(code, lino, _end);





×







730













UNCOV

731



  if (idstr == NULL) {





×








UNCOV

732



    idstr = "";




×







733



  }











UNCOV

734



  pReader->idStr = taosStrdup(idstr);





×








UNCOV

735



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





×







736













UNCOV

737



  pReader->type = pCond->type;




×








UNCOV

738



  pReader->bFilesetDelimited = false;




×








UNCOV

739



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




×







740













UNCOV

741



  if (pCond->numOfCols <= 0) {





×







742



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





×







743



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





×







744



  }










745












746



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











UNCOV

747



  pSup = &pReader->suppInfo;




×








UNCOV

748



  pSup->tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;




×








UNCOV

749



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




×








UNCOV

750



  TSDB_CHECK_CODE(code, lino, _end);





×







751













UNCOV

752



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




×








UNCOV

753



  TSDB_CHECK_CODE(code, lino, _end);





×







754













UNCOV

755



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




×








UNCOV

756



  TSDB_CHECK_CODE(code, lino, _end);





×







757













UNCOV

758



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





×







759



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





×







760



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





×







761



                         TSDB_CODE_INVALID_PARA);










762



  }










763













UNCOV

764



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




×








UNCOV

765



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





×







766













UNCOV

767



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




×








UNCOV

768



  if (type != TSDB_DATA_TYPE_TIMESTAMP) {





×







769



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





×







770



              pReader->idStr);










771



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





×







772



  }










773













UNCOV

774



  code = tsdbInitReaderLock(pReader);




×








UNCOV

775



  TSDB_CHECK_CODE(code, lino, _end);





×







776













UNCOV

777



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




×








UNCOV

778



  TSDB_CHECK_CODE(code, lino, _end);





×







779













UNCOV

780



  *ppReader = pReader;




×








UNCOV

781



  pReader = NULL;




×







782













UNCOV

783



_end:




×








UNCOV

784



  if (code != TSDB_CODE_SUCCESS) {





×







785



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





×







786



  }











UNCOV

787



  if (pReader) {





×







788



    tsdbReaderClose2(pReader);




×







789



  }











UNCOV

790



  return code;




×







791



}










792













UNCOV

793



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




×








UNCOV

794



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

795



  int32_t              lino = 0;




×








UNCOV

796



  int32_t              st = 0;




×








UNCOV

797



  int32_t              et1 = 0;




×








UNCOV

798



  int32_t              et2 = 0;




×








UNCOV

799



  int32_t              numOfTables = 0;




×








UNCOV

800



  const TBrinBlkArray* pBlkArray = NULL;




×








UNCOV

801



  STableUidList*       pList = NULL;




×








UNCOV

802



  SBrinBlk*            pBrinBlk = NULL;




×







803













UNCOV

804



  if (pFileReader == NULL) {





×








UNCOV

805



    goto _end;




×







806



  }










807













UNCOV

808



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





×








UNCOV

809



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





×







810













UNCOV

811



  st = taosGetTimestampUs();




×








UNCOV

812



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




×







813













UNCOV

814



  code = tsdbDataFileReadBrinBlk(pFileReader, &pBlkArray);




×








UNCOV

815



  TSDB_CHECK_CODE(code, lino, _end);





×







816












817



#if 0










818



  LRUHandle* handle = NULL;










819












820



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










821



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










822



    goto _end;










823



  }










824












825












826



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










827



  size_t  num = taosArrayGetSize(aBlockIdx);










828



  if (num == 0) {










829



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










830



    return TSDB_CODE_SUCCESS;










831



  }










832



#endif










833












834



  // todo binary search to the start position











UNCOV

835



  et1 = taosGetTimestampUs();




×







836













UNCOV

837



  pList = &pReader->status.uidList;




×







838













UNCOV

839



  int32_t i = 0;




×








UNCOV

840



  int32_t j = 0;




×








UNCOV

841



  while (i < TARRAY2_SIZE(pBlkArray)) {





×








UNCOV

842



    pBrinBlk = &pBlkArray->data[i];




×








UNCOV

843



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





×








UNCOV

844



      i += 1;




×








UNCOV

845



      continue;




×







846



    }










847













UNCOV

848



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





×








UNCOV

849



      break;




×







850



    }










851













UNCOV

852



    TSDB_CHECK_CONDITION(





×







853



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










854



        _end, TSDB_CODE_INTERNAL_ERROR);










855













UNCOV

856



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





×








UNCOV

857



      i += 1;




×








UNCOV

858



      continue;




×







859



    }










860













UNCOV

861



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





×








UNCOV

862



      break;




×







863



    }










864













UNCOV

865



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




×








UNCOV

866



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





×







867













UNCOV

868



    i += 1;




×








UNCOV

869



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





×








UNCOV

870



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





×








UNCOV

871



        j++;




×







872



      }











UNCOV

873



      if (j >= numOfTables) {





×








UNCOV

874



        break;




×







875



      }










876



    }










877



  }










878













UNCOV

879



  et2 = taosGetTimestampUs();




×








UNCOV

880



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





×







881



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










882



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










883













UNCOV

884



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




×







885













UNCOV

886



_end:




×








UNCOV

887



  if (code != TSDB_CODE_SUCCESS) {





×







888



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





×







889



  }











UNCOV

890



  return code;




×







891



}










892













UNCOV

893



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




×







894



                                     SArray* pTableScanInfoList) {











UNCOV

895



  int32_t         code = TSDB_CODE_SUCCESS;




×








UNCOV

896



  int32_t         lino = 0;




×








UNCOV

897



  int64_t         st = 0;




×








UNCOV

898



  bool            asc = false;




×








UNCOV

899



  STimeWindow     w = {0};




×








UNCOV

900



  SBrinRecordIter iter = {0};




×








UNCOV

901



  int32_t         numOfTables = 0;




×








UNCOV

902



  SBrinRecord*    pRecord = NULL;




×








UNCOV

903



  int32_t         k = 0;




×








UNCOV

904



  size_t          sizeInDisk = 0;




×







905













UNCOV

906



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





×








UNCOV

907



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





×








UNCOV

908



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





×







909













UNCOV

910



  st = taosGetTimestampUs();




×








UNCOV

911



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




×








UNCOV

912



  w = pReader->info.window;




×








UNCOV

913



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




×







914












915



  // clear info for the new file











UNCOV

916



  cleanupInfoForNextFileset(pReader->status.pTableMap);




×








UNCOV

917



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




×







918













UNCOV

919



  while (1) {




×








UNCOV

920



    code = getNextBrinRecord(&iter, &pRecord);




×








UNCOV

921



    TSDB_CHECK_CODE(code, lino, _end);





×







922













UNCOV

923



    if (pRecord == NULL) {





×








UNCOV

924



      break;




×







925



    }










926













UNCOV

927



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





×








UNCOV

928



      break;




×







929



    }










930













UNCOV

931



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




×








UNCOV

932



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





×








UNCOV

933



      continue;




×







934



    }










935













UNCOV

936



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





×








UNCOV

937



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





×








UNCOV

938



        k += 1;




×







939



      }










940













UNCOV

941



      if (k >= numOfTables) {





×








UNCOV

942



        break;




×







943



      }










944













UNCOV

945



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




×







946



    }










947













UNCOV

948



    if (pRecord->uid < uid) {





×








UNCOV

949



      continue;




×







950



    }










951













UNCOV

952



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





×







953



                         TSDB_CODE_INTERNAL_ERROR);










954













UNCOV

955



    STableBlockScanInfo* pScanInfo = NULL;




×








UNCOV

956



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




×








UNCOV

957



    TSDB_CHECK_CODE(code, lino, _end);





×







958












959



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










960



    // the window is an open interval NOW.











UNCOV

961



    if (asc) {





×








UNCOV

962



      w.skey = pScanInfo->lastProcKey.ts;




×







963



    } else {











UNCOV

964



      w.ekey = pScanInfo->lastProcKey.ts;




×







965



    }










966












967



    // NOTE: specialized for open interval











UNCOV

968



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





×







969



      k += 1;




×







970



      if (k >= numOfTables) {





×







971



        break;




×







972



      } else {










973



        continue;




×







974



      }










975



    }










976












977



    // 1. time range check











UNCOV

978



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





×








UNCOV

979



      continue;




×







980



    }










981



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











UNCOV

982



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





×







983



      continue;




×







984



    }










985













UNCOV

986



    if (asc) {





×








UNCOV

987



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





×







988



        continue;




×







989



      }










990



    } else {











UNCOV

991



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





×







992



        continue;




×







993



      }










994



    }










995












996



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











UNCOV

997



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





×








UNCOV

998



      continue;




×







999



    }










1000













UNCOV

1001



    if (pScanInfo->pBlockList == NULL) {





×








UNCOV

1002



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




×








UNCOV

1003



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





×







1004



    }










1005













UNCOV

1006



    if (pScanInfo->pBlockIdxList == NULL) {





×








UNCOV

1007



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




×








UNCOV

1008



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





×







1009



    }










1010













UNCOV

1011



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




×








UNCOV

1012



    code = recordToBlockInfo(&blockInfo, pRecord);




×








UNCOV

1013



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

1014



    sizeInDisk += blockInfo.blockSize;




×







1015













UNCOV

1016



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




×








UNCOV

1017



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





×







1018












1019



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











UNCOV

1020



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





×








UNCOV

1021



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




×







1022



    }










1023













UNCOV

1024



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





×








UNCOV

1025



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




×







1026



    }










1027













UNCOV

1028



    pBlockNum->numOfBlocks += 1;




×








UNCOV

1029



    if (taosArrayGetSize(pTableScanInfoList) == 0) {





×








UNCOV

1030



      p1 = taosArrayPush(pTableScanInfoList, &pScanInfo);




×








UNCOV

1031



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





×







1032



    } else {











UNCOV

1033



      STableBlockScanInfo** p = taosArrayGetLast(pTableScanInfoList);




×








UNCOV

1034



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





×







1035













UNCOV

1036



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





×








UNCOV

1037



        p1 = taosArrayPush(pTableScanInfoList, &pScanInfo);




×








UNCOV

1038



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





×







1039



      }










1040



    }










1041



  }










1042













UNCOV

1043



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




×








UNCOV

1044



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




×







1045













UNCOV

1046



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




×








UNCOV

1047



  tsdbDebug(





×







1048



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










1049



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










1050



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










1051



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










1052













UNCOV

1053



  pReader->cost.numOfBlocks += total;




×








UNCOV

1054



  pReader->cost.headFileLoadTime += el;




×







1055













UNCOV

1056



_end:




×








UNCOV

1057



  if (code != TSDB_CODE_SUCCESS) {





×







1058



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





×







1059



  }











UNCOV

1060



  clearBrinBlockIter(&iter);




×








UNCOV

1061



  return code;




×







1062



}










1063













UNCOV

1064



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




×








UNCOV

1065



  if (pDumpInfo != NULL) {





×








UNCOV

1066



    pDumpInfo->allDumped = true;




×







1067



  }











UNCOV

1068



}




×







1069













UNCOV

1070



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




×







1071



                                 bool asc) {











UNCOV

1072



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1073



  int32_t lino = 0;




×







1074













UNCOV

1075



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





×








UNCOV

1076



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





×







1077













UNCOV

1078



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





×








UNCOV

1079



  pKey->numOfPKs = numOfPks;




×








UNCOV

1080



  if (pKey->numOfPKs <= 0) {





×








UNCOV

1081



    goto _end;




×







1082



  }










1083













UNCOV

1084



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





×








UNCOV

1085



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





×








UNCOV

1086



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





×







1087



  } else {










1088



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





×







1089



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





×







1090



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




×







1091



  }










1092













UNCOV

1093



_end:




×








UNCOV

1094



  if (code != TSDB_CODE_SUCCESS) {





×







1095



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





×







1096



  }











UNCOV

1097



  return code;




×







1098



}










1099













UNCOV

1100



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




×







1101



                            SBlockLoadSuppInfo* pSup) {











UNCOV

1102



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1103



  int32_t lino = 0;




×







1104













UNCOV

1105



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





×








UNCOV

1106



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





×







1107













UNCOV

1108



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





×








UNCOV

1109



    if (!COL_VAL_IS_VALUE(pColVal)) {





×








UNCOV

1110



      colDataSetNULL(pColInfoData, rowIndex);





×







1111



    } else {











UNCOV

1112



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





×








UNCOV

1113



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




×








UNCOV

1114



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





×








UNCOV

1115



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





×







1116



                 pColInfoData->info.bytes);











UNCOV

1117



        code = TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER;




×








UNCOV

1118



        TSDB_CHECK_CODE(code, lino, _end);





×







1119



      }










1120













UNCOV

1121



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





×








UNCOV

1122



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




×







1123



      }










1124













UNCOV

1125



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




×








UNCOV

1126



      TSDB_CHECK_CODE(code, lino, _end);





×







1127



    }










1128



  } else {











UNCOV

1129



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




×








UNCOV

1130



    TSDB_CHECK_CODE(code, lino, _end);





×







1131



  }










1132













UNCOV

1133



_end:




×








UNCOV

1134



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

1135



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





×







1136



  }











UNCOV

1137



  return code;




×







1138



}










1139













UNCOV

1140



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




×








UNCOV

1141



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1142



  int32_t lino = 0;




×







1143













UNCOV

1144



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





×








UNCOV

1145



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





×








UNCOV

1146



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





×







1147













UNCOV

1148



  *pInfo = NULL;




×







1149













UNCOV

1150



  size_t num = TARRAY_SIZE(pBlockIter->blockList);




×








UNCOV

1151



  if (num == 0) {





×







1152



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










1153



    // generating excessive unnecessary error logs.











UNCOV

1154



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





×








UNCOV

1155



    return TSDB_CODE_INVALID_PARA;




×







1156



  }










1157













UNCOV

1158



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




×








UNCOV

1159



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





×







1160













UNCOV

1161



_end:




×








UNCOV

1162



  if (code != TSDB_CODE_SUCCESS) {





×







1163



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





×







1164



  }











UNCOV

1165



  return code;




×







1166



}










1167













UNCOV

1168



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




×







1169



  // start end position










1170



  int s, e;











UNCOV

1171



  s = pos;




×







1172












1173



  // check











UNCOV

1174



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





×







1175



    return -1;




×







1176



  }











UNCOV

1177



  if (order == TSDB_ORDER_ASC) {





×







1178



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











UNCOV

1179



    e = num - 1;




×








UNCOV

1180



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





×








UNCOV

1181



    while (1) {




×







1182



      // check can return











UNCOV

1183



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





×








UNCOV

1184



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





×








UNCOV

1185



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





×







1186












1187



      // change start or end position











UNCOV

1188



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




×








UNCOV

1189



      if (keyList[mid] > key)





×








UNCOV

1190



        e = mid;




×








UNCOV

1191



      else if (keyList[mid] < key)





×








UNCOV

1192



        s = mid;




×







1193



      else











UNCOV

1194



        return mid;




×







1195



    }










1196



  } else {  // DESC










1197



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











UNCOV

1198



    e = 0;




×








UNCOV

1199



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





×








UNCOV

1200



    while (1) {




×







1201



      // check can return











UNCOV

1202



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





×








UNCOV

1203



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





×








UNCOV

1204



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





×







1205












1206



      // change start or end position











UNCOV

1207



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




×








UNCOV

1208



      if (keyList[mid] < key)





×








UNCOV

1209



        e = mid;




×








UNCOV

1210



      else if (keyList[mid] > key)





×








UNCOV

1211



        s = mid;




×







1212



      else











UNCOV

1213



        return mid;




×







1214



    }










1215



  }










1216



}










1217












1218



// handle the repeat ts cases.











UNCOV

1219



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




×








UNCOV

1220



  int32_t i = startPos;




×








UNCOV

1221



  int64_t startTs = pTsList[startPos];




×








UNCOV

1222



  if (asc) {





×








UNCOV

1223



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





×








UNCOV

1224



      i++;




×







1225



    }











UNCOV

1226



    return i - 1;




×







1227



  } else {











UNCOV

1228



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





×








UNCOV

1229



      i--;




×







1230



    }











UNCOV

1231



    return i + 1;




×







1232



  }










1233



}










1234













UNCOV

1235



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




×







1236



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











UNCOV

1237



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1238



  int32_t lino = 0;




×








UNCOV

1239



  int32_t endPos = -1;




×








UNCOV

1240



  bool    asc = false;




×







1241













UNCOV

1242



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





×








UNCOV

1243



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





×







1244













UNCOV

1245



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




×







1246













UNCOV

1247



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





×








UNCOV

1248



    endPos = pRecord->numRow - 1;




×








UNCOV

1249



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





×








UNCOV

1250



    endPos = 0;




×







1251



  } else {











UNCOV

1252



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





×








UNCOV

1253



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




×








UNCOV

1254



    if (endPos == -1) {





×







1255



      goto _end;




×







1256



    }










1257













UNCOV

1258



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




×







1259



  }










1260













UNCOV

1261



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





×








UNCOV

1262



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





×







1263



    int32_t i = endPos;




×







1264












1265



    if (asc) {





×







1266



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





×







1267



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





×







1268



          break;




×







1269



        }










1270



      }










1271



    } else {










1272



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





×







1273



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





×







1274



          break;




×







1275



        }










1276



      }










1277



    }










1278












1279



    endPos = i;




×







1280



  }










1281













UNCOV

1282



_end:




×








UNCOV

1283



  if (code != TSDB_CODE_SUCCESS) {





×







1284



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





×







1285



  }











UNCOV

1286



  return endPos;




×







1287



}










1288













UNCOV

1289



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




×







1290



                                int32_t dumpedRows, bool asc) {











UNCOV

1291



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1292



  int32_t lino = 0;




×







1293













UNCOV

1294



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





×








UNCOV

1295



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





×








UNCOV

1296



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





×








UNCOV

1297



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





×







1298













UNCOV

1299



  if (asc) {





×








UNCOV

1300



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




×







1301



  } else {











UNCOV

1302



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




×








UNCOV

1303



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




×







1304












1305



    // todo: opt perf by extract the loop










1306



    // reverse the array list











UNCOV

1307



    int32_t  mid = dumpedRows >> 1u;




×








UNCOV

1308



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




×








UNCOV

1309



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





×








UNCOV

1310



      int64_t t = pts[j];




×








UNCOV

1311



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




×








UNCOV

1312



      pts[dumpedRows - j - 1] = t;




×







1313



    }










1314



  }










1315













UNCOV

1316



_end:




×








UNCOV

1317



  if (code != TSDB_CODE_SUCCESS) {





×







1318



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





×







1319



  }











UNCOV

1320



  return code;




×







1321



}










1322












1323



// a faster version of copy procedure.











UNCOV

1324



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




×







1325



                               int32_t dumpedRows, bool asc) {











UNCOV

1326



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

1327



  int32_t  lino = 0;




×








UNCOV

1328



  uint8_t* p = NULL;




×








UNCOV

1329



  int32_t  step = asc ? 1 : -1;





×







1330













UNCOV

1331



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





×








UNCOV

1332



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





×








UNCOV

1333



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





×








UNCOV

1334



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





×







1335













UNCOV

1336



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





×








UNCOV

1337



  if (asc) {





×








UNCOV

1338



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




×







1339



  } else {










1340



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




×







1341



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




×







1342



  }










1343












1344



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










1345












1346



  // 1. copy data in a batch model











UNCOV

1347



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




×







1348












1349



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











UNCOV

1350



  if (!asc) {





×








UNCOV

1351



    switch (pColData->info.type) {





×








UNCOV

1352



      case TSDB_DATA_TYPE_TIMESTAMP:




×







1353



      case TSDB_DATA_TYPE_DOUBLE:










1354



      case TSDB_DATA_TYPE_BIGINT:










1355



      case TSDB_DATA_TYPE_UBIGINT: {











UNCOV

1356



        int32_t  mid = dumpedRows >> 1u;




×








UNCOV

1357



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




×








UNCOV

1358



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





×








UNCOV

1359



          int64_t t = pts[j];




×








UNCOV

1360



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




×








UNCOV

1361



          pts[dumpedRows - j - 1] = t;




×







1362



        }











UNCOV

1363



        break;




×







1364



      }










1365












1366



      case TSDB_DATA_TYPE_BOOL:




×







1367



      case TSDB_DATA_TYPE_TINYINT:










1368



      case TSDB_DATA_TYPE_UTINYINT: {










1369



        int32_t mid = dumpedRows >> 1u;




×







1370



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




×







1371



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





×







1372



          int8_t t = pts[j];




×







1373



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




×







1374



          pts[dumpedRows - j - 1] = t;




×







1375



        }










1376



        break;




×







1377



      }










1378












1379



      case TSDB_DATA_TYPE_SMALLINT:




×







1380



      case TSDB_DATA_TYPE_USMALLINT: {










1381



        int32_t  mid = dumpedRows >> 1u;




×







1382



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




×







1383



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





×







1384



          int64_t t = pts[j];




×







1385



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




×







1386



          pts[dumpedRows - j - 1] = t;




×







1387



        }










1388



        break;




×







1389



      }










1390












1391



      case TSDB_DATA_TYPE_FLOAT:




×







1392



      case TSDB_DATA_TYPE_INT:










1393



      case TSDB_DATA_TYPE_UINT: {










1394



        int32_t  mid = dumpedRows >> 1u;




×







1395



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




×







1396



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





×







1397



          int32_t t = pts[j];




×







1398



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




×







1399



          pts[dumpedRows - j - 1] = t;




×







1400



        }










1401



        break;




×







1402



      }










1403



    }










1404



  }










1405












1406



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











UNCOV

1407



  if (pData->flag != HAS_VALUE) {





×








UNCOV

1408



    int32_t rowIndex = 0;




×







1409













UNCOV

1410



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





×








UNCOV

1411



      uint8_t v = tColDataGetBitValue(pData, j);




×








UNCOV

1412



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





×








UNCOV

1413



        colDataSetNull_f(pColData->nullbitmap, rowIndex);




×








UNCOV

1414



        pColData->hasNull = true;




×







1415



      }










1416



    }










1417



  }










1418













UNCOV

1419



_end:




×








UNCOV

1420



  if (code != TSDB_CODE_SUCCESS) {





×







1421



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





×







1422



  }











UNCOV

1423



  return code;




×







1424



}










1425













UNCOV

1426



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




×








UNCOV

1427



  record->uid = pBlockInfo->uid;




×








UNCOV

1428



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




×








UNCOV

1429



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




×







1430













UNCOV

1431



  if (pSupp->numOfPks > 0) {





×








UNCOV

1432



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




×








UNCOV

1433



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




×







1434













UNCOV

1435



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




×








UNCOV

1436



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




×







1437













UNCOV

1438



    if (IS_VAR_DATA_TYPE(pFirst->type)) {





×







1439



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




×







1440



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




×







1441












1442



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




×







1443



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




×







1444



    } else {











UNCOV

1445



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




×








UNCOV

1446



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




×







1447



    }










1448



  }










1449













UNCOV

1450



  record->minVer = pBlockInfo->minVer;




×








UNCOV

1451



  record->maxVer = pBlockInfo->maxVer;




×








UNCOV

1452



  record->blockOffset = pBlockInfo->blockOffset;




×








UNCOV

1453



  record->smaOffset = pBlockInfo->smaOffset;




×








UNCOV

1454



  record->blockSize = pBlockInfo->blockSize;




×








UNCOV

1455



  record->blockKeySize = pBlockInfo->blockKeySize;




×








UNCOV

1456



  record->smaSize = pBlockInfo->smaSize;




×








UNCOV

1457



  record->numRow = pBlockInfo->numRow;




×








UNCOV

1458



  record->count = pBlockInfo->count;




×








UNCOV

1459



}




×







1460













UNCOV

1461



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




×








UNCOV

1462



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

1463



  int32_t             lino = 0;




×








UNCOV

1464



  SReaderStatus*      pStatus = NULL;




×








UNCOV

1465



  SDataBlockIter*     pBlockIter = NULL;




×








UNCOV

1466



  SBlockLoadSuppInfo* pSupInfo = NULL;




×








UNCOV

1467



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

1468



  SBlockData*         pBlockData = NULL;




×








UNCOV

1469



  SFileDataBlockInfo* pBlockInfo = NULL;




×








UNCOV

1470



  SSDataBlock*        pResBlock = NULL;




×








UNCOV

1471



  int32_t             numOfOutputCols = 0;




×








UNCOV

1472



  int64_t             st = 0;




×








UNCOV

1473



  bool                asc = false;




×








UNCOV

1474



  int32_t             step = 0;




×








UNCOV

1475



  SColVal             cv = {0};




×







1476



  SBrinRecord         tmp;











UNCOV

1477



  SBrinRecord*        pRecord = NULL;




×







1478













UNCOV

1479



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





×







1480













UNCOV

1481



  pStatus = &pReader->status;




×








UNCOV

1482



  pBlockIter = &pStatus->blockIter;




×








UNCOV

1483



  pSupInfo = &pReader->suppInfo;




×








UNCOV

1484



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







1485













UNCOV

1486



  pBlockData = &pStatus->fileBlockData;




×








UNCOV

1487



  pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

1488



  numOfOutputCols = pSupInfo->numOfCols;




×








UNCOV

1489



  st = taosGetTimestampUs();




×








UNCOV

1490



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




×








UNCOV

1491



  step = asc ? 1 : -1;





×







1492













UNCOV

1493



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




×








UNCOV

1494



  TSDB_CHECK_CODE(code, lino, _end);





×







1495













UNCOV

1496



  blockInfoToRecord(&tmp, pBlockInfo, pSupInfo);




×








UNCOV

1497



  pRecord = &tmp;




×







1498












1499



  // no data exists, return directly.











UNCOV

1500



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





×







1501



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





×







1502



             pBlockInfo->uid, pReader->idStr);










1503



    pResBlock->info.rows = 0;




×







1504



    goto _end;




×







1505



  }










1506













UNCOV

1507



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





×







1508



                       TSDB_CODE_INVALID_PARA);










1509












1510



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











UNCOV

1511



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





×








UNCOV

1512



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





×








UNCOV

1513



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





×







1514



      // pDumpInfo->rowIndex = 0;











UNCOV

1515



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





×








UNCOV

1516



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





×







1517



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










1518



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











UNCOV

1519



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





×








UNCOV

1520



      int32_t order = asc ? TSDB_ORDER_DESC : TSDB_ORDER_ASC;





×








UNCOV

1521



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





×








UNCOV

1522



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




×







1523













UNCOV

1524



      if (pDumpInfo->rowIndex < 0) {





×







1525



        tsdbError(





×







1526



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










1527



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










1528



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










1529



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










1530



        code = TSDB_CODE_INVALID_PARA;




×







1531



        TSDB_CHECK_CODE(code, lino, _end);





×







1532



      }










1533













UNCOV

1534



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




×







1535













UNCOV

1536



      TSDB_CHECK_CONDITION(





×







1537



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










1538



          lino, _end, TSDB_CODE_INVALID_PARA);










1539












1540



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











UNCOV

1541



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





×








UNCOV

1542



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





×







1543



        int32_t i = pDumpInfo->rowIndex;




×







1544



        if (asc) {





×







1545



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





×







1546



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





×







1547



              break;




×







1548



            }










1549



          }










1550



        } else {










1551



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





×







1552



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





×







1553



              break;




×







1554



            }










1555



          }










1556



        }










1557












1558



        pDumpInfo->rowIndex = i;




×







1559



      }










1560



    }










1561



  }










1562












1563



  // time window check











UNCOV

1564



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




×








UNCOV

1565



  if (endIndex == -1) {





×







1566



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




×







1567



    goto _end;




×







1568



  }










1569













UNCOV

1570



  endIndex += step;




×








UNCOV

1571



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





×








UNCOV

1572



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





×







1573



    dumpedRows = pReader->resBlockInfo.capacity;




×








UNCOV

1574



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





×







1575



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




×







1576



    goto _end;




×







1577



  }










1578













UNCOV

1579



  int32_t i = 0;




×








UNCOV

1580



  int32_t rowIndex = 0;




×







1581













UNCOV

1582



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




×








UNCOV

1583



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





×







1584













UNCOV

1585



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





×








UNCOV

1586



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




×








UNCOV

1587



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

1588



    i += 1;




×







1589



  }










1590













UNCOV

1591



  int32_t colIndex = 0;




×








UNCOV

1592



  int32_t num = pBlockData->nColData;




×








UNCOV

1593



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





×








UNCOV

1594



    rowIndex = 0;




×







1595













UNCOV

1596



    SColData* pData = tBlockDataGetColDataByIdx(pBlockData, colIndex);




×








UNCOV

1597



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





×







1598



      colIndex += 1;




×








UNCOV

1599



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





×








UNCOV

1600



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




×








UNCOV

1601



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





×







1602













UNCOV

1603



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





×








UNCOV

1604



        colDataSetNNULL(pColData, 0, dumpedRows);





×







1605



      } else {











UNCOV

1606



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





×








UNCOV

1607



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




×








UNCOV

1608



          TSDB_CHECK_CODE(code, lino, _end);





×







1609



        } else {  // varchar/nchar type











UNCOV

1610



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





×








UNCOV

1611



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




×








UNCOV

1612



            TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

1613



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




×








UNCOV

1614



            TSDB_CHECK_CODE(code, lino, _end);





×







1615



          }










1616



        }










1617



      }










1618













UNCOV

1619



      colIndex += 1;




×








UNCOV

1620



      i += 1;




×







1621



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










1622



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




×







1623



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





×







1624












1625



      colDataSetNNULL(pColData, 0, dumpedRows);





×







1626



      i += 1;




×







1627



    }










1628



  }










1629












1630



  // fill the mis-matched columns with null value











UNCOV

1631



  while (i < numOfOutputCols) {





×







1632



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




×







1633



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





×







1634












1635



    colDataSetNNULL(pColData, 0, dumpedRows);





×







1636



    i += 1;




×







1637



  }










1638













UNCOV

1639



  pResBlock->info.dataLoad = 1;




×








UNCOV

1640



  pResBlock->info.rows = dumpedRows;




×








UNCOV

1641



  pDumpInfo->rowIndex += step * dumpedRows;




×







1642













UNCOV

1643



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





×







1644












1645



  // check if current block are all handled











UNCOV

1646



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





×








UNCOV

1647



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




×







1648












1649



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











UNCOV

1650



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





×








UNCOV

1651



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




×







1652



    }










1653



  } else {











UNCOV

1654



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





×








UNCOV

1655



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




×







1656



  }










1657













UNCOV

1658



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




×








UNCOV

1659



  pReader->cost.blockLoadTime += elapsedTime;




×







1660













UNCOV

1661



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





×








UNCOV

1662



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





×







1663



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










1664



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










1665



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










1666













UNCOV

1667



_end:




×








UNCOV

1668



  if (code != TSDB_CODE_SUCCESS) {





×







1669



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





×







1670



  }











UNCOV

1671



  return code;




×







1672



}










1673












1674



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











UNCOV

1675



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

1676



  int32_t lino = 0;




×







1677













UNCOV

1678



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





×







1679













UNCOV

1680



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




×








UNCOV

1681



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





×







1682



    terrno = code;




×







1683



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





×







1684



  }











UNCOV

1685



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

1686



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





×







1687













UNCOV

1688



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




×








UNCOV

1689



  TSDB_CHECK_CODE(code, lino, _end);





×







1690













UNCOV

1691



_end:




×








UNCOV

1692



  if (code != TSDB_CODE_SUCCESS) {





×







1693



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





×







1694



    terrno = code;




×







1695



    return NULL;




×







1696



  }











UNCOV

1697



  return pReader->info.pSchema;




×







1698



}










1699













UNCOV

1700



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




×







1701



                                   uint64_t uid) {











UNCOV

1702



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

1703



  int32_t             lino = 0;




×








UNCOV

1704



  STSchema*           pSchema = NULL;




×








UNCOV

1705



  SFileDataBlockInfo* pBlockInfo = NULL;




×








UNCOV

1706



  SBlockLoadSuppInfo* pSup = NULL;




×








UNCOV

1707



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

1708



  int64_t             st = 0;




×







1709



  SBrinRecord         tmp;











UNCOV

1710



  SBrinRecord*        pRecord = NULL;




×







1711













UNCOV

1712



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





×








UNCOV

1713



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





×







1714













UNCOV

1715



  pSchema = pReader->info.pSchema;




×








UNCOV

1716



  st = taosGetTimestampUs();




×








UNCOV

1717



  pSup = &pReader->suppInfo;




×







1718













UNCOV

1719



  tBlockDataReset(pBlockData);




×







1720













UNCOV

1721



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





×







1722



    pSchema = getTableSchemaImpl(pReader, uid);




×







1723



    if (pSchema == NULL) {





×







1724



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





×







1725



                pReader->idStr);










1726



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





×







1727



    }










1728



  }










1729













UNCOV

1730



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




×








UNCOV

1731



  TSDB_CHECK_CODE(code, lino, _end);





×







1732













UNCOV

1733



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







1734













UNCOV

1735



  blockInfoToRecord(&tmp, pBlockInfo, pSup);




×








UNCOV

1736



  pRecord = &tmp;




×








UNCOV

1737



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




×








UNCOV

1738



                                           pSup->numOfCols - 1);




×








UNCOV

1739



  if (code != TSDB_CODE_SUCCESS) {





×







1740



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





×







1741



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










1742



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










1743



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










1744



    TSDB_CHECK_CODE(code, lino, _end);





×







1745



  }










1746













UNCOV

1747



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




×







1748













UNCOV

1749



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





×







1750



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










1751



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










1752



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










1753













UNCOV

1754



  pReader->cost.blockLoadTime += elapsedTime;




×








UNCOV

1755



  pDumpInfo->allDumped = false;




×







1756













UNCOV

1757



_end:




×








UNCOV

1758



  if (code != TSDB_CODE_SUCCESS) {





×







1759



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





×







1760



  }











UNCOV

1761



  return code;




×







1762



}










1763












1764



/**










1765



 * This is an two rectangles overlap cases.










1766



 */











UNCOV

1767



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




×








UNCOV

1768



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





×








UNCOV

1769



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





×








UNCOV

1770



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





×








UNCOV

1771



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





×







1772



}










1773













UNCOV

1774



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




×







1775



                                       STableBlockScanInfo* pScanInfo, int32_t* nextIndex, int32_t order,










1776



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











UNCOV

1777



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

1778



  int32_t             lino = 0;




×








UNCOV

1779



  bool                asc = false;




×








UNCOV

1780



  int32_t             step = 0;




×








UNCOV

1781



  STableDataBlockIdx* pTableDataBlockIdx = NULL;




×








UNCOV

1782



  SFileDataBlockInfo* p = NULL;




×







1783













UNCOV

1784



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





×








UNCOV

1785



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





×








UNCOV

1786



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





×







1787













UNCOV

1788



  *res = false;




×








UNCOV

1789



  asc = ASCENDING_TRAVERSE(order);




×








UNCOV

1790



  step = asc ? 1 : -1;





×







1791













UNCOV

1792



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





×








UNCOV

1793



    *res = false;




×








UNCOV

1794



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





×








UNCOV

1795



    *res = false;




×







1796



  } else {











UNCOV

1797



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





×








UNCOV

1798



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





×








UNCOV

1799



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





×








UNCOV

1800



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





×







1801













UNCOV

1802



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




×








UNCOV

1803



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





×







1804













UNCOV

1805



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




×








UNCOV

1806



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





×







1807













UNCOV

1808



    blockInfoToRecord(pRecord, p, pSupInfo);




×







1809













UNCOV

1810



    *nextIndex = pBlockInfo->tbBlockIdx + step;




×








UNCOV

1811



    *res = true;




×







1812



  }










1813













UNCOV

1814



_end:




×








UNCOV

1815



  if (code != TSDB_CODE_SUCCESS) {





×







1816



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





×







1817



  }











UNCOV

1818



  return code;




×







1819



}










1820













UNCOV

1821



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




×







1822



                                             int32_t step) {











UNCOV

1823



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

1824



  int32_t              lino = 0;




×








UNCOV

1825



  const void*          p = NULL;




×







1826



  SFileDataBlockInfo   fblock;











UNCOV

1827



  SFileDataBlockInfo*  pBlockInfo = NULL;




×








UNCOV

1828



  STableBlockScanInfo* pBlockScanInfo = NULL;




×








UNCOV

1829



  STableDataBlockIdx*  pTableDataBlockIdx = NULL;




×







1830













UNCOV

1831



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





×








UNCOV

1832



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





×







1833













UNCOV

1834



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




×








UNCOV

1835



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





×







1836













UNCOV

1837



  fblock = *(SFileDataBlockInfo*)p;




×








UNCOV

1838



  pBlockIter->index += step;




×







1839













UNCOV

1840



  if (index != pBlockIter->index) {





×







1841



    if (index > pBlockIter->index) {





×







1842



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





×







1843



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




×







1844



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





×







1845












1846



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




×







1847



        TSDB_CHECK_CODE(code, lino, _end);





×







1848












1849



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




×







1850



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





×







1851












1852



        pTableDataBlockIdx->globalIndex = i + 1;




×







1853












1854



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




×







1855



      }










1856



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





×







1857



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





×







1858



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




×







1859



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





×







1860












1861



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




×







1862



        TSDB_CHECK_CODE(code, lino, _end);





×







1863












1864



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




×







1865



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





×







1866












1867



        pTableDataBlockIdx->globalIndex = i - 1;




×







1868



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




×







1869



      }










1870



    }










1871












1872



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




×







1873



    pBlockScanInfo = NULL;




×







1874



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




×







1875



    TSDB_CHECK_CODE(code, lino, _end);





×







1876












1877



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




×







1878



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





×







1879












1880



    pTableDataBlockIdx->globalIndex = pBlockIter->index;




×







1881



  }










1882













UNCOV

1883



_end:




×








UNCOV

1884



  if (code != TSDB_CODE_SUCCESS) {





×







1885



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





×







1886



  }











UNCOV

1887



  return code;




×







1888



}










1889












1890



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











UNCOV

1891



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




×







1892



                                      int32_t numOfPk) {










1893



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











UNCOV

1894



  if (ASCENDING_TRAVERSE(order)) {





×








UNCOV

1895



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





×








UNCOV

1896



      if (numOfPk > 0) {





×








UNCOV

1897



        SValue v1 = {.type = pkType};




×








UNCOV

1898



        if (IS_VAR_DATA_TYPE(pkType)) {





×







1899



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




×







1900



        } else {











UNCOV

1901



          v1.val = pBlock->lastPk.val;




×







1902



        }











UNCOV

1903



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




×







1904



      } else {  // no pk











UNCOV

1905



        return true;




×







1906



      }










1907



    } else {











UNCOV

1908



      return false;




×







1909



    }










1910



  } else {











UNCOV

1911



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





×








UNCOV

1912



      if (numOfPk > 0) {





×








UNCOV

1913



        SValue v1 = {.type = pkType};




×








UNCOV

1914



        if (IS_VAR_DATA_TYPE(pkType)) {





×







1915



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




×







1916



        } else {











UNCOV

1917



          v1.val = pBlock->firstPk.val;




×







1918



        }











UNCOV

1919



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




×







1920



      } else {  // no pk










1921



        return true;




×







1922



      }










1923



    } else {











UNCOV

1924



      return false;




×







1925



    }










1926



  }










1927



}










1928













UNCOV

1929



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




×








UNCOV

1930



  bool ascScan = ASCENDING_TRAVERSE(order);




×







1931













UNCOV

1932



  int64_t key = 0;




×








UNCOV

1933



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





×








UNCOV

1934



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




×








UNCOV

1935



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





×







1936



  } else {











UNCOV

1937



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





×







1938



  }










1939













UNCOV

1940



  return key;




×







1941



}










1942













UNCOV

1943



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




×







1944



                                     int32_t order) {











UNCOV

1945



  bool    ascScan = ASCENDING_TRAVERSE(order);




×








UNCOV

1946



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




×







1947













UNCOV

1948



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





×








UNCOV

1949



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





×







1950



}










1951













UNCOV

1952



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




×








UNCOV

1953



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





×








UNCOV

1954



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





×







1955



}










1956













UNCOV

1957



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




×







1958



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











UNCOV

1959



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

1960



  int32_t             lino = 0;




×








UNCOV

1961



  SBrinRecord         rec = {0};




×








UNCOV

1962



  int32_t             neighborIndex = 0;




×








UNCOV

1963



  int32_t             order = 0;




×








UNCOV

1964



  SBlockLoadSuppInfo* pSupInfo = NULL;




×







1965



  SBrinRecord         pRecord;











UNCOV

1966



  bool                hasNeighbor = false;




×







1967













UNCOV

1968



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





×








UNCOV

1969



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





×







1970













UNCOV

1971



  order = pReader->info.order;




×








UNCOV

1972



  pSupInfo = &pReader->suppInfo;




×







1973













UNCOV

1974



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




×







1975



                                 pSupInfo, &hasNeighbor);











UNCOV

1976



  TSDB_CHECK_CODE(code, lino, _end);





×







1977












1978



  // overlap with neighbor











UNCOV

1979



  if (hasNeighbor) {





×








UNCOV

1980



    pInfo->overlapWithNeighborBlock =




×








UNCOV

1981



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




×







1982



  }










1983













UNCOV

1984



  blockInfoToRecord(&pRecord, pBlockInfo, pSupInfo);




×







1985












1986



  // has duplicated ts of different version in this block











UNCOV

1987



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





×








UNCOV

1988



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




×







1989












1990



  // todo handle the primary key overlap case











UNCOV

1991



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





×








UNCOV

1992



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




×








UNCOV

1993



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





×







1994



  }










1995













UNCOV

1996



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




×








UNCOV

1997



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




×








UNCOV

1998



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




×







1999













UNCOV

2000



_end:




×








UNCOV

2001



  if (code != TSDB_CODE_SUCCESS) {





×







2002



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





×







2003



  }











UNCOV

2004



  return code;




×







2005



}










2006












2007



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










2008



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










2009



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










2010



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










2011



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










2012



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











UNCOV

2013



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




×







2014



                                   TSDBKEY keyInBuf, bool* load) {











UNCOV

2015



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

2016



  int32_t              lino = 0;




×








UNCOV

2017



  SDataBlockToLoadInfo info = {0};




×







2018













UNCOV

2019



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





×







2020













UNCOV

2021



  *load = false;




×








UNCOV

2022



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




×








UNCOV

2023



  TSDB_CHECK_CODE(code, lino, _end);





×







2024













UNCOV

2025



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





×








UNCOV

2026



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





×







2027












2028



  // log the reason why load the datablock for profile











UNCOV

2029



  if (*load) {





×








UNCOV

2030



    tsdbDebug("%p uid:%" PRIu64





×







2031



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










2032



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










2033



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










2034



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










2035



              pReader->idStr);










2036



  }










2037













UNCOV

2038



_end:




×








UNCOV

2039



  if (code != TSDB_CODE_SUCCESS) {





×







2040



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





×







2041



  }











UNCOV

2042



  return code;




×







2043



}










2044













UNCOV

2045



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




×







2046



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











UNCOV

2047



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

2048



  int32_t              lino = 0;




×








UNCOV

2049



  SDataBlockToLoadInfo info = {0};




×







2050













UNCOV

2051



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





×







2052













UNCOV

2053



  *res = false;




×








UNCOV

2054



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




×








UNCOV

2055



  TSDB_CHECK_CODE(code, lino, _end);





×







2056













UNCOV

2057



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





×








UNCOV

2058



           info.overlapWithSttBlock);





×







2059













UNCOV

2060



_end:




×








UNCOV

2061



  if (code != TSDB_CODE_SUCCESS) {





×







2062



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





×







2063



  }











UNCOV

2064



  return code;




×







2065



}










2066













UNCOV

2067



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




×








UNCOV

2068



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

2069



  int32_t     lino = 0;




×








UNCOV

2070



  SRowMerger* pMerger = NULL;




×








UNCOV

2071



  STSchema*   ps = NULL;




×







2072













UNCOV

2073



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





×







2074













UNCOV

2075



  pMerger = &pReader->status.merger;




×







2076













UNCOV

2077



  if (pMerger->pArray == NULL) {





×








UNCOV

2078



    ps = getTableSchemaImpl(pReader, uid);





×








UNCOV

2079



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





×







2080



  }










2081













UNCOV

2082



_end:




×








UNCOV

2083



  if (code != TSDB_CODE_SUCCESS) {





×







2084



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





×







2085



  }











UNCOV

2086



  return code;




×







2087



}










2088













UNCOV

2089



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




×








UNCOV

2090



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

2091



  int32_t      lino = 0;




×








UNCOV

2092



  int64_t      st = 0;




×








UNCOV

2093



  SSDataBlock* pBlock = NULL;




×







2094













UNCOV

2095



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





×







2096













UNCOV

2097



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





×








UNCOV

2098



    goto _end;




×







2099



  }










2100













UNCOV

2101



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




×








UNCOV

2102



  TSDB_CHECK_CODE(code, lino, _end);





×







2103













UNCOV

2104



  st = taosGetTimestampUs();




×








UNCOV

2105



  pBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

2106



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




×








UNCOV

2107



  TSDB_CHECK_CODE(code, lino, _end);





×







2108













UNCOV

2109



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




×








UNCOV

2110



  updateComposedBlockInfo(pReader, el, pBlockScanInfo);




×







2111













UNCOV

2112



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





×







2113



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










2114



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










2115



            pReader->idStr);










2116













UNCOV

2117



  pReader->cost.buildmemBlock += el;




×







2118













UNCOV

2119



_end:




×








UNCOV

2120



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

2121



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





×







2122



  }











UNCOV

2123



  return code;




×







2124



}










2125













UNCOV

2126



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




×







2127



                                               SFileBlockDumpInfo* pDumpInfo, bool* copied) {










2128



  // opt version










2129



  // 1. it is not a border point










2130



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











UNCOV

2131



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

2132



  int32_t lino = 0;




×








UNCOV

2133



  bool    asc = false;




×







2134













UNCOV

2135



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





×








UNCOV

2136



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





×








UNCOV

2137



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





×







2138













UNCOV

2139



  *copied = false;




×








UNCOV

2140



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




×








UNCOV

2141



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





×








UNCOV

2142



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





×







2143












2144



    SRowKey nextRowKey;











UNCOV

2145



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





×








UNCOV

2146



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





×







2147













UNCOV

2148



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





×








UNCOV

2149



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




×








UNCOV

2150



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2151



      pDumpInfo->rowIndex += step;




×








UNCOV

2152



      *copied = true;




×







2153



    }










2154



  }










2155













UNCOV

2156



_end:




×








UNCOV

2157



  if (code != TSDB_CODE_SUCCESS) {





×







2158



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





×







2159



  }











UNCOV

2160



  return code;




×







2161



}










2162













UNCOV

2163



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




×







2164



                                    SVersionRange* pVerRange) {











UNCOV

2165



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

2166



  int32_t  lino = 0;




×








UNCOV

2167



  int32_t  order = 0;




×








UNCOV

2168



  int32_t  step = 0;




×








UNCOV

2169



  SRowKey* pNextProc = NULL;




×







2170













UNCOV

2171



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





×








UNCOV

2172



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





×







2173













UNCOV

2174



  order = pSttBlockReader->order;




×








UNCOV

2175



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





×








UNCOV

2176



  pNextProc = &pScanInfo->sttKeyInfo.nextProcKey;




×







2177













UNCOV

2178



  while (1) {




×








UNCOV

2179



    bool hasVal = false;




×








UNCOV

2180



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




×








UNCOV

2181



    if (code) {





×







2182



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





×







2183



                pSttBlockReader->mergeTree.idStr);











UNCOV

2184



      TSDB_CHECK_CODE(code, lino, _end);





×







2185



    }










2186













UNCOV

2187



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





×








UNCOV

2188



      pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;




×







2189












2190



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











UNCOV

2191



      pNextProc->ts += step;




×








UNCOV

2192



      if (pSttBlockReader->numOfPks > 0) {





×








UNCOV

2193



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





×








UNCOV

2194



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




×







2195



        } else {











UNCOV

2196



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




×







2197



        }










2198



      }











UNCOV

2199



      goto _end;




×







2200



    }










2201













UNCOV

2202



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




×








UNCOV

2203



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




×








UNCOV

2204



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




×







2205













UNCOV

2206



    if (pSttBlockReader->numOfPks == 0) {





×








UNCOV

2207



      pSttBlockReader->currentKey.ts = key;




×







2208



    } else {











UNCOV

2209



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





×







2210



    }










2211













UNCOV

2212



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





×







2213













UNCOV

2214



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





×








UNCOV

2215



      bool dropped = false;




×








UNCOV

2216



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




×








UNCOV

2217



                            pSttBlockReader->numOfPks > 0, &dropped);




×








UNCOV

2218



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2219



      if (!dropped) {





×








UNCOV

2220



        pScanInfo->sttKeyInfo.status = STT_FILE_HAS_DATA;




×








UNCOV

2221



        goto _end;




×







2222



      }










2223



    } else {











UNCOV

2224



      pScanInfo->sttKeyInfo.status = STT_FILE_HAS_DATA;




×








UNCOV

2225



      goto _end;




×







2226



    }










2227



  }










2228













UNCOV

2229



_end:




×








UNCOV

2230



  if (code != TSDB_CODE_SUCCESS) {





×







2231



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





×







2232



  }











UNCOV

2233



  return code;




×







2234



}










2235













UNCOV

2236



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




×







2237













UNCOV

2238



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




×







2239













UNCOV

2240



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




×







2241



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










2242



                                              bool* copied) {











UNCOV

2243



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

2244



  int32_t  lino = 0;




×








UNCOV

2245



  SRowKey* pNext = NULL;




×







2246













UNCOV

2247



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





×








UNCOV

2248



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





×








UNCOV

2249



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





×







2250













UNCOV

2251



  *copied = false;




×







2252












2253



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











UNCOV

2254



  doPinSttBlock(pSttBlockReader);




×








UNCOV

2255



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




×








UNCOV

2256



  doUnpinSttBlock(pSttBlockReader);




×








UNCOV

2257



  TSDB_CHECK_CODE(code, lino, _end);





×







2258













UNCOV

2259



  if (hasDataInSttBlock(pScanInfo)) {





×








UNCOV

2260



    pNext = getCurrentKeyInSttBlock(pSttBlockReader);





×








UNCOV

2261



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





×








UNCOV

2262



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




×








UNCOV

2263



      *copied = (code == TSDB_CODE_SUCCESS);




×








UNCOV

2264



      TSDB_CHECK_CODE(code, lino, _end);





×







2265



    }










2266



  } else {











UNCOV

2267



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




×








UNCOV

2268



    *copied = (code == TSDB_CODE_SUCCESS);




×








UNCOV

2269



    TSDB_CHECK_CODE(code, lino, _end);





×







2270



  }










2271













UNCOV

2272



_end:




×








UNCOV

2273



  if (code != TSDB_CODE_SUCCESS) {





×







2274



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





×







2275



  }











UNCOV

2276



  return code;




×







2277



}










2278












2279



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











UNCOV

2280



  int32_t   code = TSDB_CODE_SUCCESS;




×








UNCOV

2281



  int32_t   lino = 0;




×








UNCOV

2282



  STSchema* ps = NULL;




×








UNCOV

2283



  void**    p = NULL;




×







2284













UNCOV

2285



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





×







2286












2287



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











UNCOV

2288



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





×







2289



    ps = getTableSchemaImpl(pReader, uid);




×







2290



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





×







2291



  }










2292













UNCOV

2293



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





×








UNCOV

2294



    ps = pReader->info.pSchema;




×








UNCOV

2295



    goto _end;




×







2296



  }










2297













UNCOV

2298



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




×








UNCOV

2299



  if (p != NULL) {





×








UNCOV

2300



    ps = *(STSchema**)p;




×








UNCOV

2301



    goto _end;




×







2302



  }










2303













UNCOV

2304



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




×








UNCOV

2305



  TSDB_CHECK_CODE(code, lino, _end);





×







2306













UNCOV

2307



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




×








UNCOV

2308



  TSDB_CHECK_CODE(code, lino, _end);





×







2309













UNCOV

2310



_end:




×








UNCOV

2311



  if (code != TSDB_CODE_SUCCESS) {





×







2312



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





×







2313



    terrno = code;




×







2314



    return NULL;




×







2315



  }











UNCOV

2316



  return ps;




×







2317



}










2318













UNCOV

2319



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




×







2320



                                     SIterInfo* pIter, SSttBlockReader* pSttBlockReader) {











UNCOV

2321



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

2322



  int32_t             lino = 0;




×








UNCOV

2323



  SRowMerger*         pMerger = NULL;




×








UNCOV

2324



  SRow*               pTSRow = NULL;




×








UNCOV

2325



  SBlockData*         pBlockData = NULL;




×








UNCOV

2326



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

2327



  SRowKey*            pSttKey = NULL;




×








UNCOV

2328



  int32_t             pkSrcSlot = 0;




×








UNCOV

2329



  SRowKey             k = {0};




×








UNCOV

2330



  STSchema*           pSchema = NULL;




×







2331













UNCOV

2332



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





×








UNCOV

2333



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





×








UNCOV

2334



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





×







2335













UNCOV

2336



  pMerger = &pReader->status.merger;




×








UNCOV

2337



  pBlockData = &pReader->status.fileBlockData;




×








UNCOV

2338



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

2339



  pkSrcSlot = pReader->suppInfo.pkSrcSlot;




×







2340













UNCOV

2341



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





×








UNCOV

2342



    pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);




×







2343



  }










2344













UNCOV

2345



  tRowGetKeyEx(pRow, &k);





×







2346













UNCOV

2347



  if (pRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

2348



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





×








UNCOV

2349



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





×







2350



  }










2351













UNCOV

2352



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




×








UNCOV

2353



  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {





×








UNCOV

2354



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





×







2355



  } else {











UNCOV

2356



    pfKey = NULL;




×







2357



  }










2358













UNCOV

2359



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




×







2360












2361



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











UNCOV

2362



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




×








UNCOV

2363



  TSDB_CHECK_CODE(code, lino, _end);





×







2364













UNCOV

2365



  SRowKey minKey = k;




×








UNCOV

2366



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





×








UNCOV

2367



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





×








UNCOV

2368



      minKey = *pfKey;




×







2369



    }










2370













UNCOV

2371



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





×








UNCOV

2372



      minKey = *pSttKey;




×







2373



    }










2374



  } else {











UNCOV

2375



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





×








UNCOV

2376



      minKey = *pfKey;




×







2377



    }










2378













UNCOV

2379



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





×








UNCOV

2380



      minKey = *pSttKey;




×







2381



    }










2382



  }










2383












2384



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










2385



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











UNCOV

2386



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




×







2387












2388



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











UNCOV

2389



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





×








UNCOV

2390



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




×








UNCOV

2391



    TSDB_CHECK_CODE(code, lino, _end);





×







2392













UNCOV

2393



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




×








UNCOV

2394



    TSDB_CHECK_CODE(code, lino, _end);





×







2395



  }










2396













UNCOV

2397



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





×








UNCOV

2398



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




×








UNCOV

2399



    code = tsdbRowMergerAdd(pMerger, fRow1, NULL);




×








UNCOV

2400



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2401



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




×








UNCOV

2402



                                 pReader->idStr);




×








UNCOV

2403



    TSDB_CHECK_CODE(code, lino, _end);





×







2404



  }










2405













UNCOV

2406



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





×








UNCOV

2407



    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);




×








UNCOV

2408



    TSDB_CHECK_CODE(code, lino, _end);





×







2409













UNCOV

2410



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




×








UNCOV

2411



    TSDB_CHECK_CODE(code, lino, _end);





×







2412



  }










2413













UNCOV

2414



  code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

2415



  TSDB_CHECK_CODE(code, lino, _end);





×







2416













UNCOV

2417



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




×







2418













UNCOV

2419



  taosMemoryFreeClear(pTSRow);





×








UNCOV

2420



  tsdbRowMergerClear(pMerger);




×








UNCOV

2421



  TSDB_CHECK_CODE(code, lino, _end);





×







2422













UNCOV

2423



_end:




×








UNCOV

2424



  if (code != TSDB_CODE_SUCCESS) {





×







2425



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





×







2426



  }











UNCOV

2427



  return code;




×







2428



}










2429













UNCOV

2430



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




×







2431



                                         STableBlockScanInfo* pBlockScanInfo, SBlockData* pBlockData) {











UNCOV

2432



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

2433



  int32_t             lino = 0;




×








UNCOV

2434



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

2435



  SRowMerger*         pMerger = NULL;




×








UNCOV

2436



  SRow*               pTSRow = NULL;




×








UNCOV

2437



  int32_t             pkSrcSlot = 0;




×







2438













UNCOV

2439



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





×








UNCOV

2440



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





×








UNCOV

2441



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





×







2442













UNCOV

2443



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

2444



  pMerger = &pReader->status.merger;




×








UNCOV

2445



  pkSrcSlot = pReader->suppInfo.pkSrcSlot;




×







2446












2447



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











UNCOV

2448



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




×








UNCOV

2449



  TSDB_CHECK_CODE(code, lino, _end);





×







2450













UNCOV

2451



  bool dataInDataFile = hasDataInFileBlock(pBlockData, pDumpInfo);




×








UNCOV

2452



  bool dataInSttFile = hasDataInSttBlock(pBlockScanInfo);




×







2453













UNCOV

2454



  if (dataInDataFile && (!dataInSttFile)) {





×







2455



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











UNCOV

2456



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




×








UNCOV

2457



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2458



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





×







2459



    // no data in data file exists











UNCOV

2460



    code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);




×








UNCOV

2461



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2462



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





×







2463



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











UNCOV

2464



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




×








UNCOV

2465



    TSDB_CHECK_CODE(code, lino, _end);





×







2466



  } else {











UNCOV

2467



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





×







2468



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











UNCOV

2469



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




×








UNCOV

2470



    SRowKey* pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);





×







2471













UNCOV

2472



    int32_t ret = pkCompEx(pKey, pSttKey);




×







2473













UNCOV

2474



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





×








UNCOV

2475



      if (ret < 0) {  // asc





×








UNCOV

2476



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




×








UNCOV

2477



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2478



      } else if (ret > 0) {





×








UNCOV

2479



        code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);




×








UNCOV

2480



        TSDB_CHECK_CODE(code, lino, _end);





×







2481



      }










2482



    } else {  // desc











UNCOV

2483



      if (ret > 0) {





×








UNCOV

2484



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




×








UNCOV

2485



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2486



      } else if (ret < 0) {





×








UNCOV

2487



        code = mergeRowsInSttBlocks(pSttBlockReader, pBlockScanInfo, pReader);




×








UNCOV

2488



        TSDB_CHECK_CODE(code, lino, _end);





×







2489



      }










2490



    }











UNCOV

2491



    if (ret != 0) {





×








UNCOV

2492



      goto _end;




×







2493



    }










2494












2495



    // pKey == pSttKey











UNCOV

2496



    tRowKeyAssign(&pBlockScanInfo->lastProcKey, pKey);




×







2497












2498



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










2499



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










2500













UNCOV

2501



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




×








UNCOV

2502



    TSDB_CHECK_CODE(code, lino, _end);





×







2503













UNCOV

2504



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




×








UNCOV

2505



    TSDB_CHECK_CODE(code, lino, _end);





×







2506













UNCOV

2507



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




×








UNCOV

2508



    code = tsdbRowMergerAdd(pMerger, pRow1, NULL);




×








UNCOV

2509



    TSDB_CHECK_CODE(code, lino, _end);





×







2510












2511



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











UNCOV

2512



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




×








UNCOV

2513



                                 pReader->idStr);




×








UNCOV

2514



    TSDB_CHECK_CODE(code, lino, _end);





×







2515













UNCOV

2516



    code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

2517



    TSDB_CHECK_CODE(code, lino, _end);





×







2518













UNCOV

2519



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




×







2520













UNCOV

2521



    taosMemoryFreeClear(pTSRow);





×








UNCOV

2522



    tsdbRowMergerClear(pMerger);




×








UNCOV

2523



    TSDB_CHECK_CODE(code, lino, _end);





×







2524



  }










2525













UNCOV

2526



_end:




×








UNCOV

2527



  if (code != TSDB_CODE_SUCCESS) {





×







2528



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





×







2529



  }











UNCOV

2530



  return code;




×







2531



}










2532













UNCOV

2533



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




×







2534



                                     SSttBlockReader* pSttBlockReader) {











UNCOV

2535



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

2536



  int32_t             lino = 0;




×








UNCOV

2537



  SRowMerger*         pMerger = NULL;




×








UNCOV

2538



  SRow*               pTSRow = NULL;




×








UNCOV

2539



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

2540



  SArray*             pDelList = NULL;




×








UNCOV

2541



  int32_t             pkSrcSlot = 0;




×








UNCOV

2542



  TSDBROW*            pRow = NULL;




×








UNCOV

2543



  TSDBROW*            piRow = NULL;




×








UNCOV

2544



  SRowKey*            pSttKey = NULL;




×







2545













UNCOV

2546



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





×








UNCOV

2547



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





×








UNCOV

2548



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





×







2549













UNCOV

2550



  pMerger = &pReader->status.merger;




×








UNCOV

2551



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

2552



  pDelList = pBlockScanInfo->delSkyline;




×








UNCOV

2553



  pkSrcSlot = pReader->suppInfo.pkSrcSlot;




×







2554













UNCOV

2555



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




×








UNCOV

2556



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2557



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




×








UNCOV

2558



  TSDB_CHECK_CODE(code, lino, _end);





×







2559













UNCOV

2560



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





×








UNCOV

2561



    pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);




×







2562



  }










2563













UNCOV

2564



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




×








UNCOV

2565



  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {





×








UNCOV

2566



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





×







2567



  } else {











UNCOV

2568



    pfKey = NULL;




×







2569



  }










2570













UNCOV

2571



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




×








UNCOV

2572



  tRowGetKeyEx(pRow, &k);





×








UNCOV

2573



  tRowGetKeyEx(piRow, &ik);





×







2574













UNCOV

2575



  STSchema* pSchema = NULL;




×








UNCOV

2576



  if (pRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

2577



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





×








UNCOV

2578



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





×







2579



  }










2580













UNCOV

2581



  STSchema* piSchema = NULL;




×








UNCOV

2582



  if (piRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

2583



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





×








UNCOV

2584



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





×







2585



  }










2586












2587



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











UNCOV

2588



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




×








UNCOV

2589



  TSDB_CHECK_CODE(code, lino, _end);





×







2590













UNCOV

2591



  SRowKey minKey = k;




×








UNCOV

2592



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





×








UNCOV

2593



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





×








UNCOV

2594



      minKey = ik;




×







2595



    }










2596













UNCOV

2597



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





×







2598



      minKey = *pfKey;




×







2599



    }










2600













UNCOV

2601



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





×








UNCOV

2602



      minKey = *pSttKey;




×







2603



    }










2604



  } else {











UNCOV

2605



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





×







2606



      minKey = ik;




×







2607



    }










2608













UNCOV

2609



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





×







2610



      minKey = *pfKey;




×







2611



    }










2612













UNCOV

2613



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





×







2614



      minKey = *pSttKey;




×







2615



    }










2616



  }










2617













UNCOV

2618



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




×







2619












2620



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











UNCOV

2621



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





×







2622



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




×







2623



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




×







2624



    TSDB_CHECK_CODE(code, lino, _end);





×







2625












2626



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




×







2627



    TSDB_CHECK_CODE(code, lino, _end);





×







2628



  }










2629













UNCOV

2630



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





×








UNCOV

2631



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




×








UNCOV

2632



    code = tsdbRowMergerAdd(pMerger, pRow1, NULL);




×








UNCOV

2633



    TSDB_CHECK_CODE(code, lino, _end);





×







2634













UNCOV

2635



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




×








UNCOV

2636



                                 pReader->idStr);




×








UNCOV

2637



    TSDB_CHECK_CODE(code, lino, _end);





×







2638



  }










2639













UNCOV

2640



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





×








UNCOV

2641



    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);




×








UNCOV

2642



    TSDB_CHECK_CODE(code, lino, _end);





×







2643













UNCOV

2644



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




×








UNCOV

2645



    TSDB_CHECK_CODE(code, lino, _end);





×







2646



  }










2647













UNCOV

2648



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





×








UNCOV

2649



    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);




×








UNCOV

2650



    TSDB_CHECK_CODE(code, lino, _end);





×







2651













UNCOV

2652



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




×








UNCOV

2653



    TSDB_CHECK_CODE(code, lino, _end);





×







2654



  }










2655













UNCOV

2656



  code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

2657



  TSDB_CHECK_CODE(code, lino, _end);





×







2658













UNCOV

2659



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




×







2660













UNCOV

2661



  taosMemoryFreeClear(pTSRow);





×








UNCOV

2662



  tsdbRowMergerClear(pMerger);




×








UNCOV

2663



  TSDB_CHECK_CODE(code, lino, _end);





×







2664













UNCOV

2665



_end:




×








UNCOV

2666



  if (code != TSDB_CODE_SUCCESS) {





×







2667



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





×







2668



  }











UNCOV

2669



  return code;




×







2670



}










2671













UNCOV

2672



int32_t doInitMemDataIter(STsdbReader* pReader, STbData** pData, STableBlockScanInfo* pBlockScanInfo, STsdbRowKey* pKey,




×







2673



                          SMemTable* pMem, SIterInfo* pIter, const char* type) {











UNCOV

2674



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

2675



  int32_t lino = 0;




×








UNCOV

2676



  int32_t backward = false;




×







2677













UNCOV

2678



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





×








UNCOV

2679



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





×








UNCOV

2680



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





×








UNCOV

2681



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





×







2682













UNCOV

2683



  backward = (!ASCENDING_TRAVERSE(pReader->info.order));




×








UNCOV

2684



  pIter->hasVal = false;




×







2685













UNCOV

2686



  if (pMem != NULL) {





×








UNCOV

2687



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





×








UNCOV

2688



    *pData = tsdbGetTbDataFromMemTable(pMem, pReader->info.suid, pBlockScanInfo->uid);




×







2689













UNCOV

2690



    if ((*pData) != NULL) {





×








UNCOV

2691



      code = tsdbTbDataIterCreate((*pData), pKey, backward, &pIter->iter);




×








UNCOV

2692



      if (code == TSDB_CODE_SUCCESS) {





×








UNCOV

2693



        pIter->hasVal = (tsdbTbDataIterGet(pIter->iter) != NULL);





×







2694













UNCOV

2695



        tsdbDebug("%p uid:%" PRIu64 ", check data in %s from skey:%" PRId64 ", order:%d, ts range in buf:%" PRId64





×







2696



                  "-%" PRId64 " %s",










2697



                  pReader, pBlockScanInfo->uid, type, pKey->key.ts, pReader->info.order, (*pData)->minKey,










2698



                  (*pData)->maxKey, pReader->idStr);










2699



      } else {










2700



        tsdbError("%p uid:%" PRIu64 ", failed to create iterator for %s, code:%s, %s", pReader, pBlockScanInfo->uid,





×







2701



                  type, tstrerror(code), pReader->idStr);










2702



        TSDB_CHECK_CODE(code, lino, _end);





×







2703



      }










2704



    }










2705



  } else {











UNCOV

2706



    tsdbDebug("%p uid:%" PRIu64 ", no data in %s, %s", pReader, pBlockScanInfo->uid, type, pReader->idStr);





×







2707



  }










2708













UNCOV

2709



_end:




×








UNCOV

2710



  if (code != TSDB_CODE_SUCCESS) {





×







2711



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





×







2712



  }











UNCOV

2713



  return code;




×







2714



}










2715













UNCOV

2716



static int32_t doForwardDataIter(SRowKey* pKey, SIterInfo* pIter, STableBlockScanInfo* pBlockScanInfo,




×







2717



                                 STsdbReader* pReader) {











UNCOV

2718



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

2719



  int32_t  lino = 0;




×








UNCOV

2720



  SRowKey  rowKey = {0};




×








UNCOV

2721



  TSDBROW* pRow = NULL;




×







2722













UNCOV

2723



  while (1) {




×








UNCOV

2724



    code = getValidMemRow(pIter, pBlockScanInfo->delSkyline, pReader, &pRow);




×








UNCOV

2725



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2726



    if (!pIter->hasVal) {





×








UNCOV

2727



      break;




×







2728



    }










2729













UNCOV

2730



    tRowGetKeyEx(pRow, &rowKey);





×








UNCOV

2731



    int32_t ret = pkCompEx(pKey, &rowKey);




×








UNCOV

2732



    if (ret == 0) {





×







2733



      pIter->hasVal = tsdbTbDataIterNext(pIter->iter);




×







2734



    } else {











UNCOV

2735



      break;




×







2736



    }










2737



  }










2738













UNCOV

2739



_end:




×








UNCOV

2740



  if (code != TSDB_CODE_SUCCESS) {





×







2741



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





×







2742



  }











UNCOV

2743



  return code;




×







2744



}










2745












2746



// handle the open interval issue. Find the first row key that is greater than the given one.











UNCOV

2747



static int32_t forwardDataIter(SRowKey* pKey, STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader) {




×








UNCOV

2748



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

2749



  int32_t lino = 0;




×







2750













UNCOV

2751



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





×








UNCOV

2752



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





×







2753













UNCOV

2754



  code = doForwardDataIter(pKey, &pBlockScanInfo->iter, pBlockScanInfo, pReader);




×








UNCOV

2755



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2756



  code = doForwardDataIter(pKey, &pBlockScanInfo->iiter, pBlockScanInfo, pReader);




×








UNCOV

2757



  TSDB_CHECK_CODE(code, lino, _end);





×







2758













UNCOV

2759



_end:




×








UNCOV

2760



  if (code != TSDB_CODE_SUCCESS) {





×







2761



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





×







2762



  }











UNCOV

2763



  return code;




×







2764



}










2765













UNCOV

2766



static int32_t initMemDataIterator(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader) {




×








UNCOV

2767



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

2768



  int32_t        lino = 0;




×








UNCOV

2769



  STbData*       d = NULL;




×








UNCOV

2770



  STbData*       di = NULL;




×








UNCOV

2771



  bool           asc = false;




×








UNCOV

2772



  bool           forward = true;




×








UNCOV

2773



  STsdbReadSnap* pSnap = NULL;




×








UNCOV

2774



  STimeWindow*   pWindow = NULL;




×







2775



  STsdbRowKey    startKey;










2776













UNCOV

2777



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





×








UNCOV

2778



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





×







2779













UNCOV

2780



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




×








UNCOV

2781



  pSnap = pReader->pReadSnap;




×








UNCOV

2782



  pWindow = &pReader->info.window;




×







2783













UNCOV

2784



  if (pBlockScanInfo->iterInit) {





×








UNCOV

2785



    goto _end;




×







2786



  }










2787













UNCOV

2788



  startKey.key = pBlockScanInfo->lastProcKey;




×








UNCOV

2789



  startKey.version = asc ? pReader->info.verRange.minVer : pReader->info.verRange.maxVer;





×








UNCOV

2790



  if ((asc && (startKey.key.ts < pWindow->skey)) || ((!asc) && startKey.key.ts > pWindow->ekey)) {





×








UNCOV

2791



    startKey.key.ts = asc ? pWindow->skey : pWindow->ekey;





×








UNCOV

2792



    forward = false;




×







2793



  }










2794













UNCOV

2795



  code = doInitMemDataIter(pReader, &d, pBlockScanInfo, &startKey, pSnap->pMem, &pBlockScanInfo->iter, "mem");




×








UNCOV

2796



  TSDB_CHECK_CODE(code, lino, _end);





×







2797













UNCOV

2798



  code = doInitMemDataIter(pReader, &di, pBlockScanInfo, &startKey, pSnap->pIMem, &pBlockScanInfo->iiter, "imem");




×








UNCOV

2799



  TSDB_CHECK_CODE(code, lino, _end);





×







2800













UNCOV

2801



  code = loadMemTombData(&pBlockScanInfo->pMemDelData, d, di, pReader->info.verRange.maxVer);




×








UNCOV

2802



  TSDB_CHECK_CODE(code, lino, _end);





×







2803













UNCOV

2804



  if (forward) {





×








UNCOV

2805



    code = forwardDataIter(&startKey.key, pBlockScanInfo, pReader);




×








UNCOV

2806



    TSDB_CHECK_CODE(code, lino, _end);





×







2807



  }










2808













UNCOV

2809



  pBlockScanInfo->iterInit = true;




×







2810













UNCOV

2811



_end:




×








UNCOV

2812



  if (code != TSDB_CODE_SUCCESS) {





×







2813



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





×







2814



  }











UNCOV

2815



  return code;




×







2816



}










2817













UNCOV

2818



static int32_t isValidFileBlockRow(SBlockData* pBlockData, int32_t rowIndex, STableBlockScanInfo* pBlockScanInfo,




×







2819



                                   bool asc, STsdbReaderInfo* pInfo, STsdbReader* pReader, bool* valid) {











UNCOV

2820



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

2821



  int32_t lino = 0;




×







2822













UNCOV

2823



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





×








UNCOV

2824



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





×







2825













UNCOV

2826



  *valid = false;




×







2827



  // it is an multi-table data block











UNCOV

2828



  if (pBlockData->aUid != NULL) {





×







2829



    uint64_t uid = pBlockData->aUid[rowIndex];




×







2830



    if (uid != pBlockScanInfo->uid) {  // move to next row





×







2831



      *valid = false;




×







2832



      goto _end;




×







2833



    }










2834



  }










2835













UNCOV

2836



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





×







2837



  // check for version and time range











UNCOV

2838



  int64_t ver = pBlockData->aVersion[rowIndex];




×








UNCOV

2839



  if (ver > pInfo->verRange.maxVer || ver < pInfo->verRange.minVer) {





×







2840



    *valid = false;




×







2841



    goto _end;




×







2842



  }










2843













UNCOV

2844



  int64_t ts = pBlockData->aTSKEY[rowIndex];




×








UNCOV

2845



  if (ts > pInfo->window.ekey || ts < pInfo->window.skey) {





×








UNCOV

2846



    *valid = false;




×








UNCOV

2847



    goto _end;




×







2848



  }










2849













UNCOV

2850



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





×








UNCOV

2851



  if ((asc && (ts < pBlockScanInfo->lastProcKey.ts)) || ((!asc) && (ts > pBlockScanInfo->lastProcKey.ts))) {





×







2852



    *valid = false;




×







2853



    goto _end;




×







2854



  }










2855













UNCOV

2856



  if (ts == pBlockScanInfo->lastProcKey.ts) {  // todo opt perf





×







2857



    SRowKey nextRowKey;                        // lazy eval











UNCOV

2858



    tColRowGetKey(pBlockData, rowIndex, &nextRowKey);





×








UNCOV

2859



    if (pkCompEx(&pBlockScanInfo->lastProcKey, &nextRowKey) == 0) {





×







2860



      *valid = false;




×







2861



      goto _end;




×







2862



    }










2863



  }










2864













UNCOV

2865



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





×








UNCOV

2866



    bool dropped = false;




×








UNCOV

2867



    code = hasBeenDropped(pBlockScanInfo->delSkyline, &pBlockScanInfo->fileDelIndex, ts, ver, pInfo->order,




×








UNCOV

2868



                          &pInfo->verRange, pReader->suppInfo.numOfPks > 0, &dropped);




×








UNCOV

2869



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

2870



    if (dropped) {





×








UNCOV

2871



      *valid = false;




×








UNCOV

2872



      goto _end;




×







2873



    }










2874



  }










2875













UNCOV

2876



  *valid = true;




×







2877













UNCOV

2878



_end:




×








UNCOV

2879



  if (code != TSDB_CODE_SUCCESS) {





×







2880



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





×







2881



  }











UNCOV

2882



  return code;




×







2883



}










2884













UNCOV

2885



static void initSttBlockReader(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, STsdbReader* pReader) {




×








UNCOV

2886



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

2887



  int32_t              lino = 0;




×








UNCOV

2888



  int32_t              order = 0;




×








UNCOV

2889



  bool                 asc = false;




×








UNCOV

2890



  int64_t              st = 0;




×








UNCOV

2891



  SSttDataInfoForTable info = (SSttDataInfoForTable){0};




×







2892













UNCOV

2893



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





×








UNCOV

2894



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





×








UNCOV

2895



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





×







2896













UNCOV

2897



  order = pReader->info.order;




×








UNCOV

2898



  asc = ASCENDING_TRAVERSE(order);




×







2899












2900



  // the stt block reader has been initialized for this table.











UNCOV

2901



  if (pSttBlockReader->uid == pScanInfo->uid) {





×








UNCOV

2902



    goto _end;




×







2903



  }










2904













UNCOV

2905



  if (pSttBlockReader->uid != 0) {





×








UNCOV

2906



    tMergeTreeClose(&pSttBlockReader->mergeTree);




×







2907



  }










2908













UNCOV

2909



  pSttBlockReader->uid = pScanInfo->uid;




×







2910












2911



  // second or third time init stt block reader











UNCOV

2912



  if (pScanInfo->cleanSttBlocks && (pReader->info.execMode == READER_EXEC_ROWS)) {





×







2913



    // only allowed to retrieve clean stt blocks for count once










2914



    if (pScanInfo->sttBlockReturned) {





×







2915



      pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;




×







2916



      tsdbDebug("uid:%" PRIu64 " set no stt-file data after stt-block retrieved, %s", pScanInfo->uid, pReader->idStr);





×







2917



    }










2918



    goto _end;




×







2919



  }










2920













UNCOV

2921



  STimeWindow w = pSttBlockReader->window;




×








UNCOV

2922



  if (asc) {





×








UNCOV

2923



    w.skey = pScanInfo->sttKeyInfo.nextProcKey.ts;




×







2924



  } else {











UNCOV

2925



    w.ekey = pScanInfo->sttKeyInfo.nextProcKey.ts;




×







2926



  }










2927













UNCOV

2928



  st = taosGetTimestampUs();




×








UNCOV

2929



  tsdbDebug("init stt block reader, window:%" PRId64 "-%" PRId64 ", uid:%" PRIu64 ", %s", w.skey, w.ekey,





×







2930



            pScanInfo->uid, pReader->idStr);










2931













UNCOV

2932



  SMergeTreeConf conf = {




×








UNCOV

2933



      .uid = pScanInfo->uid,




×








UNCOV

2934



      .suid = pReader->info.suid,




×








UNCOV

2935



      .pTsdb = pReader->pTsdb,




×







2936



      .timewindow = w,










2937



      .verRange = pSttBlockReader->verRange,










2938



      .strictTimeRange = false,











UNCOV

2939



      .pSchema = pReader->info.pSchema,




×








UNCOV

2940



      .pCurrentFileset = pReader->status.pCurrentFileset,




×








UNCOV

2941



      .backward = (pSttBlockReader->order == TSDB_ORDER_DESC),




×








UNCOV

2942



      .pSttFileBlockIterArray = pReader->status.pLDataIterArray,




×








UNCOV

2943



      .pCols = pReader->suppInfo.colId,




×








UNCOV

2944



      .numOfCols = pReader->suppInfo.numOfCols,




×







2945



      .loadTombFn = loadSttTombDataForAll,











UNCOV

2946



      .pCurRowKey = &pScanInfo->sttKeyInfo.nextProcKey,




×







2947



      .pReader = pReader,











UNCOV

2948



      .idstr = pReader->idStr,




×








UNCOV

2949



      .rspRows = (pReader->info.execMode == READER_EXEC_ROWS),




×







2950



  };










2951













UNCOV

2952



  info.pKeyRangeList = taosArrayInit(4, sizeof(SSttKeyRange));




×








UNCOV

2953



  TSDB_CHECK_NULL(info.pKeyRangeList, code, lino, _end, terrno);





×







2954













UNCOV

2955



  code = tMergeTreeOpen2(&pSttBlockReader->mergeTree, &conf, &info);




×








UNCOV

2956



  TSDB_CHECK_CODE(code, lino, _end);





×







2957













UNCOV

2958



  code = initMemDataIterator(pScanInfo, pReader);




×








UNCOV

2959



  TSDB_CHECK_CODE(code, lino, _end);





×







2960













UNCOV

2961



  code = initDelSkylineIterator(pScanInfo, pReader->info.order, &pReader->cost);




×








UNCOV

2962



  TSDB_CHECK_CODE(code, lino, _end);





×







2963













UNCOV

2964



  if (conf.rspRows) {





×








UNCOV

2965



    pScanInfo->cleanSttBlocks = isCleanSttBlock(info.pKeyRangeList, &pReader->info.window, pScanInfo, order);




×








UNCOV

2966



    if (pScanInfo->cleanSttBlocks) {





×








UNCOV

2967



      pScanInfo->numOfRowsInStt = info.numOfRows;




×







2968












2969



      // calculate the time window for data in stt files











UNCOV

2970



      for (int32_t i = 0; i < taosArrayGetSize(info.pKeyRangeList); ++i) {





×








UNCOV

2971



        SSttKeyRange* pKeyRange = taosArrayGet(info.pKeyRangeList, i);




×








UNCOV

2972



        if (pKeyRange == NULL) {





×







2973



          continue;




×







2974



        }










2975













UNCOV

2976



        if (pkCompEx(&pScanInfo->sttRange.skey, &pKeyRange->skey) > 0) {





×








UNCOV

2977



          tRowKeyAssign(&pScanInfo->sttRange.skey, &pKeyRange->skey);




×







2978



        }










2979













UNCOV

2980



        if (pkCompEx(&pScanInfo->sttRange.ekey, &pKeyRange->ekey) < 0) {





×








UNCOV

2981



          tRowKeyAssign(&pScanInfo->sttRange.ekey, &pKeyRange->ekey);




×







2982



        }










2983



      }










2984













UNCOV

2985



      pScanInfo->sttKeyInfo.status = taosArrayGetSize(info.pKeyRangeList) ? STT_FILE_HAS_DATA : STT_FILE_NO_DATA;





×







2986













UNCOV

2987



      SRowKey* p = asc ? &pScanInfo->sttRange.skey : &pScanInfo->sttRange.ekey;





×








UNCOV

2988



      tRowKeyAssign(&pScanInfo->sttKeyInfo.nextProcKey, p);




×







2989



    } else {                                // not clean stt blocks











UNCOV

2990



      INIT_KEYRANGE(&pScanInfo->sttRange);  // reset the time window




×








UNCOV

2991



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




×








UNCOV

2992



      if (code != TSDB_CODE_SUCCESS) {





×







2993



        pScanInfo->sttBlockReturned = false;




×







2994



        TSDB_CHECK_CODE(code, lino, _end);





×







2995



      }










2996



    }










2997



  } else {











UNCOV

2998



    pScanInfo->cleanSttBlocks = false;




×








UNCOV

2999



    INIT_KEYRANGE(&pScanInfo->sttRange);  // reset the time window




×








UNCOV

3000



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




×








UNCOV

3001



    if (code != TSDB_CODE_SUCCESS) {





×







3002



      pScanInfo->sttBlockReturned = false;




×







3003



      TSDB_CHECK_CODE(code, lino, _end);





×







3004



    }










3005



  }










3006













UNCOV

3007



  pScanInfo->sttBlockReturned = false;




×








UNCOV

3008



  int64_t el = taosGetTimestampUs() - st;




×








UNCOV

3009



  pReader->cost.initSttBlockReader += (el / 1000.0);




×







3010













UNCOV

3011



  tsdbDebug("init stt block reader completed, elapsed time:%" PRId64 "us %s", el, pReader->idStr);





×







3012













UNCOV

3013



_end:




×








UNCOV

3014



  if (code != TSDB_CODE_SUCCESS) {





×







3015



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





×







3016



    if (pReader) {





×







3017



      pReader->code = code;




×







3018



    }










3019



  }











UNCOV

3020



  taosArrayDestroy(info.pKeyRangeList);




×








UNCOV

3021



}




×







3022













UNCOV

3023



static bool hasDataInSttBlock(STableBlockScanInfo* pInfo) { return pInfo->sttKeyInfo.status == STT_FILE_HAS_DATA; }




×







3024













UNCOV

3025



bool hasDataInFileBlock(const SBlockData* pBlockData, const SFileBlockDumpInfo* pDumpInfo) {




×








UNCOV

3026



  if ((pBlockData->nRow > 0) && (pBlockData->nRow != pDumpInfo->totalRows)) {





×







3027



    return false;  // this is an invalid result.




×







3028



  }











UNCOV

3029



  return pBlockData->nRow > 0 && (!pDumpInfo->allDumped);





×







3030



}










3031













UNCOV

3032



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




×







3033



                              STsdbReader* pReader) {











UNCOV

3034



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

3035



  int32_t             lino = 0;




×








UNCOV

3036



  SRow*               pTSRow = NULL;




×








UNCOV

3037



  SRowMerger*         pMerger = NULL;




×








UNCOV

3038



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

3039



  bool                copied = false;




×







3040













UNCOV

3041



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





×








UNCOV

3042



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





×








UNCOV

3043



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





×







3044













UNCOV

3045



  pMerger = &pReader->status.merger;




×








UNCOV

3046



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







3047













UNCOV

3048



  code = tryCopyDistinctRowFromFileBlock(pReader, pBlockData, pKey, pDumpInfo, &copied);




×








UNCOV

3049



  TSDB_CHECK_CODE(code, lino, _end);





×







3050












3051



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











UNCOV

3052



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




×








UNCOV

3053



  TSDB_CHECK_CODE(code, lino, _end);





×







3054













UNCOV

3055



  tRowKeyAssign(&pBlockScanInfo->lastProcKey, pKey);




×







3056













UNCOV

3057



  if (copied) {





×








UNCOV

3058



    goto _end;




×







3059



  }










3060













UNCOV

3061



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




×







3062













UNCOV

3063



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




×








UNCOV

3064



  TSDB_CHECK_CODE(code, lino, _end);





×







3065













UNCOV

3066



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




×








UNCOV

3067



  TSDB_CHECK_CODE(code, lino, _end);





×







3068













UNCOV

3069



  code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

3070



  TSDB_CHECK_CODE(code, lino, _end);





×







3071













UNCOV

3072



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




×







3073













UNCOV

3074



  taosMemoryFreeClear(pTSRow);





×








UNCOV

3075



  tsdbRowMergerClear(pMerger);




×








UNCOV

3076



  TSDB_CHECK_CODE(code, lino, _end);





×







3077













UNCOV

3078



_end:




×








UNCOV

3079



  if (code != TSDB_CODE_SUCCESS) {





×







3080



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





×







3081



  }











UNCOV

3082



  return code;




×







3083



}










3084













UNCOV

3085



int32_t mergeRowsInSttBlocks(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, STsdbReader* pReader) {




×








UNCOV

3086



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

3087



  int32_t     lino = 0;




×








UNCOV

3088



  SRow*       pTSRow = NULL;




×








UNCOV

3089



  int32_t     pkSrcSlot = 0;




×








UNCOV

3090



  SRowMerger* pMerger = NULL;




×








UNCOV

3091



  bool        copied = false;




×







3092













UNCOV

3093



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





×








UNCOV

3094



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





×








UNCOV

3095



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





×







3096













UNCOV

3097



  pkSrcSlot = pReader->suppInfo.pkSrcSlot;




×








UNCOV

3098



  pMerger = &pReader->status.merger;




×







3099












3100



  // let's record the last processed key











UNCOV

3101



  tRowKeyAssign(&pScanInfo->lastProcKey, getCurrentKeyInSttBlock(pSttBlockReader));




×







3102













UNCOV

3103



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




×








UNCOV

3104



  TSDBROW  fRow = {.iRow = pRow->iRow, .type = TSDBROW_COL_FMT, .pBlockData = pRow->pBlockData};




×







3105













UNCOV

3106



  if (IS_VAR_DATA_TYPE(pScanInfo->lastProcKey.pks[0].type)) {





×








UNCOV

3107



    tsdbTrace("fRow ptr:%p, %d, uid:%" PRIu64 ", ts:%" PRId64 " pk:%s %s", pRow->pBlockData, pRow->iRow,





×







3108



              pSttBlockReader->uid, fRow.pBlockData->aTSKEY[fRow.iRow], pScanInfo->lastProcKey.pks[0].pData,










3109



              pReader->idStr);










3110



  }










3111













UNCOV

3112



  code = tryCopyDistinctRowFromSttBlock(&fRow, pSttBlockReader, pScanInfo, &pScanInfo->lastProcKey, pReader, &copied);




×








UNCOV

3113



  TSDB_CHECK_CODE(code, lino, _end);





×







3114













UNCOV

3115



  if (copied) {





×








UNCOV

3116



    goto _end;




×







3117



  }










3118













UNCOV

3119



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




×








UNCOV

3120



  TSDB_CHECK_CODE(code, lino, _end);





×







3121













UNCOV

3122



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




×








UNCOV

3123



  code = tsdbRowMergerAdd(pMerger, pRow1, NULL);




×








UNCOV

3124



  TSDB_CHECK_CODE(code, lino, _end);





×







3125













UNCOV

3126



  code = doMergeRowsInSttBlock(pSttBlockReader, pScanInfo, pMerger, pkSrcSlot, &pReader->info.verRange, pReader->idStr);




×








UNCOV

3127



  TSDB_CHECK_CODE(code, lino, _end);





×







3128













UNCOV

3129



  code = tsdbRowMergerGetRow(pMerger, &pTSRow);




×








UNCOV

3130



  TSDB_CHECK_CODE(code, lino, _end);





×







3131













UNCOV

3132



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




×







3133













UNCOV

3134



  taosMemoryFreeClear(pTSRow);





×








UNCOV

3135



  tsdbRowMergerClear(pMerger);




×








UNCOV

3136



  TSDB_CHECK_CODE(code, lino, _end);





×







3137













UNCOV

3138



_end:




×








UNCOV

3139



  if (code != TSDB_CODE_SUCCESS) {





×







3140



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





×







3141



  }











UNCOV

3142



  return code;




×







3143



}










3144













UNCOV

3145



static int32_t buildComposedDataBlockImpl(STsdbReader* pReader, STableBlockScanInfo* pBlockScanInfo,




×







3146



                                          SBlockData* pBlockData, SSttBlockReader* pSttBlockReader) {











UNCOV

3147



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

3148



  int32_t             lino = 0;




×








UNCOV

3149



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

3150



  TSDBROW*            pRow = NULL;




×








UNCOV

3151



  TSDBROW*            piRow = NULL;




×








UNCOV

3152



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




×







3153













UNCOV

3154



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





×








UNCOV

3155



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





×








UNCOV

3156



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





×







3157













UNCOV

3158



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







3159













UNCOV

3160



  if (hasDataInFileBlock(pBlockData, pDumpInfo)) {





×








UNCOV

3161



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





×







3162



  } else {











UNCOV

3163



    pKey = NULL;




×







3164



  }










3165













UNCOV

3166



  if (pBlockScanInfo->iter.hasVal) {





×








UNCOV

3167



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




×








UNCOV

3168



    TSDB_CHECK_CODE(code, lino, _end);





×







3169



  }










3170













UNCOV

3171



  if (pBlockScanInfo->iiter.hasVal) {





×








UNCOV

3172



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




×








UNCOV

3173



    TSDB_CHECK_CODE(code, lino, _end);





×







3174



  }










3175













UNCOV

3176



  if (pRow != NULL && piRow != NULL) {





×







3177



    // two levels of mem-table does contain the valid rows











UNCOV

3178



    code = doMergeMultiLevelRows(pReader, pBlockScanInfo, pBlockData, pSttBlockReader);




×








UNCOV

3179



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3180



  } else if (pBlockScanInfo->iiter.hasVal) {





×







3181



    // imem + file + stt block











UNCOV

3182



    code = doMergeBufAndFileRows(pReader, pBlockScanInfo, piRow, &pBlockScanInfo->iiter, pSttBlockReader);




×








UNCOV

3183



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3184



  } else if (pBlockScanInfo->iter.hasVal) {





×







3185



    // mem + file + stt block











UNCOV

3186



    code = doMergeBufAndFileRows(pReader, pBlockScanInfo, pRow, &pBlockScanInfo->iter, pSttBlockReader);




×








UNCOV

3187



    TSDB_CHECK_CODE(code, lino, _end);





×







3188



  } else {










3189



    // files data blocks + stt block











UNCOV

3190



    code = mergeFileBlockAndSttBlock(pReader, pSttBlockReader, pKey, pBlockScanInfo, pBlockData);




×








UNCOV

3191



    TSDB_CHECK_CODE(code, lino, _end);





×







3192



  }










3193













UNCOV

3194



_end:




×








UNCOV

3195



  if (code != TSDB_CODE_SUCCESS) {





×







3196



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





×







3197



  }











UNCOV

3198



  return code;




×







3199



}










3200













UNCOV

3201



static int32_t loadNeighborIfOverlap(SFileDataBlockInfo* pBlockInfo, STableBlockScanInfo* pBlockScanInfo,




×







3202



                                     STsdbReader* pReader, bool* loadNeighbor) {











UNCOV

3203



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

3204



  int32_t             lino = 0;




×








UNCOV

3205



  int32_t             order = 0;




×








UNCOV

3206



  SDataBlockIter*     pIter = NULL;




×








UNCOV

3207



  SBlockLoadSuppInfo* pSupInfo = NULL;




×








UNCOV

3208



  int32_t             step = 0;




×








UNCOV

3209



  int32_t             nextIndex = -1;




×








UNCOV

3210



  SBrinRecord         rec = {0};




×








UNCOV

3211



  bool                hasNeighbor = false;




×







3212













UNCOV

3213



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





×








UNCOV

3214



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





×







3215













UNCOV

3216



  order = pReader->info.order;




×








UNCOV

3217



  pIter = &pReader->status.blockIter;




×








UNCOV

3218



  pSupInfo = &pReader->suppInfo;




×








UNCOV

3219



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





×







3220













UNCOV

3221



  *loadNeighbor = false;




×








UNCOV

3222



  code = getNeighborBlockOfTable(pIter, pBlockInfo, pBlockScanInfo, &nextIndex, order, &rec, pSupInfo, &hasNeighbor);




×








UNCOV

3223



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3224



  if (!hasNeighbor) {  // do nothing





×








UNCOV

3225



    goto _end;




×







3226



  }










3227












3228



  // load next block











UNCOV

3229



  if (overlapWithNeighborBlock2(pBlockInfo, &rec, order, pReader->suppInfo.pk.type, pReader->suppInfo.numOfPks)) {





×








UNCOV

3230



    SReaderStatus*  pStatus = &pReader->status;




×








UNCOV

3231



    SDataBlockIter* pBlockIter = &pStatus->blockIter;




×







3232












3233



    // 1. find the next neighbor block in the scan block list











UNCOV

3234



    STableDataBlockIdx* tableDataBlockIdx = taosArrayGet(pBlockScanInfo->pBlockIdxList, nextIndex);




×








UNCOV

3235



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





×







3236












3237



    // 2. remove it from the scan block list











UNCOV

3238



    int32_t neighborIndex = tableDataBlockIdx->globalIndex;




×








UNCOV

3239



    code = setFileBlockActiveInBlockIter(pReader, pBlockIter, neighborIndex, step);




×








UNCOV

3240



    TSDB_CHECK_CODE(code, lino, _end);





×







3241












3242



    // 3. load the neighbor block, and set it to be the currently accessed file data block











UNCOV

3243



    code = doLoadFileBlockData(pReader, pBlockIter, &pStatus->fileBlockData, pBlockInfo->uid);




×








UNCOV

3244



    TSDB_CHECK_CODE(code, lino, _end);





×







3245












3246



    // 4. check the data values











UNCOV

3247



    code = initBlockDumpInfo(pReader, pBlockIter);




×








UNCOV

3248



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3249



    *loadNeighbor = true;




×







3250



  }










3251













UNCOV

3252



_end:




×








UNCOV

3253



  if (code != TSDB_CODE_SUCCESS) {





×







3254



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





×







3255



  }











UNCOV

3256



  return code;




×







3257



}










3258













UNCOV

3259



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




×








UNCOV

3260



  SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;




×







3261













UNCOV

3262



  pResBlock->info.id.uid = (pBlockScanInfo != NULL) ? pBlockScanInfo->uid : 0;





×








UNCOV

3263



  pResBlock->info.dataLoad = 1;




×








UNCOV

3264



  pResBlock->info.version = pReader->info.verRange.maxVer;




×







3265













UNCOV

3266



  int32_t code = blockDataUpdateTsWindow(pResBlock, pReader->suppInfo.slotId[0]);




×








UNCOV

3267



  code = blockDataUpdatePkRange(pResBlock, pReader->suppInfo.pkDstSlot, ASCENDING_TRAVERSE(pReader->info.order));




×








UNCOV

3268



  setComposedBlockFlag(pReader, true);




×







3269













UNCOV

3270



  pReader->cost.composedBlocks += 1;




×








UNCOV

3271



  pReader->cost.buildComposedBlockTime += el;




×








UNCOV

3272



}




×







3273













UNCOV

3274



static int32_t buildComposedDataBlock(STsdbReader* pReader) {




×








UNCOV

3275



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

3276



  int32_t              lino = 0;




×








UNCOV

3277



  bool                 asc = false;




×








UNCOV

3278



  int64_t              st = 0;




×








UNCOV

3279



  double               el = 0;




×








UNCOV

3280



  int32_t              step = 0;




×








UNCOV

3281



  SSDataBlock*         pResBlock = NULL;




×








UNCOV

3282



  SFileDataBlockInfo*  pBlockInfo = NULL;




×








UNCOV

3283



  SSttBlockReader*     pSttBlockReader = NULL;




×








UNCOV

3284



  SFileBlockDumpInfo*  pDumpInfo = NULL;




×








UNCOV

3285



  STableBlockScanInfo* pBlockScanInfo = NULL;




×







3286



  TSDBKEY              keyInBuf;










3287













UNCOV

3288



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





×







3289













UNCOV

3290



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




×








UNCOV

3291



  st = taosGetTimestampUs();




×








UNCOV

3292



  step = asc ? 1 : -1;





×








UNCOV

3293



  pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

3294



  pSttBlockReader = pReader->status.fileIter.pSttBlockReader;




×








UNCOV

3295



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×







3296













UNCOV

3297



  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

3298



  if (code != TSDB_CODE_SUCCESS) {





×







3299



    return 0;




×







3300



  }










3301













UNCOV

3302



  if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {





×







3303



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




×







3304



    return code;




×







3305



  }










3306













UNCOV

3307



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




×








UNCOV

3308



  TSDB_CHECK_CODE(code, lino, _end);





×







3309













UNCOV

3310



  code = getCurrentKeyInBuf(pBlockScanInfo, pReader, &keyInBuf);




×








UNCOV

3311



  TSDB_CHECK_CODE(code, lino, _end);





×







3312












3313



  // it is a clean block, load it directly











UNCOV

3314



  int64_t cap = pReader->resBlockInfo.capacity;




×








UNCOV

3315



  bool    isClean = false;




×








UNCOV

3316



  code = isCleanFileDataBlock(pReader, pBlockInfo, pBlockScanInfo, keyInBuf, &isClean);




×








UNCOV

3317



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3318



  bool directCopy = isClean && (pBlockInfo->numRow <= cap) && (pBlockScanInfo->sttKeyInfo.status == STT_FILE_NO_DATA) &&





×








UNCOV

3319



                    ((asc && ((pBlockInfo->lastKey < keyInBuf.ts) || (keyInBuf.ts == INT64_MIN))) ||





×








UNCOV

3320



                     (!asc && (pBlockInfo->lastKey > keyInBuf.ts)));





×








UNCOV

3321



  if (directCopy) {





×








UNCOV

3322



    code = copyBlockDataToSDataBlock(pReader, &pBlockScanInfo->lastProcKey);




×








UNCOV

3323



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3324



    goto _end;




×







3325



  }










3326













UNCOV

3327



  SBlockData* pBlockData = &pReader->status.fileBlockData;




×








UNCOV

3328



  initSttBlockReader(pSttBlockReader, pBlockScanInfo, pReader);




×








UNCOV

3329



  code = pReader->code;




×








UNCOV

3330



  TSDB_CHECK_CODE(code, lino, _end);





×







3331













UNCOV

3332



  while (1) {




×








UNCOV

3333



    bool hasBlockData = false;




×







3334



    {











UNCOV

3335



      while (pBlockData->nRow > 0 && pBlockData->uid == pBlockScanInfo->uid) {





×







3336



        // find the first qualified row in data block











UNCOV

3337



        bool valid = false;




×







3338



        code =











UNCOV

3339



            isValidFileBlockRow(pBlockData, pDumpInfo->rowIndex, pBlockScanInfo, asc, &pReader->info, pReader, &valid);




×








UNCOV

3340



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3341



        if (valid) {





×








UNCOV

3342



          hasBlockData = true;




×








UNCOV

3343



          break;




×







3344



        }










3345













UNCOV

3346



        pDumpInfo->rowIndex += step;




×







3347













UNCOV

3348



        if (pDumpInfo->rowIndex >= pBlockData->nRow || pDumpInfo->rowIndex < 0) {





×







3349



          // NOTE: get the new block info











UNCOV

3350



          code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

3351



          TSDB_CHECK_CODE(code, lino, _end);





×







3352












3353



          // continue check for the next file block if the last ts in the current block










3354



          // is overlapped with the next neighbor block











UNCOV

3355



          bool loadNeighbor = false;




×








UNCOV

3356



          code = loadNeighborIfOverlap(pBlockInfo, pBlockScanInfo, pReader, &loadNeighbor);




×








UNCOV

3357



          if ((!loadNeighbor) || (code != 0)) {





×








UNCOV

3358



            lino = __LINE__;




×








UNCOV

3359



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




×








UNCOV

3360



            break;




×







3361



          }










3362



        }










3363



      }










3364



    }










3365












3366



    // no data in last block and block, no need to proceed.











UNCOV

3367



    if (hasBlockData == false) {





×








UNCOV

3368



      break;




×







3369



    }










3370













UNCOV

3371



    code = buildComposedDataBlockImpl(pReader, pBlockScanInfo, pBlockData, pSttBlockReader);




×








UNCOV

3372



    TSDB_CHECK_CODE(code, lino, _end);





×







3373












3374



    // currently loaded file data block is consumed











UNCOV

3375



    if ((pBlockData->nRow > 0) && (pDumpInfo->rowIndex >= pBlockData->nRow || pDumpInfo->rowIndex < 0)) {





×








UNCOV

3376



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




×








UNCOV

3377



      break;




×







3378



    }










3379













UNCOV

3380



    if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {





×








UNCOV

3381



      break;




×







3382



    }










3383



  }










3384













UNCOV

3385



_end:




×








UNCOV

3386



  if (pReader) {





×








UNCOV

3387



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




×








UNCOV

3388



    updateComposedBlockInfo(pReader, el, pBlockScanInfo);




×







3389



  }










3390













UNCOV

3391



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





×








UNCOV

3392



    tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64





×







3393



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










3394



              pReader, pResBlock->info.id.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,










3395



              pResBlock->info.rows, el, pReader->idStr);










3396



  }










3397













UNCOV

3398



  if (code != TSDB_CODE_SUCCESS) {





×







3399



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





×







3400



  }











UNCOV

3401



  return code;




×







3402



}










3403













UNCOV

3404



void setComposedBlockFlag(STsdbReader* pReader, bool composed) { pReader->status.composedDataBlock = composed; }




×







3405













UNCOV

3406



int32_t getInitialDelIndex(const SArray* pDelSkyline, int32_t order) {




×








UNCOV

3407



  if (pDelSkyline == NULL) {





×







3408



    return 0;




×







3409



  }










3410













UNCOV

3411



  return ASCENDING_TRAVERSE(order) ? 0 : taosArrayGetSize(pDelSkyline) - 1;





×







3412



}










3413













UNCOV

3414



int32_t initDelSkylineIterator(STableBlockScanInfo* pBlockScanInfo, int32_t order, SReadCostSummary* pCost) {




×








UNCOV

3415



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

3416



  int32_t lino = 0;




×








UNCOV

3417



  int32_t newDelDataInFile = 0;




×








UNCOV

3418



  int64_t st = 0;




×








UNCOV

3419



  SArray* pSource = NULL;




×







3420













UNCOV

3421



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





×







3422













UNCOV

3423



  newDelDataInFile = taosArrayGetSize(pBlockScanInfo->pFileDelData);




×








UNCOV

3424



  if (newDelDataInFile == 0 &&





×








UNCOV

3425



      ((pBlockScanInfo->delSkyline != NULL) || (TARRAY_SIZE(pBlockScanInfo->pMemDelData) == 0))) {





×








UNCOV

3426



    goto _end;




×







3427



  }










3428













UNCOV

3429



  st = taosGetTimestampUs();




×







3430













UNCOV

3431



  if (pBlockScanInfo->delSkyline != NULL) {





×








UNCOV

3432



    taosArrayClear(pBlockScanInfo->delSkyline);




×







3433



  } else {











UNCOV

3434



    pBlockScanInfo->delSkyline = taosArrayInit(4, sizeof(TSDBKEY));




×








UNCOV

3435



    TSDB_CHECK_NULL(pBlockScanInfo->delSkyline, code, lino, _end, terrno);





×







3436



  }










3437













UNCOV

3438



  pSource = pBlockScanInfo->pFileDelData;




×








UNCOV

3439



  if (pSource == NULL) {





×








UNCOV

3440



    pSource = pBlockScanInfo->pMemDelData;




×







3441



  } else {











UNCOV

3442



    const void* p1 = taosArrayAddAll(pSource, pBlockScanInfo->pMemDelData);




×








UNCOV

3443



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





×







3444



  }










3445













UNCOV

3446



  code = tsdbBuildDeleteSkyline(pSource, 0, taosArrayGetSize(pSource) - 1, pBlockScanInfo->delSkyline);




×







3447













UNCOV

3448



  taosArrayClear(pBlockScanInfo->pFileDelData);




×








UNCOV

3449



  int32_t index = getInitialDelIndex(pBlockScanInfo->delSkyline, order);




×







3450













UNCOV

3451



  pBlockScanInfo->iter.index = index;




×








UNCOV

3452



  pBlockScanInfo->iiter.index = index;




×








UNCOV

3453



  pBlockScanInfo->fileDelIndex = index;




×








UNCOV

3454



  pBlockScanInfo->sttBlockDelIndex = index;




×








UNCOV

3455



  TSDB_CHECK_CODE(code, lino, _end);





×







3456













UNCOV

3457



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





×








UNCOV

3458



  double el = taosGetTimestampUs() - st;




×








UNCOV

3459



  pCost->createSkylineIterTime = el / 1000.0;




×







3460













UNCOV

3461



_end:




×








UNCOV

3462



  if (code != TSDB_CODE_SUCCESS) {





×







3463



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





×







3464



  }











UNCOV

3465



  return code;




×







3466



}










3467













UNCOV

3468



int32_t getCurrentKeyInBuf(STableBlockScanInfo* pScanInfo, STsdbReader* pReader, TSDBKEY* pkey) {




×








UNCOV

3469



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

3470



  int32_t  lino = 0;




×








UNCOV

3471



  bool     asc = false;




×








UNCOV

3472



  bool     hasKey = false;




×








UNCOV

3473



  bool     hasIKey = false;




×








UNCOV

3474



  TSDBROW* pRow = NULL;




×








UNCOV

3475



  TSDBROW* pIRow = NULL;




×








UNCOV

3476



  TSDBKEY  key = {.ts = TSKEY_INITIAL_VAL};




×








UNCOV

3477



  TSDBKEY  ikey = {.ts = TSKEY_INITIAL_VAL};




×







3478













UNCOV

3479



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





×








UNCOV

3480



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





×








UNCOV

3481



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





×







3482













UNCOV

3483



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




×







3484













UNCOV

3485



  code = getValidMemRow(&pScanInfo->iter, pScanInfo->delSkyline, pReader, &pRow);




×








UNCOV

3486



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3487



  if (pRow != NULL) {





×








UNCOV

3488



    hasKey = true;




×








UNCOV

3489



    key = TSDBROW_KEY(pRow);





×







3490



  }










3491













UNCOV

3492



  code = getValidMemRow(&pScanInfo->iiter, pScanInfo->delSkyline, pReader, &pIRow);




×








UNCOV

3493



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3494



  if (pIRow != NULL) {





×








UNCOV

3495



    hasIKey = true;




×








UNCOV

3496



    ikey = TSDBROW_KEY(pIRow);





×







3497



  }










3498













UNCOV

3499



  if (hasKey) {





×








UNCOV

3500



    if (hasIKey) {  // has data in mem & imem





×








UNCOV

3501



      if (asc) {





×








UNCOV

3502



        *pkey = key.ts <= ikey.ts ? key : ikey;





×







3503



      } else {










3504



        *pkey = key.ts <= ikey.ts ? ikey : key;





×







3505



      }










3506



    } else {  // no data in imem











UNCOV

3507



      *pkey = key;




×







3508



    }










3509



  } else {










3510



    // no data in mem & imem, return the initial value










3511



    // only imem has data, return ikey











UNCOV

3512



    *pkey = ikey;




×







3513



  }










3514













UNCOV

3515



_end:




×








UNCOV

3516



  if (code != TSDB_CODE_SUCCESS) {





×







3517



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





×







3518



  }











UNCOV

3519



  return code;




×







3520



}










3521













UNCOV

3522



static void prepareDurationForNextFileSet(STsdbReader* pReader) {




×








UNCOV

3523



  if (pReader->status.bProcMemFirstFileset) {





×








UNCOV

3524



    pReader->status.prevFilesetStartKey = INT64_MIN;




×








UNCOV

3525



    pReader->status.prevFilesetEndKey = INT64_MAX;




×








UNCOV

3526



    pReader->status.bProcMemFirstFileset = false;




×







3527



  }










3528













UNCOV

3529



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




×








UNCOV

3530



  STimeWindow winFid = {0};




×








UNCOV

3531



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




×







3532













UNCOV

3533



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





×








UNCOV

3534



    pReader->status.bProcMemPreFileset = !(pReader->status.memTableMaxKey < pReader->status.prevFilesetStartKey ||





×








UNCOV

3535



                                           (winFid.skey - 1) < pReader->status.memTableMinKey);





×







3536



  } else {











UNCOV

3537



    pReader->status.bProcMemPreFileset = !(pReader->status.memTableMaxKey < (winFid.ekey + 1) ||





×








UNCOV

3538



                                           pReader->status.prevFilesetEndKey < pReader->status.memTableMinKey);





×







3539



  }










3540













UNCOV

3541



  if (pReader->status.bProcMemPreFileset) {





×








UNCOV

3542



    tsdbDebug("will start pre-fileset %d buffer processing. %s", fid, pReader->idStr);





×








UNCOV

3543



    pReader->status.procMemUidList.tableUidList = pReader->status.uidList.tableUidList;




×








UNCOV

3544



    resetPreFilesetMemTableListIndex(&pReader->status);




×







3545



  }










3546













UNCOV

3547



  if (!pReader->status.bProcMemPreFileset) {





×








UNCOV

3548



    if (pReader->notifyFn) {





×








UNCOV

3549



      STsdReaderNotifyInfo info = {0};




×








UNCOV

3550



      info.duration.filesetId = fid;




×








UNCOV

3551



      pReader->notifyFn(TSD_READER_NOTIFY_DURATION_START, &info, pReader->notifyParam);




×








UNCOV

3552



      tsdbDebug("new duration %d start notification when no buffer preceeding fileset, %s", fid, pReader->idStr);





×







3553



    }










3554



  }










3555













UNCOV

3556



  pReader->status.prevFilesetStartKey = winFid.skey;




×








UNCOV

3557



  pReader->status.prevFilesetEndKey = winFid.ekey;




×








UNCOV

3558



}




×







3559













UNCOV

3560



static int32_t moveToNextFile(STsdbReader* pReader, SBlockNumber* pBlockNum, SArray* pTableList) {




×








UNCOV

3561



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

3562



  int32_t        lino = 0;




×








UNCOV

3563



  SReaderStatus* pStatus = NULL;




×








UNCOV

3564



  SArray*        pIndexList = NULL;




×








UNCOV

3565



  size_t         numOfTables = 0;




×







3566













UNCOV

3567



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





×








UNCOV

3568



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





×







3569













UNCOV

3570



  pStatus = &pReader->status;




×








UNCOV

3571



  pBlockNum->numOfBlocks = 0;




×








UNCOV

3572



  pBlockNum->numOfSttFiles = 0;




×







3573













UNCOV

3574



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




×








UNCOV

3575



  pIndexList = taosArrayInit(numOfTables, sizeof(SBrinBlk));




×








UNCOV

3576



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





×







3577













UNCOV

3578



  while (1) {




×







3579



    // only check here, since the iterate data in memory is very fast.











UNCOV

3580



    if (pReader->code != TSDB_CODE_SUCCESS) {





×







3581



      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);





×







3582



      code = pReader->code;




×







3583



      TSDB_CHECK_CODE(code, lino, _end);





×







3584



    }










3585













UNCOV

3586



    bool hasNext = false;




×








UNCOV

3587



    code = filesetIteratorNext(&pStatus->fileIter, pReader, &hasNext);




×








UNCOV

3588



    TSDB_CHECK_CODE(code, lino, _end);





×







3589













UNCOV

3590



    if (!hasNext) {  // no data files on disk





×








UNCOV

3591



      break;




×







3592



    }










3593













UNCOV

3594



    taosArrayClear(pIndexList);




×








UNCOV

3595



    code = doLoadBlockIndex(pReader, pReader->pFileReader, pIndexList);




×








UNCOV

3596



    TSDB_CHECK_CODE(code, lino, _end);





×







3597













UNCOV

3598



    if (taosArrayGetSize(pIndexList) > 0 || pReader->status.pCurrentFileset->lvlArr->size > 0) {





×








UNCOV

3599



      code = loadFileBlockBrinInfo(pReader, pIndexList, pBlockNum, pTableList);




×








UNCOV

3600



      TSDB_CHECK_CODE(code, lino, _end);





×







3601













UNCOV

3602



      if (pBlockNum->numOfBlocks + pBlockNum->numOfSttFiles > 0) {





×








UNCOV

3603



        if (pReader->bFilesetDelimited) {





×








UNCOV

3604



          prepareDurationForNextFileSet(pReader);




×







3605



        }











UNCOV

3606



        break;




×







3607



      }










3608



    }










3609












3610



    // no blocks in current file, try next files










3611



  }










3612













UNCOV

3613



  code = loadDataFileTombDataForAll(pReader);




×








UNCOV

3614



  TSDB_CHECK_CODE(code, lino, _end);





×







3615













UNCOV

3616



_end:




×








UNCOV

3617



  if (code != TSDB_CODE_SUCCESS) {





×







3618



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





×







3619



  }











UNCOV

3620



  if (pIndexList) {





×








UNCOV

3621



    taosArrayDestroy(pIndexList);




×







3622



  }











UNCOV

3623



  return code;




×







3624



}










3625












3626



// pTableIter can be NULL, no need to handle the return value











UNCOV

3627



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




×








UNCOV

3628



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

3629



  int32_t        lino = 0;




×








UNCOV

3630



  STableUidList* pList = NULL;




×







3631













UNCOV

3632



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





×







3633













UNCOV

3634



  pList = &pStatus->uidList;




×







3635













UNCOV

3636



  pList->currentIndex = 0;




×








UNCOV

3637



  uint64_t uid = pList->tableUidList[0];




×








UNCOV

3638



  pStatus->pTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));




×








UNCOV

3639



  if (pStatus->pTableIter == NULL) {





×







3640



    tsdbError("%s failed to load tableBlockScanInfo for uid:%" PRId64 ", code: internal error", id, uid);





×







3641



    TSDB_CHECK_NULL(pStatus->pTableIter, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);





×







3642



  }










3643













UNCOV

3644



_end:




×








UNCOV

3645



  if (code != TSDB_CODE_SUCCESS) {





×







3646



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





×







3647



  }











UNCOV

3648



  return code;




×







3649



}










3650













UNCOV

3651



static void resetPreFilesetMemTableListIndex(SReaderStatus* pStatus) {




×








UNCOV

3652



  STableUidList* pList = &pStatus->procMemUidList;




×







3653













UNCOV

3654



  pList->currentIndex = 0;




×








UNCOV

3655



  uint64_t uid = pList->tableUidList[0];




×








UNCOV

3656



  pStatus->pProcMemTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));




×








UNCOV

3657



}




×







3658













UNCOV

3659



static bool moveToNextTable(STableUidList* pOrderedCheckInfo, SReaderStatus* pStatus) {




×








UNCOV

3660



  pOrderedCheckInfo->currentIndex += 1;




×








UNCOV

3661



  if (pOrderedCheckInfo->currentIndex >= tSimpleHashGetSize(pStatus->pTableMap)) {





×








UNCOV

3662



    pStatus->pTableIter = NULL;




×








UNCOV

3663



    return false;




×







3664



  }










3665













UNCOV

3666



  uint64_t uid = pOrderedCheckInfo->tableUidList[pOrderedCheckInfo->currentIndex];




×








UNCOV

3667



  pStatus->pTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));




×








UNCOV

3668



  return (pStatus->pTableIter != NULL);




×







3669



}










3670













UNCOV

3671



static bool moveToNextTableForPreFileSetMem(SReaderStatus* pStatus) {




×








UNCOV

3672



  STableUidList* pUidList = &pStatus->procMemUidList;




×








UNCOV

3673



  pUidList->currentIndex += 1;




×








UNCOV

3674



  if (pUidList->currentIndex >= tSimpleHashGetSize(pStatus->pTableMap)) {





×








UNCOV

3675



    pStatus->pProcMemTableIter = NULL;




×








UNCOV

3676



    return false;




×







3677



  }










3678













UNCOV

3679



  uint64_t uid = pUidList->tableUidList[pUidList->currentIndex];




×








UNCOV

3680



  pStatus->pProcMemTableIter = tSimpleHashGet(pStatus->pTableMap, &uid, sizeof(uid));




×








UNCOV

3681



  return (pStatus->pProcMemTableIter != NULL);




×







3682



}










3683













UNCOV

3684



static int32_t buildCleanBlockFromSttFiles(STsdbReader* pReader, STableBlockScanInfo* pScanInfo) {




×








UNCOV

3685



  int32_t          code = TSDB_CODE_SUCCESS;




×








UNCOV

3686



  int32_t          lino = 0;




×








UNCOV

3687



  SReaderStatus*   pStatus = NULL;




×








UNCOV

3688



  SSttBlockReader* pSttBlockReader = NULL;




×








UNCOV

3689



  SSDataBlock*     pResBlock = NULL;




×








UNCOV

3690



  SDataBlockInfo*  pInfo = NULL;




×








UNCOV

3691



  bool             asc = false;




×







3692













UNCOV

3693



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





×








UNCOV

3694



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





×







3695













UNCOV

3696



  pStatus = &pReader->status;




×








UNCOV

3697



  pSttBlockReader = pStatus->fileIter.pSttBlockReader;




×








UNCOV

3698



  pResBlock = pReader->resBlockInfo.pResBlock;




×







3699













UNCOV

3700



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




×








UNCOV

3701



  code = blockDataEnsureCapacity(pResBlock, pScanInfo->numOfRowsInStt);




×








UNCOV

3702



  TSDB_CHECK_CODE(code, lino, _end);





×







3703













UNCOV

3704



  pInfo = &pResBlock->info;




×








UNCOV

3705



  pInfo->rows = pScanInfo->numOfRowsInStt;




×








UNCOV

3706



  pInfo->id.uid = pScanInfo->uid;




×








UNCOV

3707



  pInfo->dataLoad = 1;




×








UNCOV

3708



  pInfo->window.skey = pScanInfo->sttRange.skey.ts;




×








UNCOV

3709



  pInfo->window.ekey = pScanInfo->sttRange.ekey.ts;




×







3710













UNCOV

3711



  setComposedBlockFlag(pReader, true);




×







3712













UNCOV

3713



  pScanInfo->sttKeyInfo.nextProcKey.ts = asc ? pScanInfo->sttRange.ekey.ts + 1 : pScanInfo->sttRange.skey.ts - 1;





×








UNCOV

3714



  pScanInfo->sttKeyInfo.status = STT_FILE_NO_DATA;




×







3715













UNCOV

3716



  if (asc) {





×








UNCOV

3717



    tRowKeyAssign(&pScanInfo->lastProcKey, &pScanInfo->sttRange.ekey);




×







3718



  } else {










3719



    tRowKeyAssign(&pScanInfo->lastProcKey, &pScanInfo->sttRange.skey);




×







3720



  }










3721













UNCOV

3722



  pScanInfo->sttBlockReturned = true;




×








UNCOV

3723



  pSttBlockReader->mergeTree.pIter = NULL;




×







3724













UNCOV

3725



  tsdbDebug("%p uid:%" PRId64 " return clean stt block as one, brange:%" PRId64 "-%" PRId64 " rows:%" PRId64 " %s",





×







3726



            pReader, pResBlock->info.id.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,










3727



            pResBlock->info.rows, pReader->idStr);










3728













UNCOV

3729



_end:




×








UNCOV

3730



  if (code != TSDB_CODE_SUCCESS) {





×







3731



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





×







3732



  }











UNCOV

3733



  return code;




×







3734



}










3735













UNCOV

3736



static int32_t buildCleanBlockFromDataFiles(STsdbReader* pReader, STableBlockScanInfo* pScanInfo,




×







3737



                                            SFileDataBlockInfo* pBlockInfo, int32_t blockIndex) {











UNCOV

3738



  int32_t         code = TSDB_CODE_SUCCESS;




×








UNCOV

3739



  int32_t         lino = 0;




×








UNCOV

3740



  SReaderStatus*  pStatus = NULL;




×








UNCOV

3741



  SDataBlockInfo* pInfo = NULL;




×








UNCOV

3742



  bool            asc = false;




×







3743













UNCOV

3744



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





×








UNCOV

3745



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





×








UNCOV

3746



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





×







3747












3748



  // whole data block is required, return it directly











UNCOV

3749



  pStatus = &pReader->status;




×








UNCOV

3750



  pInfo = &pReader->resBlockInfo.pResBlock->info;




×








UNCOV

3751



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




×







3752













UNCOV

3753



  pInfo->rows = pBlockInfo->numRow;




×








UNCOV

3754



  pInfo->id.uid = pScanInfo->uid;




×








UNCOV

3755



  pInfo->dataLoad = 0;




×








UNCOV

3756



  pInfo->version = pReader->info.verRange.maxVer;




×








UNCOV

3757



  pInfo->window = (STimeWindow){.skey = pBlockInfo->firstKey, .ekey = pBlockInfo->lastKey};




×







3758













UNCOV

3759



  if (pReader->suppInfo.numOfPks > 0) {





×








UNCOV

3760



    if (IS_NUMERIC_TYPE(pReader->suppInfo.pk.type)) {





×








UNCOV

3761



      pInfo->pks[0].val = pBlockInfo->firstPk.val;




×








UNCOV

3762



      pInfo->pks[1].val = pBlockInfo->lastPk.val;




×







3763



    } else {










3764



      (void)memcpy(pInfo->pks[0].pData, varDataVal(pBlockInfo->firstPk.pData), varDataLen(pBlockInfo->firstPk.pData));




×







3765



      (void)memcpy(pInfo->pks[1].pData, varDataVal(pBlockInfo->lastPk.pData), varDataLen(pBlockInfo->lastPk.pData));




×







3766












3767



      pInfo->pks[0].nData = varDataLen(pBlockInfo->firstPk.pData);




×







3768



      pInfo->pks[1].nData = varDataLen(pBlockInfo->lastPk.pData);




×







3769



    }










3770



  }










3771












3772



  // update the last key for the corresponding table











UNCOV

3773



  setComposedBlockFlag(pReader, false);




×








UNCOV

3774



  setBlockAllDumped(&pStatus->fBlockDumpInfo, pBlockInfo->lastKey, pReader->info.order);




×








UNCOV

3775



  code = updateLastKeyInfo(&pScanInfo->lastProcKey, pBlockInfo, pInfo, pReader->suppInfo.numOfPks, asc);




×








UNCOV

3776



  TSDB_CHECK_CODE(code, lino, _end);





×







3777













UNCOV

3778



  tsdbDebug("%p uid:%" PRIu64





×







3779



            " clean file block retrieved from file, global index:%d, "










3780



            "table index:%d, rows:%d, brange:%" PRId64 "-%" PRId64 ", %s",










3781



            pReader, pScanInfo->uid, blockIndex, pBlockInfo->tbBlockIdx, pBlockInfo->numRow, pBlockInfo->firstKey,










3782



            pBlockInfo->lastKey, pReader->idStr);










3783













UNCOV

3784



_end:




×








UNCOV

3785



  if (code != TSDB_CODE_SUCCESS) {





×







3786



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





×







3787



  }











UNCOV

3788



  return code;




×







3789



}










3790













UNCOV

3791



static int32_t doLoadSttBlockSequentially(STsdbReader* pReader) {




×








UNCOV

3792



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

3793



  int32_t              lino = 0;




×








UNCOV

3794



  SReaderStatus*       pStatus = NULL;




×








UNCOV

3795



  SSttBlockReader*     pSttBlockReader = NULL;




×








UNCOV

3796



  STableUidList*       pUidList = NULL;




×








UNCOV

3797



  SSDataBlock*         pResBlock = NULL;




×








UNCOV

3798



  STableBlockScanInfo* pScanInfo = NULL;




×







3799













UNCOV

3800



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





×







3801













UNCOV

3802



  pStatus = &pReader->status;




×








UNCOV

3803



  pSttBlockReader = pStatus->fileIter.pSttBlockReader;




×








UNCOV

3804



  pUidList = &pStatus->uidList;




×







3805













UNCOV

3806



  if (tSimpleHashGetSize(pStatus->pTableMap) == 0) {





×







3807



    goto _end;




×







3808



  }










3809













UNCOV

3810



  pResBlock = pReader->resBlockInfo.pResBlock;




×







3811













UNCOV

3812



  while (1) {




×








UNCOV

3813



    if (pReader->code != TSDB_CODE_SUCCESS) {





×







3814



      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);





×







3815



      code = pReader->code;




×







3816



      TSDB_CHECK_CODE(code, lino, _end);





×







3817



    }










3818












3819



    // load the last data block of current table











UNCOV

3820



    if (pStatus->pTableIter == NULL) {





×







3821



      tsdbError("table Iter is null, invalid pScanInfo, try next table %s", pReader->idStr);





×







3822



      bool hasNexTable = moveToNextTable(pUidList, pStatus);




×







3823



      if (!hasNexTable) {





×







3824



        break;




×







3825



      }










3826












3827



      continue;




×







3828



    } else {











UNCOV

3829



      pScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;




×







3830



    }










3831













UNCOV

3832



    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pScanInfo->uid, sizeof(pScanInfo->uid))) {





×







3833



      // reset the index in last block when handing a new file











UNCOV

3834



      bool hasNexTable = moveToNextTable(pUidList, pStatus);




×








UNCOV

3835



      if (!hasNexTable) {





×








UNCOV

3836



        break;




×







3837



      }










3838













UNCOV

3839



      continue;




×







3840



    }










3841













UNCOV

3842



    initSttBlockReader(pSttBlockReader, pScanInfo, pReader);




×








UNCOV

3843



    code = pReader->code;




×








UNCOV

3844



    TSDB_CHECK_CODE(code, lino, _end);





×







3845













UNCOV

3846



    if (!hasDataInSttBlock(pScanInfo)) {





×








UNCOV

3847



      bool hasNexTable = moveToNextTable(pUidList, pStatus);




×








UNCOV

3848



      if (!hasNexTable) {





×








UNCOV

3849



        break;




×







3850



      }










3851













UNCOV

3852



      continue;




×







3853



    }










3854












3855



    // if only require the total rows, no need to load data from stt file if it is clean stt blocks











UNCOV

3856



    if (pReader->info.execMode == READER_EXEC_ROWS && pScanInfo->cleanSttBlocks) {





×








UNCOV

3857



      code = buildCleanBlockFromSttFiles(pReader, pScanInfo);




×








UNCOV

3858



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3859



      break;




×







3860



    }










3861













UNCOV

3862



    int64_t st = taosGetTimestampUs();




×







3863



    while (1) {










3864



      // no data in stt block and block, no need to proceed.











UNCOV

3865



      if (!hasDataInSttBlock(pScanInfo)) {





×








UNCOV

3866



        break;




×







3867



      }










3868













UNCOV

3869



      code = buildComposedDataBlockImpl(pReader, pScanInfo, &pReader->status.fileBlockData, pSttBlockReader);




×








UNCOV

3870



      TSDB_CHECK_CODE(code, lino, _end);





×







3871













UNCOV

3872



      if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {





×








UNCOV

3873



        break;




×







3874



      }










3875



    }










3876













UNCOV

3877



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




×








UNCOV

3878



    updateComposedBlockInfo(pReader, el, pScanInfo);




×







3879













UNCOV

3880



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





×








UNCOV

3881



      tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64





×







3882



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










3883



                pReader, pResBlock->info.id.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,










3884



                pResBlock->info.rows, el, pReader->idStr);











UNCOV

3885



      break;




×







3886



    }










3887












3888



    // current table is exhausted, let's try next table










3889



    bool hasNexTable = moveToNextTable(pUidList, pStatus);




×







3890



    if (!hasNexTable) {





×







3891



      break;




×







3892



    }










3893



  }










3894













UNCOV

3895



_end:




×








UNCOV

3896



  if (code != TSDB_CODE_SUCCESS) {





×







3897



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





×







3898



  }











UNCOV

3899



  return code;




×







3900



}










3901












3902



// current active data block not overlap with the stt-files/stt-blocks











UNCOV

3903



static bool notOverlapWithFiles(SFileDataBlockInfo* pBlockInfo, STableBlockScanInfo* pScanInfo, bool asc) {




×








UNCOV

3904



  if ((!hasDataInSttBlock(pScanInfo)) || (pScanInfo->cleanSttBlocks == true)) {





×








UNCOV

3905



    return true;




×







3906



  } else {











UNCOV

3907



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




×








UNCOV

3908



    return (asc && pBlockInfo->lastKey < keyInStt) || (!asc && pBlockInfo->firstKey > keyInStt);





×







3909



  }










3910



}










3911













UNCOV

3912



static int32_t doBuildDataBlock(STsdbReader* pReader) {




×








UNCOV

3913



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

3914



  int32_t              lino = 0;




×








UNCOV

3915



  SReaderStatus*       pStatus = NULL;




×








UNCOV

3916



  SDataBlockIter*      pBlockIter = NULL;




×








UNCOV

3917



  STableBlockScanInfo* pScanInfo = NULL;




×








UNCOV

3918



  SFileDataBlockInfo*  pBlockInfo = NULL;




×








UNCOV

3919



  SSttBlockReader*     pSttBlockReader = NULL;




×







3920



  TSDBKEY              keyInBuf;











UNCOV

3921



  bool                 asc = false;




×







3922













UNCOV

3923



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





×







3924













UNCOV

3925



  pStatus = &pReader->status;




×








UNCOV

3926



  pBlockIter = &pStatus->blockIter;




×








UNCOV

3927



  pSttBlockReader = pReader->status.fileIter.pSttBlockReader;




×








UNCOV

3928



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




×







3929













UNCOV

3930



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




×








UNCOV

3931



  TSDB_CHECK_CODE(code, lino, _end);





×







3932













UNCOV

3933



  if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {





×








UNCOV

3934



    setBlockAllDumped(&pStatus->fBlockDumpInfo, pBlockInfo->lastKey, pReader->info.order);




×








UNCOV

3935



    goto _end;




×







3936



  }










3937













UNCOV

3938



  code = pReader->code;




×








UNCOV

3939



  TSDB_CHECK_CODE(code, lino, _end);





×







3940













UNCOV

3941



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




×








UNCOV

3942



  TSDB_CHECK_CODE(code, lino, _end);





×







3943













UNCOV

3944



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





×








UNCOV

3945



    initSttBlockReader(pSttBlockReader, pScanInfo, pReader);




×








UNCOV

3946



    code = pReader->code;




×








UNCOV

3947



    TSDB_CHECK_CODE(code, lino, _end);





×







3948



  }










3949













UNCOV

3950



  code = getCurrentKeyInBuf(pScanInfo, pReader, &keyInBuf);




×








UNCOV

3951



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3952



  bool load = false;




×








UNCOV

3953



  code = fileBlockShouldLoad(pReader, pBlockInfo, pScanInfo, keyInBuf, &load);




×








UNCOV

3954



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3955



  if (load) {





×








UNCOV

3956



    code = doLoadFileBlockData(pReader, pBlockIter, &pStatus->fileBlockData, pScanInfo->uid);




×








UNCOV

3957



    TSDB_CHECK_CODE(code, lino, _end);





×







3958












3959



    // build composed data block











UNCOV

3960



    code = buildComposedDataBlock(pReader);




×








UNCOV

3961



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

3962



  } else if (bufferDataInFileBlockGap(keyInBuf, pBlockInfo, pScanInfo, pReader->info.order)) {





×







3963



    // data in memory that are earlier than current file block and stt blocks










3964



    // rows in buffer should be less than the file block in asc, greater than file block in desc











UNCOV

3965



    int64_t endKey = getBoarderKeyInFiles(pBlockInfo, pScanInfo, pReader->info.order);




×








UNCOV

3966



    code = buildDataBlockFromBuf(pReader, pScanInfo, endKey);




×








UNCOV

3967



    TSDB_CHECK_CODE(code, lino, _end);





×







3968



  } else {











UNCOV

3969



    if (notOverlapWithFiles(pBlockInfo, pScanInfo, asc)) {





×








UNCOV

3970



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




×







3971













UNCOV

3972



      if ((!hasDataInSttBlock(pScanInfo)) || (asc && pBlockInfo->lastKey < keyInStt) ||





×







3973



          (!asc && pBlockInfo->firstKey > keyInStt)) {





×







3974



        // the stt blocks may located in the gap of different data block, but the whole sttRange may overlap with the










3975



        // data block, so the overlap check is invalid actually.











UNCOV

3976



        code = buildCleanBlockFromDataFiles(pReader, pScanInfo, pBlockInfo, pBlockIter->index);




×








UNCOV

3977



        TSDB_CHECK_CODE(code, lino, _end);





×







3978



      } else {  // clean stt block










3979



        TSDB_CHECK_CONDITION((pReader->info.execMode == READER_EXEC_ROWS) && (pSttBlockReader->mergeTree.pIter == NULL),





×







3980



                             code, lino, _end, TSDB_CODE_INTERNAL_ERROR);










3981



        code = buildCleanBlockFromSttFiles(pReader, pScanInfo);




×







3982



        TSDB_CHECK_CODE(code, lino, _end);





×







3983



      }










3984



    } else {











UNCOV

3985



      SBlockData* pBData = &pReader->status.fileBlockData;




×








UNCOV

3986



      tBlockDataReset(pBData);




×







3987













UNCOV

3988



      SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;




×







3989













UNCOV

3990



      tsdbDebug("load data in stt block firstly %s", pReader->idStr);





×








UNCOV

3991



      int64_t st = taosGetTimestampUs();




×







3992












3993



      // let's load data from stt files, make sure clear the cleanStt block flag before load the data from stt files











UNCOV

3994



      initSttBlockReader(pSttBlockReader, pScanInfo, pReader);




×








UNCOV

3995



      code = pReader->code;




×








UNCOV

3996



      TSDB_CHECK_CODE(code, lino, _end);





×







3997












3998



      // no data in stt block, no need to proceed.











UNCOV

3999



      while (hasDataInSttBlock(pScanInfo)) {





×








UNCOV

4000



        TSDB_CHECK_CONDITION(pScanInfo->sttKeyInfo.status == STT_FILE_HAS_DATA, code, lino, _end,





×







4001



                             TSDB_CODE_INTERNAL_ERROR);










4002













UNCOV

4003



        code = buildComposedDataBlockImpl(pReader, pScanInfo, &pReader->status.fileBlockData, pSttBlockReader);




×








UNCOV

4004



        TSDB_CHECK_CODE(code, lino, _end);





×







4005













UNCOV

4006



        if (pResBlock->info.rows >= pReader->resBlockInfo.capacity) {





×








UNCOV

4007



          break;




×







4008



        }










4009












4010



        // data in stt now overlaps with current active file data block, need to composed with file data block.











UNCOV

4011



        SRowKey* pSttKey = getCurrentKeyInSttBlock(pSttBlockReader);




×








UNCOV

4012



        if ((pSttKey->ts >= pBlockInfo->firstKey && asc) || (pSttKey->ts <= pBlockInfo->lastKey && (!asc))) {





×







4013



          tsdbDebug("%p lastKeyInStt:%" PRId64 ", overlap with file block, brange:%" PRId64 "-%" PRId64 " %s", pReader,





×







4014



                    pSttKey->ts, pBlockInfo->firstKey, pBlockInfo->lastKey, pReader->idStr);










4015



          break;




×







4016



        }










4017



      }










4018













UNCOV

4019



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




×








UNCOV

4020



      updateComposedBlockInfo(pReader, el, pScanInfo);




×







4021













UNCOV

4022



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





×








UNCOV

4023



        tsdbDebug("%p uid:%" PRIu64 ", composed data block created, brange:%" PRIu64 "-%" PRIu64 " rows:%" PRId64





×







4024



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










4025



                  pReader, pResBlock->info.id.uid, pResBlock->info.window.skey, pResBlock->info.window.ekey,










4026



                  pResBlock->info.rows, el, pReader->idStr);










4027



      }










4028



    }










4029



  }










4030













UNCOV

4031



  code = pReader->code;




×








UNCOV

4032



  TSDB_CHECK_CODE(code, lino, _end);





×







4033













UNCOV

4034



_end:




×








UNCOV

4035



  if (code != TSDB_CODE_SUCCESS) {





×







4036



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





×







4037



  }











UNCOV

4038



  return code;




×







4039



}










4040













UNCOV

4041



static int32_t buildBlockFromBufferSeqForPreFileset(STsdbReader* pReader, int64_t endKey) {




×








UNCOV

4042



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

4043



  int32_t        lino = 0;




×








UNCOV

4044



  SReaderStatus* pStatus = NULL;




×







4045













UNCOV

4046



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





×







4047













UNCOV

4048



  pStatus = &pReader->status;




×







4049













UNCOV

4050



  tsdbDebug("seq load data blocks from cache that preceeds fileset %d, %s", pReader->status.pCurrentFileset->fid,





×







4051



            pReader->idStr);










4052













UNCOV

4053



  while (1) {




×








UNCOV

4054



    if (pReader->code != TSDB_CODE_SUCCESS) {





×







4055



      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);





×







4056



      code = pReader->code;




×







4057



      TSDB_CHECK_CODE(code, lino, _end);





×







4058



    }










4059













UNCOV

4060



    STableBlockScanInfo** pBlockScanInfo = pStatus->pProcMemTableIter;




×








UNCOV

4061



    if (pReader->pIgnoreTables &&





×








UNCOV

4062



        taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {




×








UNCOV

4063



      bool hasNexTable = moveToNextTableForPreFileSetMem(pStatus);




×








UNCOV

4064



      if (!hasNexTable) {





×







4065



        break;




×







4066



      }











UNCOV

4067



      continue;




×







4068



    }










4069













UNCOV

4070



    code = initMemDataIterator(*pBlockScanInfo, pReader);




×








UNCOV

4071



    TSDB_CHECK_CODE(code, lino, _end);





×







4072













UNCOV

4073



    code = initDelSkylineIterator(*pBlockScanInfo, pReader->info.order, &pReader->cost);




×








UNCOV

4074



    TSDB_CHECK_CODE(code, lino, _end);





×







4075













UNCOV

4076



    code = buildDataBlockFromBuf(pReader, *pBlockScanInfo, endKey);




×








UNCOV

4077



    TSDB_CHECK_CODE(code, lino, _end);





×







4078













UNCOV

4079



    if (pReader->resBlockInfo.pResBlock->info.rows > 0) {





×








UNCOV

4080



      break;




×







4081



    }










4082












4083



    // current table is exhausted, let's try next table











UNCOV

4084



    bool hasNexTable = moveToNextTableForPreFileSetMem(pStatus);




×








UNCOV

4085



    if (!hasNexTable) {





×








UNCOV

4086



      break;




×







4087



    }










4088



  }










4089













UNCOV

4090



_end:




×








UNCOV

4091



  if (code != TSDB_CODE_SUCCESS) {





×







4092



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





×







4093



  }











UNCOV

4094



  return code;




×







4095



}










4096













UNCOV

4097



static int32_t buildBlockFromBufferSequentially(STsdbReader* pReader, int64_t endKey) {




×








UNCOV

4098



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

4099



  int32_t        lino = 0;




×








UNCOV

4100



  SReaderStatus* pStatus = NULL;




×








UNCOV

4101



  STableUidList* pUidList = NULL;




×







4102













UNCOV

4103



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





×







4104













UNCOV

4105



  pStatus = &pReader->status;




×








UNCOV

4106



  pUidList = &pStatus->uidList;




×







4107













UNCOV

4108



  tsdbDebug("seq load data blocks from cache, %s", pReader->idStr);





×







4109













UNCOV

4110



  while (1) {




×








UNCOV

4111



    if (pReader->code != TSDB_CODE_SUCCESS) {





×







4112



      tsdbWarn("tsdb reader is stopped ASAP, code:%s, %s", tstrerror(pReader->code), pReader->idStr);





×







4113



      code = pReader->code;




×







4114



      TSDB_CHECK_CODE(code, lino, _end);





×







4115



    }










4116













UNCOV

4117



    STableBlockScanInfo** pBlockScanInfo = pStatus->pTableIter;




×








UNCOV

4118



    if (pBlockScanInfo == NULL || *pBlockScanInfo == NULL) {





×







4119



      break;










4120



    }










4121













UNCOV

4122



    if (pReader->pIgnoreTables &&





×








UNCOV

4123



        taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {




×








UNCOV

4124



      bool hasNexTable = moveToNextTable(pUidList, pStatus);




×








UNCOV

4125



      if (!hasNexTable) {





×








UNCOV

4126



        break;




×







4127



      }











UNCOV

4128



      continue;




×







4129



    }










4130













UNCOV

4131



    code = initMemDataIterator(*pBlockScanInfo, pReader);




×








UNCOV

4132



    TSDB_CHECK_CODE(code, lino, _end);





×







4133













UNCOV

4134



    code = initDelSkylineIterator(*pBlockScanInfo, pReader->info.order, &pReader->cost);




×








UNCOV

4135



    TSDB_CHECK_CODE(code, lino, _end);





×







4136













UNCOV

4137



    code = buildDataBlockFromBuf(pReader, *pBlockScanInfo, endKey);




×








UNCOV

4138



    TSDB_CHECK_CODE(code, lino, _end);





×







4139













UNCOV

4140



    if (pReader->resBlockInfo.pResBlock->info.rows > 0) {





×








UNCOV

4141



      break;




×







4142



    }










4143












4144



    // current table is exhausted, let's try next table











UNCOV

4145



    bool hasNexTable = moveToNextTable(pUidList, pStatus);




×








UNCOV

4146



    if (!hasNexTable) {





×








UNCOV

4147



      break;




×







4148



    }










4149



  }










4150












4151



_end:




×








UNCOV

4152



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

4153



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





×







4154



  }











UNCOV

4155



  return code;




×







4156



}










4157












4158



// set the correct start position in case of the first/last file block, according to the query time window











UNCOV

4159



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




×








UNCOV

4160



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

4161



  int32_t             lino = 0;




×








UNCOV

4162



  SFileDataBlockInfo* pBlockInfo = NULL;




×








UNCOV

4163



  SReaderStatus*      pStatus = NULL;




×








UNCOV

4164



  SFileBlockDumpInfo* pDumpInfo = NULL;




×







4165













UNCOV

4166



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





×







4167













UNCOV

4168



  pStatus = &pReader->status;




×








UNCOV

4169



  pDumpInfo = &pStatus->fBlockDumpInfo;




×







4170













UNCOV

4171



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




×








UNCOV

4172



  if (code == TSDB_CODE_SUCCESS) {





×








UNCOV

4173



    pDumpInfo->totalRows = pBlockInfo->numRow;




×








UNCOV

4174



    pDumpInfo->rowIndex = ASCENDING_TRAVERSE(pReader->info.order) ? 0 : pBlockInfo->numRow - 1;





×







4175



  } else {











UNCOV

4176



    pDumpInfo->totalRows = 0;




×








UNCOV

4177



    pDumpInfo->rowIndex = 0;




×








UNCOV

4178



    code = TSDB_CODE_SUCCESS;




×







4179



  }










4180













UNCOV

4181



  pDumpInfo->allDumped = false;




×







4182













UNCOV

4183



_end:




×








UNCOV

4184



  if (code != TSDB_CODE_SUCCESS) {





×







4185



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





×







4186



  }











UNCOV

4187



  return code;




×







4188



}










4189













UNCOV

4190



static int32_t initForFirstBlockInFile(STsdbReader* pReader, SDataBlockIter* pBlockIter) {




×








UNCOV

4191



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

4192



  int32_t      lino = 0;




×








UNCOV

4193



  SBlockNumber num = {0};




×








UNCOV

4194



  SArray*      pTableList = NULL;




×







4195













UNCOV

4196



  pTableList = taosArrayInit(40, POINTER_BYTES);




×








UNCOV

4197



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





×







4198













UNCOV

4199



  code = moveToNextFile(pReader, &num, pTableList);




×








UNCOV

4200



  TSDB_CHECK_CODE(code, lino, _end);





×







4201












4202



  // all data files are consumed, try data in buffer











UNCOV

4203



  if (num.numOfBlocks + num.numOfSttFiles == 0) {





×








UNCOV

4204



    pReader->status.loadFromFile = false;




×








UNCOV

4205



    goto _end;




×







4206



  }










4207












4208



  // initialize the block iterator for a new fileset











UNCOV

4209



  if (num.numOfBlocks > 0) {





×








UNCOV

4210



    code = initBlockIterator(pReader, pBlockIter, num.numOfBlocks, pTableList);




×








UNCOV

4211



    TSDB_CHECK_CODE(code, lino, _end);





×







4212



  } else {  // no block data, only last block exists











UNCOV

4213



    tBlockDataReset(&pReader->status.fileBlockData);




×








UNCOV

4214



    code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), pReader->idStr);




×








UNCOV

4215



    TSDB_CHECK_CODE(code, lino, _end);





×







4216













UNCOV

4217



    code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

4218



    TSDB_CHECK_CODE(code, lino, _end);





×







4219



  }










4220













UNCOV

4221



  code = initBlockDumpInfo(pReader, pBlockIter);




×








UNCOV

4222



  TSDB_CHECK_CODE(code, lino, _end);





×







4223













UNCOV

4224



_end:




×








UNCOV

4225



  if (code != TSDB_CODE_SUCCESS) {





×







4226



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





×







4227



  }











UNCOV

4228



  if (pTableList) {





×








UNCOV

4229



    taosArrayDestroy(pTableList);




×







4230



  }











UNCOV

4231



  return code;




×







4232



}










4233













UNCOV

4234



static bool fileBlockPartiallyRead(SFileBlockDumpInfo* pDumpInfo, bool asc) {




×








UNCOV

4235



  return (!pDumpInfo->allDumped) &&





×








UNCOV

4236



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





×







4237



}










4238












4239



typedef enum {










4240



  TSDB_READ_RETURN = 0x1,










4241



  TSDB_READ_CONTINUE = 0x2,










4242



} ERetrieveType;










4243













UNCOV

4244



static int32_t doReadDataFromSttFiles(STsdbReader* pReader, ERetrieveType* pReturnType) {




×








UNCOV

4245



  int32_t         code = TSDB_CODE_SUCCESS;




×








UNCOV

4246



  int32_t         lino = 0;




×








UNCOV

4247



  SSDataBlock*    pResBlock = NULL;




×








UNCOV

4248



  SDataBlockIter* pBlockIter = NULL;




×







4249













UNCOV

4250



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





×








UNCOV

4251



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





×







4252













UNCOV

4253



  pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

4254



  pBlockIter = &pReader->status.blockIter;




×







4255













UNCOV

4256



  *pReturnType = TSDB_READ_RETURN;




×







4257













UNCOV

4258



  tsdbDebug("seq load data blocks from stt files %s", pReader->idStr);





×







4259












4260



  while (1) {











UNCOV

4261



    code = doLoadSttBlockSequentially(pReader);




×








UNCOV

4262



    TSDB_CHECK_CODE(code, lino, _end);





×







4263













UNCOV

4264



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





×








UNCOV

4265



      goto _end;




×







4266



    }










4267












4268



    // all data blocks are checked in this stt file, now let's try the next file set











UNCOV

4269



    TSDB_CHECK_CONDITION(pReader->status.pTableIter == NULL, code, lino, _end, TSDB_CODE_INTERNAL_ERROR);





×







4270













UNCOV

4271



    code = initForFirstBlockInFile(pReader, pBlockIter);




×








UNCOV

4272



    TSDB_CHECK_CODE(code, lino, _end);





×







4273












4274



    // all the data files are completely checked











UNCOV

4275



    if (pReader->status.loadFromFile == false) {





×








UNCOV

4276



      goto _end;




×







4277



    }










4278













UNCOV

4279



    if (pReader->status.bProcMemPreFileset) {





×








UNCOV

4280



      code = buildFromPreFilesetBuffer(pReader);




×








UNCOV

4281



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4282



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





×








UNCOV

4283



        pReader->status.processingMemPreFileSet = true;




×








UNCOV

4284



        goto _end;




×







4285



      }










4286



    }










4287













UNCOV

4288



    if (pBlockIter->numOfBlocks > 0) {  // there are data blocks existed.





×








UNCOV

4289



      *pReturnType = TSDB_READ_CONTINUE;




×








UNCOV

4290



      goto _end;




×







4291



    } else {  // all blocks in data file are checked, let's check the data in stt-files











UNCOV

4292



      code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

4293



      TSDB_CHECK_CODE(code, lino, _end);





×







4294



    }










4295



  }










4296













UNCOV

4297



_end:




×








UNCOV

4298



  if (code != TSDB_CODE_SUCCESS) {





×







4299



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





×







4300



  }











UNCOV

4301



  return code;




×







4302



}










4303













UNCOV

4304



static int32_t buildBlockFromFiles(STsdbReader* pReader) {




×








UNCOV

4305



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

4306



  int32_t             lino = 0;




×








UNCOV

4307



  SDataBlockIter*     pBlockIter = NULL;




×








UNCOV

4308



  SSDataBlock*        pResBlock = NULL;




×








UNCOV

4309



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

4310



  SBlockData*         pBlockData = NULL;




×








UNCOV

4311



  const char*         id = NULL;




×








UNCOV

4312



  bool                asc = false;




×







4313













UNCOV

4314



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





×







4315













UNCOV

4316



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




×







4317













UNCOV

4318



  pBlockIter = &pReader->status.blockIter;




×








UNCOV

4319



  pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

4320



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

4321



  pBlockData = &pReader->status.fileBlockData;




×








UNCOV

4322



  id = pReader->idStr;




×







4323













UNCOV

4324



  if (pBlockIter->numOfBlocks == 0) {





×







4325



    // let's try to extract data from stt files.











UNCOV

4326



    ERetrieveType type = 0;




×








UNCOV

4327



    code = doReadDataFromSttFiles(pReader, &type);




×








UNCOV

4328



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4329



    if (type == TSDB_READ_RETURN) {





×








UNCOV

4330



      goto _end;




×







4331



    }










4332












4333



    code = doBuildDataBlock(pReader);




×








UNCOV

4334



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4335



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





×








UNCOV

4336



      goto _end;




×







4337



    }










4338



  }










4339












4340



  while (1) {











UNCOV

4341



    if (fileBlockPartiallyRead(pDumpInfo, asc)) {  // file data block is partially loaded





×








UNCOV

4342



      code = buildComposedDataBlock(pReader);




×








UNCOV

4343



      TSDB_CHECK_CODE(code, lino, _end);





×







4344



    } else {










4345



      // current block are exhausted, try the next file block











UNCOV

4346



      if (pDumpInfo->allDumped) {





×







4347



        // try next data block in current file











UNCOV

4348



        bool hasNext = blockIteratorNext(&pReader->status.blockIter);




×








UNCOV

4349



        if (hasNext) {  // check for the next block in the block accessed order list





×








UNCOV

4350



          code = initBlockDumpInfo(pReader, pBlockIter);




×








UNCOV

4351



          TSDB_CHECK_CODE(code, lino, _end);





×







4352



        } else {










4353



          // all data blocks in files are checked, let's check the data in last files.










4354



          // data blocks in current file are exhausted, let's try the next file now











UNCOV

4355



          if (pBlockData->uid != 0) {





×








UNCOV

4356



            tBlockDataClear(pBlockData);




×







4357



          }










4358













UNCOV

4359



          tBlockDataReset(pBlockData);




×








UNCOV

4360



          code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), id);




×








UNCOV

4361



          TSDB_CHECK_CODE(code, lino, _end);





×







4362













UNCOV

4363



          code = resetTableListIndex(&pReader->status, id);




×








UNCOV

4364



          TSDB_CHECK_CODE(code, lino, _end);





×







4365













UNCOV

4366



          ERetrieveType type = 0;




×








UNCOV

4367



          code = doReadDataFromSttFiles(pReader, &type);




×








UNCOV

4368



          TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4369



          if (type == TSDB_READ_RETURN) {





×








UNCOV

4370



            break;




×







4371



          }










4372



        }










4373



      }










4374













UNCOV

4375



      code = doBuildDataBlock(pReader);




×








UNCOV

4376



      TSDB_CHECK_CODE(code, lino, _end);





×







4377



    }










4378













UNCOV

4379



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





×








UNCOV

4380



      break;




×







4381



    }










4382



  }










4383













UNCOV

4384



_end:




×








UNCOV

4385



  if (code != TSDB_CODE_SUCCESS) {





×







4386



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





×







4387



  }











UNCOV

4388



  return code;




×







4389



}










4390













UNCOV

4391



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




×







4392



                                int8_t* pLevel, STsdb** pTsdb) {











UNCOV

4393



  if (pTsdb == NULL) {





×







4394



    return;




×







4395



  }










4396













UNCOV

4397



  *pTsdb = NULL;




×








UNCOV

4398



  if (VND_IS_RSMA(pVnode) && !pCond->skipRollup) {





×








UNCOV

4399



    int8_t  level = 0;




×








UNCOV

4400



    int8_t  precision = pVnode->config.tsdbCfg.precision;




×








UNCOV

4401



    int64_t now = taosGetTimestamp(precision);





×








UNCOV

4402



    int64_t offset = tsQueryRsmaTolerance * ((precision == TSDB_TIME_PRECISION_MILLI)   ? 1L




×








UNCOV

4403



                                             : (precision == TSDB_TIME_PRECISION_MICRO) ? 1000L





×







4404



                                                                                        : 1000000L);





×







4405













UNCOV

4406



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





×








UNCOV

4407



      SRetention* pRetention = retentions + level;




×








UNCOV

4408



      if (pRetention->keep <= 0) {





×







4409



        if (level > 0) {





×







4410



          --level;




×







4411



        }










4412



        break;




×







4413



      }











UNCOV

4414



      if ((now - pRetention->keep) <= (pCond->twindows.skey + offset)) {





×








UNCOV

4415



        break;




×







4416



      }











UNCOV

4417



      ++level;




×







4418



    }










4419













UNCOV

4420



    const char* str = (idStr != NULL) ? idStr : "";





×







4421













UNCOV

4422



    if (level == TSDB_RETENTION_L0) {





×








UNCOV

4423



      *pLevel = TSDB_RETENTION_L0;




×








UNCOV

4424



      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L0, str);





×








UNCOV

4425



      *pTsdb = VND_RSMA0(pVnode);




×








UNCOV

4426



      return;




×








UNCOV

4427



    } else if (level == TSDB_RETENTION_L1) {





×








UNCOV

4428



      *pLevel = TSDB_RETENTION_L1;




×








UNCOV

4429



      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L1, str);





×








UNCOV

4430



      *pTsdb = VND_RSMA1(pVnode);




×








UNCOV

4431



      return;




×







4432



    } else {











UNCOV

4433



      *pLevel = TSDB_RETENTION_L2;




×








UNCOV

4434



      tsdbDebug("vgId:%d, rsma level %d is selected to query %s", TD_VID(pVnode), TSDB_RETENTION_L2, str);





×








UNCOV

4435



      *pTsdb = VND_RSMA2(pVnode);




×








UNCOV

4436



      return;




×







4437



    }










4438



  }










4439













UNCOV

4440



  *pTsdb = VND_TSDB(pVnode);




×







4441



}










4442













UNCOV

4443



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




×








UNCOV

4444



  int64_t startVer = (pCond->startVersion == -1) ? 0 : pCond->startVersion;





×







4445













UNCOV

4446



  int64_t endVer = 0;




×








UNCOV

4447



  if (pCond->endVersion == -1) {





×







4448



    // user not specified end version, set current maximum version of vnode as the endVersion











UNCOV

4449



    endVer = pVnode->state.applied;




×







4450



  } else {











UNCOV

4451



    endVer = (pCond->endVersion > pVnode->state.applied) ? pVnode->state.applied : pCond->endVersion;




×







4452



  }










4453













UNCOV

4454



  return (SVersionRange){.minVer = startVer, .maxVer = endVer};




×







4455



}










4456













UNCOV

4457



static int32_t reverseSearchStartPos(const SArray* pDelList, int32_t index, int64_t key, bool asc, int32_t* start) {




×








UNCOV

4458



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

4459



  int32_t lino = 0;




×








UNCOV

4460



  size_t  num = 0;




×







4461













UNCOV

4462



  num = taosArrayGetSize(pDelList);




×








UNCOV

4463



  *start = index;




×







4464













UNCOV

4465



  if (asc) {





×








UNCOV

4466



    if (*start >= num - 1) {





×








UNCOV

4467



      *start = num - 1;




×







4468



    }










4469













UNCOV

4470



    TSDBKEY* p = taosArrayGet(pDelList, *start);




×








UNCOV

4471



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





×







4472













UNCOV

4473



    while (p->ts >= key && *start > 0) {





×








UNCOV

4474



      *start -= 1;




×







4475



    }










4476



  } else {











UNCOV

4477



    if (index <= 0) {





×







4478



      *start = 0;




×







4479



    }










4480













UNCOV

4481



    TSDBKEY* p = taosArrayGet(pDelList, *start);




×








UNCOV

4482



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





×







4483













UNCOV

4484



    while (p->ts <= key && *start < num - 1) {





×








UNCOV

4485



      *start += 1;




×







4486



    }










4487



  }










4488













UNCOV

4489



_end:




×








UNCOV

4490



  if (code != TSDB_CODE_SUCCESS) {





×







4491



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





×







4492



  }











UNCOV

4493



  return code;




×







4494



}










4495













UNCOV

4496



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




×







4497



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











UNCOV

4498



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

4499



  int32_t lino = 0;




×








UNCOV

4500



  size_t  num = 0;




×








UNCOV

4501



  int32_t step = 0;




×








UNCOV

4502



  bool    asc = false;




×







4503













UNCOV

4504



  *dropped = false;




×







4505













UNCOV

4506



  if (pDelList == NULL || (TARRAY_SIZE(pDelList) == 0)) {





×







4507



    goto _end;




×







4508



  }










4509













UNCOV

4510



  num = taosArrayGetSize(pDelList);




×








UNCOV

4511



  asc = ASCENDING_TRAVERSE(order);




×








UNCOV

4512



  step = asc ? 1 : -1;





×







4513













UNCOV

4514



  if (hasPk) {  // handle the case where duplicated timestamps existed.





×








UNCOV

4515



    code = reverseSearchStartPos(pDelList, *index, key, asc, index);




×








UNCOV

4516



    TSDB_CHECK_CODE(code, lino, _end);





×







4517



  }










4518













UNCOV

4519



  if (asc) {





×








UNCOV

4520



    if (*index >= num - 1) {





×








UNCOV

4521



      TSDBKEY* last = taosArrayGetLast(pDelList);




×








UNCOV

4522



      if (last == NULL) {





×







4523



        goto _end;




×







4524



      }










4525













UNCOV

4526



      if (key > last->ts) {





×








UNCOV

4527



        goto _end;




×








UNCOV

4528



      } else if (key == last->ts) {





×








UNCOV

4529



        TSDBKEY* prev = taosArrayGet(pDelList, num - 2);




×








UNCOV

4530



        if (prev == NULL) {





×







4531



          goto _end;




×







4532



        }










4533













UNCOV

4534



        *dropped = (prev->version >= ver && prev->version <= pVerRange->maxVer && prev->version >= pVerRange->minVer);





×







4535



      }










4536



    } else {











UNCOV

4537



      TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);




×








UNCOV

4538



      TSDBKEY* pNext = taosArrayGet(pDelList, (*index) + 1);




×








UNCOV

4539



      if (pCurrent == NULL || pNext == NULL) {





×







4540



        goto _end;




×







4541



      }










4542













UNCOV

4543



      if (key < pCurrent->ts) {





×








UNCOV

4544



        goto _end;




×







4545



      }










4546













UNCOV

4547



      if (pCurrent->ts <= key && pNext->ts >= key && pCurrent->version >= ver &&





×








UNCOV

4548



          pVerRange->maxVer >= pCurrent->version) {





×








UNCOV

4549



        *dropped = true;




×








UNCOV

4550



        goto _end;




×







4551



      }










4552













UNCOV

4553



      while (pNext->ts <= key && (*index) < num - 1) {





×








UNCOV

4554



        (*index) += 1;




×







4555













UNCOV

4556



        if ((*index) < num - 1) {





×








UNCOV

4557



          pCurrent = taosArrayGet(pDelList, *index);




×








UNCOV

4558



          pNext = taosArrayGet(pDelList, (*index) + 1);




×








UNCOV

4559



          if (pCurrent == NULL || pNext == NULL) {





×







4560



            break;










4561



          }










4562












4563



          // it is not a consecutive deletion range, ignore it











UNCOV

4564



          if (pCurrent->version == 0 && pNext->version > 0) {





×








UNCOV

4565



            continue;




×







4566



          }










4567













UNCOV

4568



          if (pCurrent->ts <= key && pNext->ts >= key && pCurrent->version >= ver &&





×








UNCOV

4569



              pVerRange->maxVer >= pCurrent->version) {





×








UNCOV

4570



            *dropped = true;




×








UNCOV

4571



            break;




×







4572



          }










4573



        }










4574



      }










4575



    }










4576



  } else {











UNCOV

4577



    if (*index <= 0) {





×







4578



      TSDBKEY* pFirst = taosArrayGet(pDelList, 0);




×







4579



      if (pFirst == NULL) {





×







4580



        goto _end;




×







4581



      }










4582












4583



      if (key < pFirst->ts) {





×







4584



        goto _end;




×







4585



      } else if (key == pFirst->ts) {





×







4586



        *dropped = pFirst->version >= ver;




×







4587



      } else {










4588



        tsdbError("unexpected error, key:%" PRId64 ", first:%" PRId64, key, pFirst->ts);





×







4589



      }










4590



    } else {











UNCOV

4591



      TSDBKEY* pCurrent = taosArrayGet(pDelList, *index);




×








UNCOV

4592



      TSDBKEY* pPrev = taosArrayGet(pDelList, (*index) - 1);




×








UNCOV

4593



      if (pCurrent == NULL || pPrev == NULL) {





×







4594



        goto _end;




×







4595



      }










4596













UNCOV

4597



      if (key > pCurrent->ts) {





×








UNCOV

4598



        goto _end;




×







4599



      }










4600













UNCOV

4601



      if (pPrev->ts <= key && pCurrent->ts >= key && pPrev->version >= ver) {





×








UNCOV

4602



        *dropped = true;




×








UNCOV

4603



        goto _end;




×







4604



      }










4605













UNCOV

4606



      while (pPrev->ts >= key && (*index) > 1) {





×








UNCOV

4607



        (*index) += step;




×







4608













UNCOV

4609



        if ((*index) >= 1) {





×








UNCOV

4610



          pCurrent = taosArrayGet(pDelList, *index);




×








UNCOV

4611



          pPrev = taosArrayGet(pDelList, (*index) - 1);




×








UNCOV

4612



          if (pCurrent == NULL || pPrev == NULL) {





×







4613



            break;










4614



          }










4615












4616



          // it is not a consecutive deletion range, ignore it











UNCOV

4617



          if (pCurrent->version > 0 && pPrev->version == 0) {





×








UNCOV

4618



            continue;




×







4619



          }










4620













UNCOV

4621



          if (pPrev->ts <= key && pCurrent->ts >= key && pPrev->version >= ver) {





×








UNCOV

4622



            *dropped = true;




×








UNCOV

4623



            break;




×







4624



          }










4625



        }










4626



      }










4627



    }










4628



  }










4629













UNCOV

4630



_end:




×








UNCOV

4631



  if (code != TSDB_CODE_SUCCESS) {





×







4632



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





×







4633



  }











UNCOV

4634



  return code;




×







4635



}










4636












4637



FORCE_INLINE int32_t getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader, TSDBROW** pRes) {











UNCOV

4638



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

4639



  int32_t  lino = 0;




×








UNCOV

4640



  int32_t  order = 0;




×








UNCOV

4641



  TSDBROW* pRow = NULL;




×







4642



  TSDBKEY  key;










4643













UNCOV

4644



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





×








UNCOV

4645



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





×







4646













UNCOV

4647



  *pRes = NULL;




×







4648













UNCOV

4649



  if (!pIter->hasVal) {





×








UNCOV

4650



    goto _end;




×







4651



  }










4652













UNCOV

4653



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





×








UNCOV

4654



  order = pReader->info.order;




×








UNCOV

4655



  pRow = tsdbTbDataIterGet(pIter->iter);





×







4656













UNCOV

4657



  TSDBROW_INIT_KEY(pRow, key);





×








UNCOV

4658



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





×







4659



    pIter->hasVal = false;




×







4660



    goto _end;




×







4661



  }










4662












4663



  // it is a valid data version











UNCOV

4664



  if (key.version <= pReader->info.verRange.maxVer && key.version >= pReader->info.verRange.minVer) {





×








UNCOV

4665



    if (pDelList == NULL || TARRAY_SIZE(pDelList) == 0) {





×








UNCOV

4666



      *pRes = pRow;




×








UNCOV

4667



      goto _end;




×







4668



    } else {











UNCOV

4669



      bool dropped = false;




×








UNCOV

4670



      code = hasBeenDropped(pDelList, &pIter->index, key.ts, key.version, order, &pReader->info.verRange,




×








UNCOV

4671



                            pReader->suppInfo.numOfPks > 0, &dropped);




×








UNCOV

4672



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4673



      if (!dropped) {





×








UNCOV

4674



        *pRes = pRow;




×








UNCOV

4675



        goto _end;




×







4676



      }










4677



    }










4678



  }










4679












4680



  while (1) {











UNCOV

4681



    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);




×








UNCOV

4682



    if (!pIter->hasVal) {





×








UNCOV

4683



      goto _end;




×







4684



    }










4685













UNCOV

4686



    pRow = tsdbTbDataIterGet(pIter->iter);





×







4687













UNCOV

4688



    TSDBROW_INIT_KEY(pRow, key);





×








UNCOV

4689



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





×








UNCOV

4690



      pIter->hasVal = false;




×








UNCOV

4691



      goto _end;




×







4692



    }










4693













UNCOV

4694



    if (key.version <= pReader->info.verRange.maxVer && key.version >= pReader->info.verRange.minVer) {





×








UNCOV

4695



      if (pDelList == NULL || TARRAY_SIZE(pDelList) == 0) {





×








UNCOV

4696



        *pRes = pRow;




×








UNCOV

4697



        goto _end;




×







4698



      } else {











UNCOV

4699



        bool dropped = false;




×








UNCOV

4700



        code = hasBeenDropped(pDelList, &pIter->index, key.ts, key.version, order, &pReader->info.verRange,




×








UNCOV

4701



                              pReader->suppInfo.numOfPks > 0, &dropped);




×








UNCOV

4702



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4703



        if (!dropped) {





×








UNCOV

4704



          *pRes = pRow;




×








UNCOV

4705



          goto _end;




×







4706



        }










4707



      }










4708



    }










4709



  }










4710













UNCOV

4711



_end:




×








UNCOV

4712



  if (code != TSDB_CODE_SUCCESS) {





×







4713



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





×







4714



  }











UNCOV

4715



  return code;




×







4716



}










4717













UNCOV

4718



int32_t doMergeRowsInBuf(SIterInfo* pIter, uint64_t uid, SRowKey* pCurKey, SArray* pDelList, STsdbReader* pReader) {




×








UNCOV

4719



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

4720



  int32_t     lino = 0;




×








UNCOV

4721



  SRowMerger* pMerger = NULL;




×







4722













UNCOV

4723



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





×








UNCOV

4724



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





×







4725













UNCOV

4726



  pMerger = &pReader->status.merger;




×







4727













UNCOV

4728



  while (1) {




×








UNCOV

4729



    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);




×








UNCOV

4730



    if (!pIter->hasVal) {





×








UNCOV

4731



      break;




×







4732



    }










4733












4734



    // data exists but not valid











UNCOV

4735



    TSDBROW* pRow = NULL;





×








UNCOV

4736



    code = getValidMemRow(pIter, pDelList, pReader, &pRow);




×








UNCOV

4737



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4738



    if (pRow == NULL) {





×








UNCOV

4739



      break;




×







4740



    }










4741












4742



    // ts is not identical, quit











UNCOV

4743



    if (TSDBROW_TS(pRow) != pCurKey->ts) {





×








UNCOV

4744



      break;




×







4745



    }










4746













UNCOV

4747



    if (pCurKey->numOfPKs > 0) {





×








UNCOV

4748



      SRowKey nextKey = {0};




×








UNCOV

4749



      tRowGetKeyEx(pRow, &nextKey);





×








UNCOV

4750



      if (pkCompEx(pCurKey, &nextKey) != 0) {





×








UNCOV

4751



        break;




×







4752



      }










4753



    }










4754













UNCOV

4755



    STSchema* pTSchema = NULL;




×








UNCOV

4756



    if (pRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

4757



      pTSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(pRow), pReader, uid);





×








UNCOV

4758



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





×







4759



    }










4760













UNCOV

4761



    code = tsdbRowMergerAdd(pMerger, pRow, pTSchema);




×








UNCOV

4762



    TSDB_CHECK_CODE(code, lino, _end);





×







4763



  }










4764













UNCOV

4765



_end:




×








UNCOV

4766



  if (code != TSDB_CODE_SUCCESS) {





×







4767



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





×







4768



  }











UNCOV

4769



  return code;




×







4770



}










4771













UNCOV

4772



static int32_t doMergeRowsInFileBlockImpl(SBlockData* pBlockData, int32_t* rowIndex, SRowKey* pKey, SRowMerger* pMerger,




×







4773



                                          SVersionRange* pVerRange, int32_t step) {











UNCOV

4774



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

4775



  int32_t lino = 0;




×







4776













UNCOV

4777



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





×








UNCOV

4778



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





×







4779













UNCOV

4780



  while ((*rowIndex) < pBlockData->nRow && (*rowIndex) >= 0) {





×







4781



    SRowKey cur;











UNCOV

4782



    tColRowGetKey(pBlockData, (*rowIndex), &cur);





×








UNCOV

4783



    if (pkCompEx(&cur, pKey) != 0) {





×








UNCOV

4784



      break;




×







4785



    }










4786












4787



    if (pBlockData->aVersion[(*rowIndex)] > pVerRange->maxVer ||





×








UNCOV

4788



        pBlockData->aVersion[(*rowIndex)] < pVerRange->minVer) {





×







4789



      (*rowIndex) += step;




×







4790



      continue;




×







4791



    }










4792













UNCOV

4793



    TSDBROW fRow = tsdbRowFromBlockData(pBlockData, (*rowIndex));




×








UNCOV

4794



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




×








UNCOV

4795



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4796



    (*rowIndex) += step;




×







4797



  }










4798













UNCOV

4799



_end:




×








UNCOV

4800



  if (code != TSDB_CODE_SUCCESS) {





×







4801



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





×







4802



  }











UNCOV

4803



  return code;




×







4804



}










4805












4806



typedef enum {










4807



  CHECK_FILEBLOCK_CONT = 0x1,










4808



  CHECK_FILEBLOCK_QUIT = 0x2,










4809



} CHECK_FILEBLOCK_STATE;










4810













UNCOV

4811



static int32_t checkForNeighborFileBlock(STsdbReader* pReader, STableBlockScanInfo* pScanInfo,




×







4812



                                         SFileDataBlockInfo* pFBlock, SRowMerger* pMerger, SRowKey* pKey,










4813



                                         CHECK_FILEBLOCK_STATE* state) {











UNCOV

4814



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

4815



  int32_t             lino = 0;




×








UNCOV

4816



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

4817



  SBlockData*         pBlockData = NULL;




×








UNCOV

4818



  bool                asc = false;




×








UNCOV

4819



  SVersionRange*      pVerRange = NULL;




×








UNCOV

4820



  bool                loadNeighbor = true;




×








UNCOV

4821



  int32_t             step = 0;




×







4822













UNCOV

4823



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





×








UNCOV

4824



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





×







4825













UNCOV

4826



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

4827



  pBlockData = &pReader->status.fileBlockData;




×








UNCOV

4828



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




×








UNCOV

4829



  pVerRange = &pReader->info.verRange;




×








UNCOV

4830



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





×







4831













UNCOV

4832



  *state = CHECK_FILEBLOCK_QUIT;




×








UNCOV

4833



  code = loadNeighborIfOverlap(pFBlock, pScanInfo, pReader, &loadNeighbor);




×








UNCOV

4834



  TSDB_CHECK_CODE(code, lino, _end);





×







4835













UNCOV

4836



  if (loadNeighbor) {





×








UNCOV

4837



    code = doMergeRowsInFileBlockImpl(pBlockData, &pDumpInfo->rowIndex, pKey, pMerger, pVerRange, step);




×








UNCOV

4838



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4839



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





×







4840



      *state = CHECK_FILEBLOCK_CONT;




×







4841



    }










4842



  }










4843













UNCOV

4844



_end:




×








UNCOV

4845



  if (code != TSDB_CODE_SUCCESS) {





×







4846



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





×







4847



  }











UNCOV

4848



  return code;




×







4849



}










4850













UNCOV

4851



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




×







4852



                                STsdbReader* pReader) {











UNCOV

4853



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

4854



  int32_t             lino = 0;




×








UNCOV

4855



  SFileBlockDumpInfo* pDumpInfo = NULL;




×








UNCOV

4856



  SRowMerger*         pMerger = NULL;




×








UNCOV

4857



  bool                asc = false;




×








UNCOV

4858



  int32_t             step = 0;




×








UNCOV

4859



  SVersionRange*      pRange = NULL;




×







4860













UNCOV

4861



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





×








UNCOV

4862



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





×







4863













UNCOV

4864



  pDumpInfo = &pReader->status.fBlockDumpInfo;




×








UNCOV

4865



  pMerger = &pReader->status.merger;




×








UNCOV

4866



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




×








UNCOV

4867



  step = asc ? 1 : -1;





×








UNCOV

4868



  pRange = &pReader->info.verRange;




×







4869













UNCOV

4870



  pDumpInfo->rowIndex += step;




×








UNCOV

4871



  if ((pDumpInfo->rowIndex <= pBlockData->nRow - 1 && asc) || (pDumpInfo->rowIndex >= 0 && !asc)) {





×








UNCOV

4872



    code = doMergeRowsInFileBlockImpl(pBlockData, &pDumpInfo->rowIndex, pKey, pMerger, pRange, step);




×








UNCOV

4873



    TSDB_CHECK_CODE(code, lino, _end);





×







4874



  }










4875












4876



  // all rows are consumed, let's try next file block











UNCOV

4877



  if ((pDumpInfo->rowIndex >= pBlockData->nRow && asc) || (pDumpInfo->rowIndex < 0 && !asc)) {





×







4878



    while (1) {




×








UNCOV

4879



      SFileDataBlockInfo* pFileBlockInfo = NULL;




×








UNCOV

4880



      code = getCurrentBlockInfo(&pReader->status.blockIter, &pFileBlockInfo, pReader->idStr);




×








UNCOV

4881



      TSDB_CHECK_CODE(code, lino, _end);





×







4882













UNCOV

4883



      if (pFileBlockInfo == NULL) {





×








UNCOV

4884



        break;




×







4885



      }










4886













UNCOV

4887



      CHECK_FILEBLOCK_STATE st = CHECK_FILEBLOCK_QUIT;




×








UNCOV

4888



      code = checkForNeighborFileBlock(pReader, pScanInfo, pFileBlockInfo, pMerger, pKey, &st);




×








UNCOV

4889



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4890



      if (st == CHECK_FILEBLOCK_QUIT) {





×








UNCOV

4891



        break;




×







4892



      }










4893



    }










4894



  }










4895













UNCOV

4896



_end:




×








UNCOV

4897



  if (code != TSDB_CODE_SUCCESS) {





×







4898



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





×







4899



  }











UNCOV

4900



  return code;




×







4901



}










4902













UNCOV

4903



int32_t doMergeRowsInSttBlock(SSttBlockReader* pSttBlockReader, STableBlockScanInfo* pScanInfo, SRowMerger* pMerger,




×







4904



                              int32_t pkSrcSlot, SVersionRange* pVerRange, const char* idStr) {











UNCOV

4905



  int32_t  code = TSDB_CODE_SUCCESS;




×








UNCOV

4906



  int32_t  lino = 0;




×








UNCOV

4907



  SRowKey* pRowKey = NULL;




×








UNCOV

4908



  SRowKey* pNextKey = NULL;




×







4909













UNCOV

4910



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





×







4911













UNCOV

4912



  pRowKey = &pScanInfo->lastProcKey;




×







4913













UNCOV

4914



  while (1) {




×








UNCOV

4915



    code = nextRowFromSttBlocks(pSttBlockReader, pScanInfo, pkSrcSlot, pVerRange);




×








UNCOV

4916



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4917



    if (!hasDataInSttBlock(pScanInfo)) {





×








UNCOV

4918



      break;




×







4919



    }










4920













UNCOV

4921



    pNextKey = getCurrentKeyInSttBlock(pSttBlockReader);





×







4922













UNCOV

4923



    int32_t ret = pkCompEx(pRowKey, pNextKey);




×








UNCOV

4924



    if (ret == 0) {





×








UNCOV

4925



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




×








UNCOV

4926



      code = tsdbRowMergerAdd(pMerger, pRow1, NULL);




×








UNCOV

4927



      TSDB_CHECK_CODE(code, lino, _end);





×







4928



    } else {











UNCOV

4929



      tsdbTrace("uid:%" PRIu64 " last del index:%d, del range:%d, lastKeyInStt:%" PRId64 ", %s", pScanInfo->uid,





×







4930



                pScanInfo->sttBlockDelIndex, (int32_t)taosArrayGetSize(pScanInfo->delSkyline),










4931



                pScanInfo->sttKeyInfo.nextProcKey.ts, idStr);











UNCOV

4932



      break;




×







4933



    }










4934



  }










4935













UNCOV

4936



_end:




×








UNCOV

4937



  if (code != TSDB_CODE_SUCCESS) {





×







4938



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





×







4939



  }











UNCOV

4940



  return code;




×







4941



}










4942













UNCOV

4943



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




×







4944



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











UNCOV

4945



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

4946



  int32_t     lino = 0;




×








UNCOV

4947



  SRowMerger* pMerger = NULL;




×








UNCOV

4948



  TSDBROW*    pNextRow = NULL;




×








UNCOV

4949



  STSchema*   pTSchema = NULL;




×








UNCOV

4950



  STSchema*   pTSchema1 = NULL;




×







4951



  TSDBROW     current;










4952













UNCOV

4953



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





×








UNCOV

4954



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





×








UNCOV

4955



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





×








UNCOV

4956



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





×








UNCOV

4957



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





×







4958













UNCOV

4959



  pMerger = &pReader->status.merger;




×








UNCOV

4960



  current = *pRow;




×







4961












4962



  {  // if the timestamp of the next valid row has a different ts, return current row directly











UNCOV

4963



    pIter->hasVal = tsdbTbDataIterNext(pIter->iter);




×







4964













UNCOV

4965



    if (!pIter->hasVal) {





×








UNCOV

4966



      *pResRow = *pRow;




×








UNCOV

4967



      *freeTSRow = false;




×








UNCOV

4968



      goto _end;




×







4969



    } else {  // has next point in mem/imem











UNCOV

4970



      code = getValidMemRow(pIter, pDelList, pReader, &pNextRow);




×








UNCOV

4971



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

4972



      if (pNextRow == NULL) {





×








UNCOV

4973



        *pResRow = current;




×








UNCOV

4974



        *freeTSRow = false;




×








UNCOV

4975



        goto _end;




×







4976



      }










4977













UNCOV

4978



      if (TSDBROW_TS(&current) != TSDBROW_TS(pNextRow)) {





×








UNCOV

4979



        *pResRow = current;




×








UNCOV

4980



        *freeTSRow = false;




×








UNCOV

4981



        goto _end;




×







4982



      }










4983













UNCOV

4984



      if (pKey->numOfPKs > 0) {





×








UNCOV

4985



        SRowKey nextRowKey = {0};




×








UNCOV

4986



        tRowGetKeyEx(pNextRow, &nextRowKey);





×








UNCOV

4987



        if (pkCompEx(pKey, &nextRowKey) != 0) {





×








UNCOV

4988



          *pResRow = current;




×








UNCOV

4989



          *freeTSRow = false;




×








UNCOV

4990



          goto _end;




×







4991



        }










4992



      }










4993



    }










4994



  }










4995












4996



  // start to merge duplicated rows











UNCOV

4997



  if (current.type == TSDBROW_ROW_FMT) {  // get the correct schema for row-wise data in memory





×








UNCOV

4998



    pTSchema = doGetSchemaForTSRow(current.pTSRow->sver, pReader, uid);





×








UNCOV

4999



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





×







5000



  }










5001













UNCOV

5002



  code = tsdbRowMergerAdd(pMerger, &current, pTSchema);




×








UNCOV

5003



  TSDB_CHECK_CODE(code, lino, _end);





×







5004













UNCOV

5005



  if (pNextRow->type == TSDBROW_ROW_FMT) {  // get the correct schema for row-wise data in memory





×








UNCOV

5006



    pTSchema1 = doGetSchemaForTSRow(pNextRow->pTSRow->sver, pReader, uid);





×








UNCOV

5007



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





×







5008



  }










5009













UNCOV

5010



  code = tsdbRowMergerAdd(pMerger, pNextRow, pTSchema1);




×








UNCOV

5011



  TSDB_CHECK_CODE(code, lino, _end);





×







5012













UNCOV

5013



  code = doMergeRowsInBuf(pIter, uid, pKey, pDelList, pReader);




×








UNCOV

5014



  TSDB_CHECK_CODE(code, lino, _end);





×







5015













UNCOV

5016



  code = tsdbRowMergerGetRow(pMerger, &pResRow->pTSRow);




×








UNCOV

5017



  TSDB_CHECK_CODE(code, lino, _end);





×







5018













UNCOV

5019



  pResRow->type = TSDBROW_ROW_FMT;




×








UNCOV

5020



  tsdbRowMergerClear(pMerger);




×








UNCOV

5021



  *freeTSRow = true;




×







5022













UNCOV

5023



_end:




×








UNCOV

5024



  if (code != TSDB_CODE_SUCCESS) {





×







5025



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





×







5026



  }











UNCOV

5027



  return code;




×







5028



}










5029













UNCOV

5030



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




×







5031



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











UNCOV

5032



  int32_t     code = TSDB_CODE_SUCCESS;




×








UNCOV

5033



  int32_t     lino = 0;




×








UNCOV

5034



  SRowMerger* pMerger = NULL;




×








UNCOV

5035



  STSchema*   pSchema = NULL;




×








UNCOV

5036



  STSchema*   piSchema = NULL;




×







5037













UNCOV

5038



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





×








UNCOV

5039



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





×








UNCOV

5040



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





×








UNCOV

5041



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





×







5042













UNCOV

5043



  pMerger = &pReader->status.merger;




×







5044













UNCOV

5045



  if (pRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

5046



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





×








UNCOV

5047



    TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);





×







5048



  }










5049













UNCOV

5050



  if (piRow->type == TSDBROW_ROW_FMT) {





×








UNCOV

5051



    piSchema = doGetSchemaForTSRow(TSDBROW_SVERSION(piRow), pReader, pBlockScanInfo->uid);





×








UNCOV

5052



    TSDB_CHECK_NULL(piSchema, code, lino, _end, terrno);





×







5053



  }










5054













UNCOV

5055



  if (ASCENDING_TRAVERSE(pReader->info.order)) {  // ascending order imem --> mem





×








UNCOV

5056



    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);




×








UNCOV

5057



    TSDB_CHECK_CODE(code, lino, _end);





×







5058













UNCOV

5059



    code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, piRowKey, pBlockScanInfo->delSkyline, pReader);




×








UNCOV

5060



    TSDB_CHECK_CODE(code, lino, _end);





×







5061













UNCOV

5062



    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);




×








UNCOV

5063



    TSDB_CHECK_CODE(code, lino, _end);





×







5064













UNCOV

5065



    code = doMergeRowsInBuf(&pBlockScanInfo->iter, pBlockScanInfo->uid, pRowKey, pBlockScanInfo->delSkyline, pReader);




×








UNCOV

5066



    TSDB_CHECK_CODE(code, lino, _end);





×







5067



  } else {










5068



    code = tsdbRowMergerAdd(pMerger, pRow, pSchema);




×







5069



    TSDB_CHECK_CODE(code, lino, _end);





×







5070












5071



    code = doMergeRowsInBuf(&pBlockScanInfo->iter, pBlockScanInfo->uid, pRowKey, pBlockScanInfo->delSkyline, pReader);




×







5072



    TSDB_CHECK_CODE(code, lino, _end);





×







5073












5074



    code = tsdbRowMergerAdd(pMerger, piRow, piSchema);




×







5075



    TSDB_CHECK_CODE(code, lino, _end);





×







5076












5077



    code = doMergeRowsInBuf(&pBlockScanInfo->iiter, pBlockScanInfo->uid, piRowKey, pBlockScanInfo->delSkyline, pReader);




×







5078



    TSDB_CHECK_CODE(code, lino, _end);





×







5079



  }










5080













UNCOV

5081



  tRowKeyAssign(&pBlockScanInfo->lastProcKey, pRowKey);




×







5082













UNCOV

5083



  code = tsdbRowMergerGetRow(pMerger, pTSRow);




×








UNCOV

5084



  tsdbRowMergerClear(pMerger);




×








UNCOV

5085



  TSDB_CHECK_CODE(code, lino, _end);





×







5086













UNCOV

5087



_end:




×








UNCOV

5088



  if (code != TSDB_CODE_SUCCESS) {





×







5089



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5090



  }











UNCOV

5091



  return code;




×







5092



}










5093













UNCOV

5094



static int32_t tsdbGetNextRowInMem(STableBlockScanInfo* pBlockScanInfo, STsdbReader* pReader, TSDBROW* pResRow,




×







5095



                                   int64_t endKey, bool* freeTSRow) {











UNCOV

5096



  int32_t    code = TSDB_CODE_SUCCESS;




×








UNCOV

5097



  int32_t    lino = 0;




×








UNCOV

5098



  TSDBROW*   pRow = NULL;




×








UNCOV

5099



  TSDBROW*   piRow = NULL;




×








UNCOV

5100



  SArray*    pDelList = NULL;




×








UNCOV

5101



  uint64_t   uid = 0;




×








UNCOV

5102



  SIterInfo* piter = NULL;




×








UNCOV

5103



  SIterInfo* piiter = NULL;




×








UNCOV

5104



  SRowKey    rowKey = {0};




×








UNCOV

5105



  SRowKey    irowKey = {0};




×








UNCOV

5106



  bool       asc = false;




×







5107













UNCOV

5108



  TSDB_CHECK_NULL(pBlockScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5109



  TSDB_CHECK_NULL(pResRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5110



  TSDB_CHECK_NULL(freeTSRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5111













UNCOV

5112



  code = getValidMemRow(&pBlockScanInfo->iter, pBlockScanInfo->delSkyline, pReader, &pRow);





×








UNCOV

5113



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5114



  code = getValidMemRow(&pBlockScanInfo->iiter, pBlockScanInfo->delSkyline, pReader, &piRow);





×








UNCOV

5115



  TSDB_CHECK_CODE(code, lino, _end);





×







5116













UNCOV

5117



  pDelList = pBlockScanInfo->delSkyline;




×








UNCOV

5118



  uid = pBlockScanInfo->uid;




×








UNCOV

5119



  piter = &pBlockScanInfo->iter;




×








UNCOV

5120



  piiter = &pBlockScanInfo->iiter;




×







5121












5122



  // todo refactor











UNCOV

5123



  asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

5124



  if (piter->hasVal) {





×








UNCOV

5125



    tRowGetKeyEx(pRow, &rowKey);





×








UNCOV

5126



    if ((rowKey.ts >= endKey && asc) || (rowKey.ts <= endKey && !asc)) {





×








UNCOV

5127



      pRow = NULL;




×







5128



    }










5129



  }










5130













UNCOV

5131



  if (piiter->hasVal) {





×








UNCOV

5132



    tRowGetKeyEx(piRow, &irowKey);





×








UNCOV

5133



    if ((irowKey.ts >= endKey && asc) || (irowKey.ts <= endKey && !asc)) {





×







5134



      piRow = NULL;




×







5135



    }










5136



  }










5137













UNCOV

5138



  if (pRow != NULL && piRow != NULL) {





×








UNCOV

5139



    if (rowKey.numOfPKs == 0) {





×








UNCOV

5140



      if ((rowKey.ts > irowKey.ts && asc) || (rowKey.ts < irowKey.ts && (!asc))) {  // ik.ts < k.ts





×








UNCOV

5141



        code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5142



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5143



      } else if ((rowKey.ts < irowKey.ts && asc) || (rowKey.ts > irowKey.ts && (!asc))) {





×








UNCOV

5144



        code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5145



        TSDB_CHECK_CODE(code, lino, _end);





×







5146



      } else {  // ik.ts == k.ts











UNCOV

5147



        pResRow->type = TSDBROW_ROW_FMT;




×








UNCOV

5148



        code = doMergeMemIMemRows(pRow, &rowKey, piRow, &irowKey, pBlockScanInfo, pReader, &pResRow->pTSRow);




×








UNCOV

5149



        TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5150



        *freeTSRow = true;




×







5151



      }










5152



    } else {











UNCOV

5153



      int32_t ret = pkCompEx(&rowKey, &irowKey);




×








UNCOV

5154



      if (ret != 0) {





×








UNCOV

5155



        if ((ret > 0 && asc) || (ret < 0 && (!asc))) {  // ik.ts < k.ts





×








UNCOV

5156



          code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5157



          TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5158



        } else if ((ret < 0 && asc) || (ret > 0 && (!asc))) {





×








UNCOV

5159



          code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5160



          TSDB_CHECK_CODE(code, lino, _end);





×







5161



        }










5162



      } else {  // ik.ts == k.ts










5163



        pResRow->type = TSDBROW_ROW_FMT;




×







5164



        code = doMergeMemIMemRows(pRow, &rowKey, piRow, &irowKey, pBlockScanInfo, pReader, &pResRow->pTSRow);




×







5165



        TSDB_CHECK_CODE(code, lino, _end);





×







5166



        *freeTSRow = true;




×







5167



      }










5168



    }











UNCOV

5169



  } else if (piter->hasVal && pRow != NULL) {





×








UNCOV

5170



    code = doMergeMemTableMultiRows(pRow, &rowKey, uid, piter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5171



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5172



  } else if (piiter->hasVal && piRow != NULL) {





×








UNCOV

5173



    code = doMergeMemTableMultiRows(piRow, &irowKey, uid, piiter, pDelList, pResRow, pReader, freeTSRow);




×








UNCOV

5174



    TSDB_CHECK_CODE(code, lino, _end);





×







5175



  }










5176













UNCOV

5177



_end:




×








UNCOV

5178



  if (code != TSDB_CODE_SUCCESS) {





×







5179



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5180



  }











UNCOV

5181



  return code;




×







5182



}










5183













UNCOV

5184



int32_t doAppendRowFromTSRow(SSDataBlock* pBlock, STsdbReader* pReader, SRow* pTSRow, STableBlockScanInfo* pScanInfo) {




×








UNCOV

5185



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

5186



  int32_t             lino = 0;




×








UNCOV

5187



  int32_t             outputRowIndex = 0;




×








UNCOV

5188



  int64_t             uid = 0;




×








UNCOV

5189



  SBlockLoadSuppInfo* pSupInfo = NULL;




×








UNCOV

5190



  STSchema*           pSchema = NULL;




×








UNCOV

5191



  SColVal             colVal = {0};




×








UNCOV

5192



  int32_t             i = 0, j = 0;




×







5193













UNCOV

5194



  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5195



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5196



  TSDB_CHECK_NULL(pTSRow, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5197



  TSDB_CHECK_NULL(pScanInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5198













UNCOV

5199



  outputRowIndex = pBlock->info.rows;




×








UNCOV

5200



  uid = pScanInfo->uid;




×







5201













UNCOV

5202



  pSupInfo = &pReader->suppInfo;




×








UNCOV

5203



  pSchema = doGetSchemaForTSRow(pTSRow->sver, pReader, uid);





×








UNCOV

5204



  TSDB_CHECK_NULL(pSchema, code, lino, _end, terrno);





×







5205













UNCOV

5206



  if (pSupInfo->colId[i] == PRIMARYKEY_TIMESTAMP_COL_ID) {





×








UNCOV

5207



    SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5208



    TSDB_CHECK_NULL(pColData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5209













UNCOV

5210



    ((int64_t*)pColData->pData)[outputRowIndex] = pTSRow->ts;




×








UNCOV

5211



    i += 1;




×







5212



  }










5213













UNCOV

5214



  while (i < pSupInfo->numOfCols && j < pSchema->numOfCols) {





×








UNCOV

5215



    col_id_t colId = pSupInfo->colId[i];




×







5216













UNCOV

5217



    if (colId == pSchema->columns[j].colId) {





×








UNCOV

5218



      SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5219



      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5220













UNCOV

5221



      code = tRowGet(pTSRow, pSchema, j, &colVal);




×








UNCOV

5222



      TSDB_CHECK_CODE(code, lino, _end);





×







5223













UNCOV

5224



      code = doCopyColVal(pColInfoData, outputRowIndex, i, &colVal, pSupInfo);




×








UNCOV

5225



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5226



      i += 1;




×








UNCOV

5227



      j += 1;




×








UNCOV

5228



    } else if (colId < pSchema->columns[j].colId) {





×







5229



      SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);




×







5230



      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5231












5232



      colDataSetNULL(pColInfoData, outputRowIndex);





×







5233



      i += 1;




×








UNCOV

5234



    } else if (colId > pSchema->columns[j].colId) {





×








UNCOV

5235



      j += 1;




×







5236



    }










5237



  }










5238












5239



  // set null value since current column does not exist in the "pSchema"











UNCOV

5240



  while (i < pSupInfo->numOfCols) {





×








UNCOV

5241



    SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5242



    TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5243













UNCOV

5244



    colDataSetNULL(pColInfoData, outputRowIndex);





×








UNCOV

5245



    i += 1;




×







5246



  }










5247













UNCOV

5248



  pBlock->info.dataLoad = 1;




×








UNCOV

5249



  pBlock->info.rows += 1;




×







5250













UNCOV

5251



_end:




×








UNCOV

5252



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

5253



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5254



  }











UNCOV

5255



  return code;




×







5256



}










5257













UNCOV

5258



int32_t doAppendRowFromFileBlock(SSDataBlock* pResBlock, STsdbReader* pReader, SBlockData* pBlockData,




×







5259



                                 int32_t rowIndex) {











UNCOV

5260



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

5261



  int32_t             lino = 0;




×








UNCOV

5262



  int32_t             i = 0, j = 0;




×








UNCOV

5263



  int32_t             outputRowIndex = 0;




×








UNCOV

5264



  SBlockLoadSuppInfo* pSupInfo = NULL;




×








UNCOV

5265



  SColVal             cv = {0};




×








UNCOV

5266



  int32_t             numOfInputCols = 0;




×








UNCOV

5267



  int32_t             numOfOutputCols = 0;




×







5268













UNCOV

5269



  TSDB_CHECK_NULL(pResBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5270



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

5271



  TSDB_CHECK_NULL(pBlockData, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5272













UNCOV

5273



  outputRowIndex = pResBlock->info.rows;




×







5274













UNCOV

5275



  pSupInfo = &pReader->suppInfo;




×








UNCOV

5276



  ((int64_t*)pReader->status.pPrimaryTsCol->pData)[outputRowIndex] = pBlockData->aTSKEY[rowIndex];




×








UNCOV

5277



  i += 1;




×







5278













UNCOV

5279



  numOfInputCols = pBlockData->nColData;




×








UNCOV

5280



  numOfOutputCols = pSupInfo->numOfCols;




×







5281













UNCOV

5282



  while (i < numOfOutputCols && j < numOfInputCols) {





×








UNCOV

5283



    SColData* pData = tBlockDataGetColDataByIdx(pBlockData, j);




×








UNCOV

5284



    if (pData->cid < pSupInfo->colId[i]) {





×








UNCOV

5285



      j += 1;




×








UNCOV

5286



      continue;




×







5287



    }










5288













UNCOV

5289



    SColumnInfoData* pCol = TARRAY_GET_ELEM(pResBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5290



    if (pData->cid == pSupInfo->colId[i]) {





×








UNCOV

5291



      code = tColDataGetValue(pData, rowIndex, &cv);




×








UNCOV

5292



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5293



      code = doCopyColVal(pCol, outputRowIndex, i, &cv, pSupInfo);




×








UNCOV

5294



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5295



      j += 1;




×







5296



    } else if (pData->cid > pCol->info.colId) {





×







5297



      // the specified column does not exist in file block, fill with null data










5298



      colDataSetNULL(pCol, outputRowIndex);





×







5299



    }










5300













UNCOV

5301



    i += 1;




×







5302



  }










5303













UNCOV

5304



  while (i < numOfOutputCols) {





×








UNCOV

5305



    SColumnInfoData* pCol = taosArrayGet(pResBlock->pDataBlock, pSupInfo->slotId[i]);




×








UNCOV

5306



    TSDB_CHECK_NULL(pCol, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5307













UNCOV

5308



    colDataSetNULL(pCol, outputRowIndex);





×








UNCOV

5309



    i += 1;




×







5310



  }










5311













UNCOV

5312



  pResBlock->info.dataLoad = 1;




×








UNCOV

5313



  pResBlock->info.rows += 1;




×







5314













UNCOV

5315



_end:




×








UNCOV

5316



  if (code != TSDB_CODE_SUCCESS) {





×







5317



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5318



  }











UNCOV

5319



  return code;




×







5320



}










5321













UNCOV

5322



int32_t buildDataBlockFromBufImpl(STableBlockScanInfo* pBlockScanInfo, int64_t endKey, int32_t capacity,




×







5323



                                  STsdbReader* pReader) {











UNCOV

5324



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

5325



  int32_t      lino = 0;




×








UNCOV

5326



  SSDataBlock* pBlock = NULL;




×







5327













UNCOV

5328



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5329













UNCOV

5330



  pBlock = pReader->resBlockInfo.pResBlock;




×







5331













UNCOV

5332



  do {




×








UNCOV

5333



    TSDBROW row = {.type = -1};




×








UNCOV

5334



    bool    freeTSRow = false;




×








UNCOV

5335



    code = tsdbGetNextRowInMem(pBlockScanInfo, pReader, &row, endKey, &freeTSRow);




×








UNCOV

5336



    TSDB_CHECK_CODE(code, lino, _end);





×







5337













UNCOV

5338



    if (row.type == -1) {





×








UNCOV

5339



      break;




×







5340



    }










5341













UNCOV

5342



    if (row.type == TSDBROW_ROW_FMT) {





×








UNCOV

5343



      code = doAppendRowFromTSRow(pBlock, pReader, row.pTSRow, pBlockScanInfo);




×








UNCOV

5344



      if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

5345



        if (freeTSRow) {





×







5346



          taosMemoryFreeClear(row.pTSRow);





×







5347



        }











UNCOV

5348



        TSDB_CHECK_CODE(code, lino, _end);





×







5349



      }











UNCOV

5350



      pBlockScanInfo->lastProcKey.ts = row.pTSRow->ts;




×








UNCOV

5351



      pBlockScanInfo->lastProcKey.numOfPKs = row.pTSRow->numOfPKs;




×








UNCOV

5352



      if (row.pTSRow->numOfPKs > 0) {





×








UNCOV

5353



        code = tRowGetPrimaryKeyDeepCopy(row.pTSRow, &pBlockScanInfo->lastProcKey);




×








UNCOV

5354



        if (code != TSDB_CODE_SUCCESS) {





×







5355



          if (freeTSRow) {





×







5356



            taosMemoryFreeClear(row.pTSRow);





×







5357



          }










5358



          TSDB_CHECK_CODE(code, lino, _end);





×







5359



        }










5360



      }










5361













UNCOV

5362



      if (freeTSRow) {





×








UNCOV

5363



        taosMemoryFreeClear(row.pTSRow);





×







5364



      }










5365



    } else {











UNCOV

5366



      code = doAppendRowFromFileBlock(pBlock, pReader, row.pBlockData, row.iRow);




×








UNCOV

5367



      TSDB_CHECK_CODE(code, lino, _end);





×







5368













UNCOV

5369



      tColRowGetKeyDeepCopy(row.pBlockData, row.iRow, pReader->suppInfo.pkSrcSlot, &pBlockScanInfo->lastProcKey);





×







5370



    }










5371












5372



    // no data in buffer, return immediately











UNCOV

5373



    if (!(pBlockScanInfo->iter.hasVal || pBlockScanInfo->iiter.hasVal)) {





×








UNCOV

5374



      break;




×







5375



    }










5376













UNCOV

5377



    if (pBlock->info.rows >= capacity) {





×








UNCOV

5378



      break;




×







5379



    }










5380



  } while (1);










5381













UNCOV

5382



_end:




×








UNCOV

5383



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

5384



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5385



  }











UNCOV

5386



  return code;




×







5387



}










5388












5389



// TODO refactor: with createDataBlockScanInfo











UNCOV

5390



int32_t tsdbSetTableList2(STsdbReader* pReader, const void* pTableList, int32_t num) {




×








UNCOV

5391



  int32_t               code = TSDB_CODE_SUCCESS;




×








UNCOV

5392



  int32_t               lino = 0;




×








UNCOV

5393



  int32_t               size = 0;




×








UNCOV

5394



  STableBlockScanInfo** p = NULL;




×








UNCOV

5395



  STableUidList*        pUidList = NULL;




×








UNCOV

5396



  int32_t               iter = 0;




×








UNCOV

5397



  bool                  acquired = false;




×







5398













UNCOV

5399



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5400













UNCOV

5401



  size = tSimpleHashGetSize(pReader->status.pTableMap);




×







5402













UNCOV

5403



  code = tsdbAcquireReader(pReader);




×








UNCOV

5404



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5405



  acquired = true;




×







5406













UNCOV

5407



  while ((p = tSimpleHashIterate(pReader->status.pTableMap, p, &iter)) != NULL) {





×








UNCOV

5408



    clearBlockScanInfo(*p);




×







5409



  }










5410













UNCOV

5411



  tSimpleHashClear(pReader->status.pTableMap);




×







5412













UNCOV

5413



  if (size < num) {





×








UNCOV

5414



    code = ensureBlockScanInfoBuf(&pReader->blockInfoBuf, num);




×








UNCOV

5415



    TSDB_CHECK_CODE(code, lino, _end);





×







5416













UNCOV

5417



    char* p1 = taosMemoryRealloc(pReader->status.uidList.tableUidList, sizeof(uint64_t) * num);





×








UNCOV

5418



    TSDB_CHECK_NULL(p1, code, lino, _end, terrno);





×







5419













UNCOV

5420



    pReader->status.uidList.tableUidList = (uint64_t*)p1;




×







5421



  }










5422













UNCOV

5423



  pUidList = &pReader->status.uidList;




×








UNCOV

5424



  pUidList->currentIndex = 0;




×







5425













UNCOV

5426



  STableKeyInfo* pList = (STableKeyInfo*)pTableList;




×








UNCOV

5427



  for (int32_t i = 0; i < num; ++i) {





×








UNCOV

5428



    pUidList->tableUidList[i] = pList[i].uid;




×







5429













UNCOV

5430



    STableBlockScanInfo* pInfo = NULL;




×








UNCOV

5431



    code = getPosInBlockInfoBuf(&pReader->blockInfoBuf, i, &pInfo);




×








UNCOV

5432



    TSDB_CHECK_CODE(code, lino, _end);





×







5433













UNCOV

5434



    code = initTableBlockScanInfo(pInfo, pList[i].uid, pReader->status.pTableMap, pReader);




×








UNCOV

5435



    TSDB_CHECK_CODE(code, lino, _end);





×







5436



  }










5437













UNCOV

5438



_end:




×








UNCOV

5439



  if (code != TSDB_CODE_SUCCESS) {





×







5440



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5441



  }











UNCOV

5442



  if (acquired) {





×








UNCOV

5443



    (void)tsdbReleaseReader(pReader);




×







5444



  }











UNCOV

5445



  return code;




×







5446



}










5447












5448



uint64_t tsdbGetReaderMaxVersion2(STsdbReader* pReader) { return pReader->info.verRange.maxVer; }




×







5449













UNCOV

5450



static int32_t doOpenReaderImpl(STsdbReader* pReader) {




×








UNCOV

5451



  int32_t         code = TSDB_CODE_SUCCESS;




×








UNCOV

5452



  int32_t         lino = 0;




×








UNCOV

5453



  SReaderStatus*  pStatus = NULL;




×








UNCOV

5454



  SDataBlockIter* pBlockIter = NULL;




×







5455













UNCOV

5456



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5457













UNCOV

5458



  pStatus = &pReader->status;




×








UNCOV

5459



  pBlockIter = &pStatus->blockIter;




×







5460













UNCOV

5461



  if (pReader->bFilesetDelimited) {





×








UNCOV

5462



    getMemTableTimeRange(pReader, &pReader->status.memTableMaxKey, &pReader->status.memTableMinKey);




×








UNCOV

5463



    pReader->status.bProcMemFirstFileset = true;




×







5464



  }










5465













UNCOV

5466



  code = initFilesetIterator(&pStatus->fileIter, pReader->pReadSnap->pfSetArray, pReader);




×








UNCOV

5467



  TSDB_CHECK_CODE(code, lino, _end);





×







5468













UNCOV

5469



  code = resetDataBlockIterator(&pStatus->blockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo),




×








UNCOV

5470



                                pReader->idStr);




×








UNCOV

5471



  TSDB_CHECK_CODE(code, lino, _end);





×







5472













UNCOV

5473



  if (pStatus->fileIter.numOfFiles == 0) {





×








UNCOV

5474



    pStatus->loadFromFile = false;




×







5475



  } else {











UNCOV

5476



    code = initForFirstBlockInFile(pReader, pBlockIter);




×







5477



  }










5478













UNCOV

5479



  if (!pStatus->loadFromFile) {





×








UNCOV

5480



    code = resetTableListIndex(pStatus, pReader->idStr);




×








UNCOV

5481



    TSDB_CHECK_CODE(code, lino, _end);





×







5482



  }










5483













UNCOV

5484



_end:




×








UNCOV

5485



  if (code != TSDB_CODE_SUCCESS) {





×







5486



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5487



  }











UNCOV

5488



  return code;




×







5489



}










5490













UNCOV

5491



static void freeSchemaFunc(void* param) {




×








UNCOV

5492



  void** p = (void**)param;




×








UNCOV

5493



  taosMemoryFreeClear(*p);





×








UNCOV

5494



}




×







5495













UNCOV

5496



static void clearSharedPtr(STsdbReader* p) {




×








UNCOV

5497



  if (p) {





×








UNCOV

5498



    p->status.pTableMap = NULL;




×








UNCOV

5499



    p->status.uidList.tableUidList = NULL;




×








UNCOV

5500



    p->info.pSchema = NULL;




×








UNCOV

5501



    p->pReadSnap = NULL;




×








UNCOV

5502



    p->pSchemaMap = NULL;




×







5503



  }











UNCOV

5504



}




×







5505













UNCOV

5506



static int32_t setSharedPtr(STsdbReader* pDst, const STsdbReader* pSrc) {




×








UNCOV

5507



  pDst->status.pTableMap = pSrc->status.pTableMap;




×








UNCOV

5508



  pDst->status.uidList = pSrc->status.uidList;




×








UNCOV

5509



  pDst->info.pSchema = pSrc->info.pSchema;




×








UNCOV

5510



  pDst->pSchemaMap = pSrc->pSchemaMap;




×








UNCOV

5511



  pDst->pReadSnap = pSrc->pReadSnap;




×








UNCOV

5512



  pDst->pReadSnap->pfSetArray = pSrc->pReadSnap->pfSetArray;




×







5513













UNCOV

5514



  if (pDst->info.pSchema) {





×








UNCOV

5515



    return tsdbRowMergerInit(&pDst->status.merger, pDst->info.pSchema);




×







5516



  }










5517












5518



  return TSDB_CODE_SUCCESS;




×







5519



}










5520












5521



// ====================================== EXPOSED APIs ======================================











UNCOV

5522



int32_t tsdbReaderOpen2(void* pVnode, SQueryTableDataCond* pCond, void* pTableList, int32_t numOfTables,




×







5523



                        SSDataBlock* pResBlock, void** ppReader, const char* idstr, SHashObj** pIgnoreTables) {











UNCOV

5524



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

5525



  int32_t      lino = 0;




×








UNCOV

5526



  STimeWindow  window = {0};




×








UNCOV

5527



  SVnodeCfg*   pConf = NULL;




×








UNCOV

5528



  STsdbReader* pReader = NULL;




×








UNCOV

5529



  int32_t      capacity = 0;




×







5530













UNCOV

5531



  window = pCond->twindows;




×








UNCOV

5532



  pConf = &(((SVnode*)pVnode)->config);




×







5533













UNCOV

5534



  capacity = pConf->tsdbCfg.maxRows;




×








UNCOV

5535



  if (pResBlock != NULL) {





×








UNCOV

5536



    code = blockDataEnsureCapacity(pResBlock, capacity);




×








UNCOV

5537



    TSDB_CHECK_CODE(code, lino, _end);





×







5538



  }










5539













UNCOV

5540



  code = tsdbReaderCreate(pVnode, pCond, ppReader, capacity, pResBlock, idstr);




×








UNCOV

5541



  TSDB_CHECK_CODE(code, lino, _end);





×







5542












5543



  // check for query time window











UNCOV

5544



  pReader = *ppReader;




×








UNCOV

5545



  if (isEmptyQueryTimeWindow(&pReader->info.window) && pCond->type == TIMEWINDOW_RANGE_CONTAINED) {





×








UNCOV

5546



    tsdbDebug("%p query window not overlaps with the data set, no result returned, %s", pReader, pReader->idStr);





×








UNCOV

5547



    goto _end;




×







5548



  }










5549













UNCOV

5550



  if (pCond->type == TIMEWINDOW_RANGE_EXTERNAL) {





×







5551



    // update the SQueryTableDataCond to create inner reader











UNCOV

5552



    int32_t order = pCond->order;




×








UNCOV

5553



    if (order == TSDB_ORDER_ASC) {





×








UNCOV

5554



      pCond->twindows = pCond->extTwindows[0];




×








UNCOV

5555



      pCond->order = TSDB_ORDER_DESC;




×







5556



    } else {










5557



      pCond->twindows = pCond->extTwindows[1];




×







5558



      pCond->order = TSDB_ORDER_ASC;




×







5559



    }










5560












5561



    // here we only need one more row, so the capacity is set to be ONE.











UNCOV

5562



    code = tsdbReaderCreate(pVnode, pCond, (void**)&((STsdbReader*)pReader)->innerReader[0], 1, pResBlock, idstr);




×








UNCOV

5563



    TSDB_CHECK_CODE(code, lino, _end);





×







5564













UNCOV

5565



    if (order == TSDB_ORDER_ASC) {





×








UNCOV

5566



      pCond->twindows = pCond->extTwindows[1];




×







5567



    } else {










5568



      pCond->twindows = pCond->extTwindows[0];




×







5569



    }











UNCOV

5570



    pCond->order = order;




×







5571













UNCOV

5572



    code = tsdbReaderCreate(pVnode, pCond, (void**)&((STsdbReader*)pReader)->innerReader[1], 1, pResBlock, idstr);




×








UNCOV

5573



    TSDB_CHECK_CODE(code, lino, _end);





×







5574



  }










5575












5576



  // NOTE: the endVersion in pCond is the data version not schema version, so pCond->endVersion is not correct here.










5577



  //  no valid error code set in metaGetTbTSchema, so let's set the error code here.










5578



  //  we should proceed in case of tmq processing.











UNCOV

5579



  if (pCond->suid != 0) {





×








UNCOV

5580



    code = metaGetTbTSchemaMaybeNull(pReader->pTsdb->pVnode->pMeta, pReader->info.suid, -1, 1, &pReader->info.pSchema);




×








UNCOV

5581



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5582



    if (pReader->info.pSchema == NULL) {





×








UNCOV

5583



      tsdbWarn("failed to get table schema, suid:%" PRIu64 ", ver:-1, %s", pReader->info.suid, pReader->idStr);





×







5584



    }











UNCOV

5585



  } else if (numOfTables > 0) {





×








UNCOV

5586



    STableKeyInfo* pKey = pTableList;




×








UNCOV

5587



    code = metaGetTbTSchemaMaybeNull(pReader->pTsdb->pVnode->pMeta, pKey->uid, -1, 1, &pReader->info.pSchema);




×








UNCOV

5588



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5589



    if (pReader->info.pSchema == NULL) {





×







5590



      tsdbWarn("failed to get table schema, uid:%" PRIu64 ", ver:-1, %s", pKey->uid, pReader->idStr);





×







5591



    }










5592



  }










5593













UNCOV

5594



  if (pReader->info.pSchema != NULL) {





×








UNCOV

5595



    code = tsdbRowMergerInit(&pReader->status.merger, pReader->info.pSchema);




×








UNCOV

5596



    TSDB_CHECK_CODE(code, lino, _end);





×







5597



  }










5598













UNCOV

5599



  pReader->pSchemaMap = tSimpleHashInit(8, taosFastHash);




×








UNCOV

5600



  if (pReader->pSchemaMap == NULL) {





×







5601



    tsdbError("failed init schema hash for reader %s", pReader->idStr);





×







5602



    TSDB_CHECK_NULL(pReader->pSchemaMap, code, lino, _end, terrno);





×







5603



  }










5604













UNCOV

5605



  tSimpleHashSetFreeFp(pReader->pSchemaMap, freeSchemaFunc);




×








UNCOV

5606



  if (pReader->info.pSchema != NULL) {





×








UNCOV

5607



    code = updateBlockSMAInfo(pReader->info.pSchema, &pReader->suppInfo);




×








UNCOV

5608



    TSDB_CHECK_CODE(code, lino, _end);





×







5609



  }










5610













UNCOV

5611



  STsdbReader* p = (pReader->innerReader[0] != NULL) ? pReader->innerReader[0] : pReader;





×







5612













UNCOV

5613



  code = createDataBlockScanInfo(p, &pReader->blockInfoBuf, pTableList, &pReader->status.uidList, numOfTables,




×







5614



                                 &pReader->status.pTableMap);











UNCOV

5615



  TSDB_CHECK_CODE(code, lino, _end);





×







5616













UNCOV

5617



  pReader->status.pLDataIterArray = taosArrayInit(4, POINTER_BYTES);




×








UNCOV

5618



  TSDB_CHECK_NULL(pReader->status.pLDataIterArray, code, lino, _end, terrno);





×







5619













UNCOV

5620



  pReader->flag = READER_STATUS_SUSPEND;




×








UNCOV

5621



  pReader->info.execMode = pCond->notLoadData ? READER_EXEC_ROWS : READER_EXEC_DATA;





×







5622













UNCOV

5623



  pReader->pIgnoreTables = pIgnoreTables;




×








UNCOV

5624



  tsdbDebug("%p total numOfTable:%d, window:%" PRId64 " - %" PRId64 ", verRange:%" PRId64 " - %" PRId64





×







5625



            " in this query %s",










5626



            pReader, numOfTables, pReader->info.window.skey, pReader->info.window.ekey, pReader->info.verRange.minVer,










5627



            pReader->info.verRange.maxVer, pReader->idStr);










5628













UNCOV

5629



_end:




×








UNCOV

5630



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

5631



    tsdbError("%s failed at line %d since %s, %s", __func__, lino, tstrerror(code), idstr);





×








UNCOV

5632



    tsdbReaderClose2(*ppReader);




×








UNCOV

5633



    *ppReader = NULL;  // reset the pointer value.




×







5634



  }











UNCOV

5635



  return code;




×







5636



}










5637













UNCOV

5638



void tsdbReaderClose2(STsdbReader* pReader) {




×








UNCOV

5639



  if (pReader == NULL) {





×








UNCOV

5640



    return;




×







5641



  }










5642













UNCOV

5643



  int32_t code = tsdbAcquireReader(pReader);




×








UNCOV

5644



  if (code) {





×







5645



    return;




×







5646



  }










5647












5648



  {











UNCOV

5649



    if (pReader->innerReader[0] != NULL || pReader->innerReader[1] != NULL) {





×








UNCOV

5650



      STsdbReader* p = pReader->innerReader[0];




×








UNCOV

5651



      clearSharedPtr(p);




×







5652













UNCOV

5653



      p = pReader->innerReader[1];




×








UNCOV

5654



      clearSharedPtr(p);




×







5655













UNCOV

5656



      tsdbReaderClose2(pReader->innerReader[0]);




×








UNCOV

5657



      tsdbReaderClose2(pReader->innerReader[1]);




×







5658



    }










5659



  }










5660













UNCOV

5661



  SBlockLoadSuppInfo* pSupInfo = &pReader->suppInfo;




×








UNCOV

5662



  TARRAY2_DESTROY(&pSupInfo->colAggArray, NULL);





×







5663













UNCOV

5664



  if (pSupInfo->buildBuf) {





×








UNCOV

5665



    for (int32_t i = 0; i < pSupInfo->numOfCols; ++i) {





×








UNCOV

5666



      if (pSupInfo->buildBuf[i] != NULL) {





×








UNCOV

5667



        taosMemoryFreeClear(pSupInfo->buildBuf[i]);





×







5668



      }










5669



    }










5670



  }










5671













UNCOV

5672



  if (pReader->resBlockInfo.freeBlock) {





×








UNCOV

5673



    blockDataDestroy(pReader->resBlockInfo.pResBlock);




×








UNCOV

5674



    pReader->resBlockInfo.pResBlock = NULL;




×







5675



  }










5676













UNCOV

5677



  taosMemoryFree(pSupInfo->colId);





×








UNCOV

5678



  tBlockDataDestroy(&pReader->status.fileBlockData);




×








UNCOV

5679



  cleanupDataBlockIterator(&pReader->status.blockIter, shouldFreePkBuf(&pReader->suppInfo));




×







5680













UNCOV

5681



  size_t numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);




×








UNCOV

5682



  if (pReader->status.pTableMap != NULL) {





×








UNCOV

5683



    destroyAllBlockScanInfo(&pReader->status.pTableMap);




×







5684



  }











UNCOV

5685



  clearBlockScanInfoBuf(&pReader->blockInfoBuf);




×







5686













UNCOV

5687



  if (pReader->pFileReader != NULL) {





×








UNCOV

5688



    tsdbDataFileReaderClose(&pReader->pFileReader);




×







5689



  }










5690













UNCOV

5691



  SReadCostSummary* pCost = &pReader->cost;




×








UNCOV

5692



  SFilesetIter*     pFilesetIter = &pReader->status.fileIter;




×








UNCOV

5693



  if (pFilesetIter->pSttBlockReader != NULL) {





×








UNCOV

5694



    SSttBlockReader* pSttBlockReader = pFilesetIter->pSttBlockReader;




×








UNCOV

5695



    tMergeTreeClose(&pSttBlockReader->mergeTree);




×







5696













UNCOV

5697



    clearRowKey(&pSttBlockReader->currentKey);




×








UNCOV

5698



    taosMemoryFree(pSttBlockReader);





×







5699



  }










5700













UNCOV

5701



  destroySttBlockReader(pReader->status.pLDataIterArray, &pCost->sttCost);




×








UNCOV

5702



  pReader->status.pLDataIterArray = NULL;




×








UNCOV

5703



  taosMemoryFreeClear(pReader->status.uidList.tableUidList);





×







5704













UNCOV

5705



  tsdbTrace("tsdb/reader-close: %p, untake snapshot", pReader);





×








UNCOV

5706



  void* p = pReader->pReadSnap;




×








UNCOV

5707



  if ((p == atomic_val_compare_exchange_ptr((void**)&pReader->pReadSnap, p, NULL)) && (p != NULL)) {





×








UNCOV

5708



    tsdbUntakeReadSnap2(pReader, p, true);




×








UNCOV

5709



    pReader->pReadSnap = NULL;




×







5710



  }










5711













UNCOV

5712



  (void) tsem_destroy(&pReader->resumeAfterSuspend);




×








UNCOV

5713



  (void) tsdbReleaseReader(pReader);




×








UNCOV

5714



  (void) tsdbUninitReaderLock(pReader);




×







5715













UNCOV

5716



  tsdbDebug(





×







5717



      "%p :io-cost summary: head-file:%" PRIu64 ", head-file time:%.2f ms, SMA:%" PRId64










5718



      " SMA-time:%.2f ms, fileBlocks:%" PRId64










5719



      ", fileBlocks-load-time:%.2f ms, "










5720



      "build in-memory-block-time:%.2f ms, sttBlocks:%" PRId64 ", sttBlocks-time:%.2f ms, sttStatisBlock:%" PRId64










5721



      ", stt-statis-Block-time:%.2f ms, composed-blocks:%" PRId64










5722



      ", composed-blocks-time:%.2fms, STableBlockScanInfo size:%.2f Kb, createTime:%.2f ms,createSkylineIterTime:%.2f "










5723



      "ms, initSttBlockReader:%.2fms, %s",










5724



      pReader, pCost->headFileLoad, pCost->headFileLoadTime, pCost->smaDataLoad, pCost->smaLoadTime, pCost->numOfBlocks,










5725



      pCost->blockLoadTime, pCost->buildmemBlock, pCost->sttCost.loadBlocks, pCost->sttCost.blockElapsedTime,










5726



      pCost->sttCost.loadStatisBlocks, pCost->sttCost.statisElapsedTime, pCost->composedBlocks,










5727



      pCost->buildComposedBlockTime, numOfTables * sizeof(STableBlockScanInfo) / 1000.0, pCost->createScanInfoList,










5728



      pCost->createSkylineIterTime, pCost->initSttBlockReader, pReader->idStr);










5729













UNCOV

5730



  taosMemoryFree(pReader->idStr);





×







5731













UNCOV

5732



  tsdbRowMergerCleanup(&pReader->status.merger);




×








UNCOV

5733



  taosMemoryFree(pReader->info.pSchema);





×







5734













UNCOV

5735



  tSimpleHashCleanup(pReader->pSchemaMap);




×








UNCOV

5736



  taosMemoryFreeClear(pReader);





×







5737



}










5738












5739



static int32_t doSuspendCurrentReader(STsdbReader* pCurrentReader) {




×







5740



  int32_t               code = TSDB_CODE_SUCCESS;




×







5741



  int32_t               lino = 0;




×







5742



  SReaderStatus*        pStatus = NULL;




×







5743



  STableBlockScanInfo** p = NULL;




×







5744












5745



  TSDB_CHECK_NULL(pCurrentReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5746












5747



  pStatus = &pCurrentReader->status;




×







5748












5749



  if (pStatus->loadFromFile) {





×







5750



    tsdbDataFileReaderClose(&pCurrentReader->pFileReader);




×







5751












5752



    SReadCostSummary* pCost = &pCurrentReader->cost;




×







5753



    destroySttBlockReader(pStatus->pLDataIterArray, &pCost->sttCost);




×







5754



    pStatus->pLDataIterArray = taosArrayInit(4, POINTER_BYTES);




×







5755



    TSDB_CHECK_NULL(pStatus->pLDataIterArray, code, lino, _end, terrno);





×







5756



  }










5757












5758



  // resetDataBlockScanInfo excluding lastKey










5759



  int32_t step = ASCENDING_TRAVERSE(pCurrentReader->info.order) ? 1 : -1;





×







5760



  int32_t iter = 0;




×







5761



  while ((p = tSimpleHashIterate(pStatus->pTableMap, p, &iter)) != NULL) {





×







5762



    STableBlockScanInfo* pInfo = *(STableBlockScanInfo**)p;




×







5763



    clearBlockScanInfo(pInfo);




×







5764



    //    pInfo->sttKeyInfo.nextProcKey = pInfo->lastProcKey.ts + step;










5765



    //    pInfo->sttKeyInfo.nextProcKey = pInfo->lastProcKey + step;










5766



  }










5767












5768



  pStatus->uidList.currentIndex = 0;




×







5769



  initReaderStatus(pStatus);




×







5770












5771



_end:




×







5772



  if (code != TSDB_CODE_SUCCESS) {





×







5773



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5774



  }










5775



  return code;




×







5776



}










5777












5778



int32_t tsdbReaderSuspend2(STsdbReader* pReader) {




×







5779



  int32_t code = TSDB_CODE_SUCCESS;




×







5780



  int32_t lino = 0;




×







5781












5782



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5783












5784



  // save reader's base state & reset top state to be reconstructed from base state










5785



  pReader->status.suspendInvoked = true;  // record the suspend status




×







5786












5787



  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {





×







5788



    if (pReader->step == EXTERNAL_ROWS_PREV) {





×







5789



      code = doSuspendCurrentReader(pReader->innerReader[0]);




×







5790



    } else if (pReader->step == EXTERNAL_ROWS_MAIN) {





×







5791



      code = doSuspendCurrentReader(pReader);




×







5792



    } else {










5793



      code = doSuspendCurrentReader(pReader->innerReader[1]);




×







5794



    }










5795



  } else {










5796



    code = doSuspendCurrentReader(pReader);




×







5797



  }










5798












5799



  // make sure only release once










5800



  void* p = pReader->pReadSnap;




×







5801



  if ((p == atomic_val_compare_exchange_ptr((void**)&pReader->pReadSnap, p, NULL)) && (p != NULL)) {





×







5802



    tsdbUntakeReadSnap2(pReader, p, false);




×







5803



    pReader->pReadSnap = NULL;




×







5804



  }










5805












5806



  if (pReader->bFilesetDelimited) {





×







5807



    pReader->status.memTableMinKey = INT64_MAX;




×







5808



    pReader->status.memTableMaxKey = INT64_MIN;




×







5809



  }










5810



  pReader->flag = READER_STATUS_SUSPEND;




×







5811












5812



  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {





×







5813



    clearSharedPtr(pReader->innerReader[0]);




×







5814



    clearSharedPtr(pReader->innerReader[1]);




×







5815



  }










5816












5817



#if SUSPEND_RESUME_TEST










5818



  tsem_post(&pReader->resumeAfterSuspend);










5819



#endif










5820












5821



  tsdbDebug("reader: %p suspended in this query %s, step:%d", pReader, pReader->idStr, pReader->step);





×







5822












5823



_end:




×







5824



  if (code != TSDB_CODE_SUCCESS) {





×







5825



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5826



  }










5827



  return code;




×







5828



}










5829












5830



static int32_t tsdbSetQueryReseek(void* pQHandle) {




×







5831



  int32_t      code = 0;




×







5832



  STsdbReader* pReader = pQHandle;




×







5833












5834



  code = tsdbTryAcquireReader(pReader);




×







5835



  if (code == 0) {





×







5836



    if (pReader->flag == READER_STATUS_SUSPEND) {





×







5837



      code = tsdbReleaseReader(pReader);




×







5838



      return code;




×







5839



    }










5840












5841



    code = tsdbReaderSuspend2(pReader);




×







5842



    (void)tsdbReleaseReader(pReader);




×







5843



    return code;




×







5844



  } else if (code == EBUSY) {





×







5845



    return TSDB_CODE_VND_QUERY_BUSY;




×







5846



  } else {










5847



    terrno = TAOS_SYSTEM_ERROR(code);




×







5848



    return TSDB_CODE_FAILED;




×







5849



  }










5850



}










5851













UNCOV

5852



int32_t tsdbReaderResume2(STsdbReader* pReader) {




×








UNCOV

5853



  int32_t               code = TSDB_CODE_SUCCESS;




×








UNCOV

5854



  int32_t               lino = 0;




×








UNCOV

5855



  STableBlockScanInfo** pBlockScanInfo = NULL;




×








UNCOV

5856



  int32_t               numOfTables = 0;




×







5857













UNCOV

5858



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5859













UNCOV

5860



  pBlockScanInfo = pReader->status.pTableIter;




×







5861












5862



  //  restore reader's state, task snapshot











UNCOV

5863



  numOfTables = tSimpleHashGetSize(pReader->status.pTableMap);




×








UNCOV

5864



  if (numOfTables > 0) {





×








UNCOV

5865



    tsdbTrace("tsdb/reader: %p, take snapshot", pReader);





×








UNCOV

5866



    code = tsdbTakeReadSnap2(pReader, tsdbSetQueryReseek, &pReader->pReadSnap, pReader->idStr);




×








UNCOV

5867



    TSDB_CHECK_CODE(code, lino, _end);





×







5868












5869



    // open reader failure may cause the flag still to be READER_STATUS_SUSPEND, which may cause suspend reader failure.










5870



    // So we need to set it A.S.A.P











UNCOV

5871



    pReader->flag = READER_STATUS_NORMAL;




×







5872













UNCOV

5873



    if (pReader->type == TIMEWINDOW_RANGE_CONTAINED) {





×








UNCOV

5874



      code = doOpenReaderImpl(pReader);




×








UNCOV

5875



      TSDB_CHECK_CODE(code, lino, _end);





×







5876



    } else {











UNCOV

5877



      STsdbReader* pPrevReader = pReader->innerReader[0];




×








UNCOV

5878



      STsdbReader* pNextReader = pReader->innerReader[1];




×







5879












5880



      // we need only one row











UNCOV

5881



      pPrevReader->resBlockInfo.capacity = 1;




×








UNCOV

5882



      code = setSharedPtr(pPrevReader, pReader);




×








UNCOV

5883



      TSDB_CHECK_CODE(code, lino, _end);





×







5884













UNCOV

5885



      pNextReader->resBlockInfo.capacity = 1;




×








UNCOV

5886



      code = setSharedPtr(pNextReader, pReader);




×








UNCOV

5887



      TSDB_CHECK_CODE(code, lino, _end);





×







5888













UNCOV

5889



      if (pReader->step == 0 || pReader->step == EXTERNAL_ROWS_PREV) {





×








UNCOV

5890



        code = doOpenReaderImpl(pPrevReader);




×








UNCOV

5891



        TSDB_CHECK_CODE(code, lino, _end);





×







5892



      } else if (pReader->step == EXTERNAL_ROWS_MAIN) {





×







5893



        code = doOpenReaderImpl(pReader);




×







5894



        TSDB_CHECK_CODE(code, lino, _end);





×







5895



      } else {










5896



        code = doOpenReaderImpl(pNextReader);




×







5897



        TSDB_CHECK_CODE(code, lino, _end);





×







5898



      }










5899



    }










5900



  }










5901













UNCOV

5902



  tsdbDebug("reader: %p resumed uid %" PRIu64 ", numOfTable:%" PRId32 ", in this query %s", pReader,





×







5903



            pBlockScanInfo ? (*pBlockScanInfo)->uid : 0, numOfTables, pReader->idStr);










5904













UNCOV

5905



_end:




×








UNCOV

5906



  if (code != TSDB_CODE_SUCCESS) {





×







5907



    tsdbError("%s failed at line %d since %s, %s", __func__, lino, tstrerror(code),





×







5908



              (pReader && pReader->idStr) ? pReader->idStr : "");










5909



  }











UNCOV

5910



  return code;




×







5911



}










5912













UNCOV

5913



static int32_t buildFromPreFilesetBuffer(STsdbReader* pReader) {




×








UNCOV

5914



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

5915



  int32_t        lino = 0;




×








UNCOV

5916



  SReaderStatus* pStatus = NULL;




×








UNCOV

5917



  SSDataBlock*   pBlock = NULL;




×








UNCOV

5918



  int32_t        fid = 0;




×








UNCOV

5919



  STimeWindow    win = {0};




×







5920













UNCOV

5921



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5922













UNCOV

5923



  pStatus = &pReader->status;




×








UNCOV

5924



  pBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

5925



  fid = pReader->status.pCurrentFileset->fid;




×








UNCOV

5926



  tsdbFidKeyRange(fid, pReader->pTsdb->keepCfg.days, pReader->pTsdb->keepCfg.precision, &win.skey, &win.ekey);




×







5927













UNCOV

5928



  int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? win.skey : win.ekey;





×








UNCOV

5929



  code = buildBlockFromBufferSeqForPreFileset(pReader, endKey);




×








UNCOV

5930



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5931



  if (pBlock->info.rows <= 0) {





×








UNCOV

5932



    tsdbDebug("finished pre-fileset %d buffer processing. %s", fid, pReader->idStr);





×








UNCOV

5933



    pStatus->bProcMemPreFileset = false;




×








UNCOV

5934



    pStatus->processingMemPreFileSet = false;




×








UNCOV

5935



    if (pReader->notifyFn) {





×








UNCOV

5936



      STsdReaderNotifyInfo info = {0};




×








UNCOV

5937



      info.duration.filesetId = fid;




×








UNCOV

5938



      pReader->notifyFn(TSD_READER_NOTIFY_DURATION_START, &info, pReader->notifyParam);




×








UNCOV

5939



      tsdbDebug("new duration %d start notification when buffer pre-fileset, %s", fid, pReader->idStr);





×







5940



    }










5941



  }










5942













UNCOV

5943



_end:




×








UNCOV

5944



  if (code != TSDB_CODE_SUCCESS) {





×







5945



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







5946



  }











UNCOV

5947



  return code;




×







5948



}










5949













UNCOV

5950



static int32_t doTsdbNextDataBlockFilesetDelimited(STsdbReader* pReader) {




×








UNCOV

5951



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

5952



  int32_t        lino = 0;




×








UNCOV

5953



  SReaderStatus* pStatus = NULL;




×








UNCOV

5954



  SSDataBlock*   pBlock = NULL;




×







5955













UNCOV

5956



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







5957













UNCOV

5958



  pStatus = &pReader->status;




×








UNCOV

5959



  pBlock = pReader->resBlockInfo.pResBlock;




×







5960













UNCOV

5961



  if (pStatus->loadFromFile) {





×








UNCOV

5962



    if (pStatus->bProcMemPreFileset) {





×








UNCOV

5963



      code = buildFromPreFilesetBuffer(pReader);




×








UNCOV

5964



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

5965



      if (pBlock->info.rows > 0) {





×








UNCOV

5966



        goto _end;




×







5967



      }










5968



    }










5969













UNCOV

5970



    code = buildBlockFromFiles(pReader);




×








UNCOV

5971



    TSDB_CHECK_CODE(code, lino, _end);





×







5972













UNCOV

5973



    tsdbTrace("block from file rows: %" PRId64 ", will process pre-file set buffer: %d. %s", pBlock->info.rows,





×







5974



              pStatus->bProcMemFirstFileset, pReader->idStr);











UNCOV

5975



    if (pStatus->bProcMemPreFileset) {





×








UNCOV

5976



      if (pBlock->info.rows > 0) {





×








UNCOV

5977



        if (pReader->notifyFn && !pReader->status.processingMemPreFileSet) {





×







5978



          int32_t              fid = pReader->status.pCurrentFileset->fid;




×







5979



          STsdReaderNotifyInfo info = {0};




×







5980



          info.duration.filesetId = fid;




×







5981



          pReader->notifyFn(TSD_READER_NOTIFY_NEXT_DURATION_BLOCK, &info, pReader->notifyParam);




×







5982



        }










5983



      } else {










5984



        pStatus->bProcMemPreFileset = false;




×







5985



      }










5986



    }










5987













UNCOV

5988



    if (pBlock->info.rows <= 0) {





×








UNCOV

5989



      code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

5990



      TSDB_CHECK_CODE(code, lino, _end);





×







5991













UNCOV

5992



      int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;





×








UNCOV

5993



      code = buildBlockFromBufferSequentially(pReader, endKey);




×








UNCOV

5994



      TSDB_CHECK_CODE(code, lino, _end);





×







5995



    }










5996



  } else {  // no data in files, let's try the buffer











UNCOV

5997



    int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;





×








UNCOV

5998



    code = buildBlockFromBufferSequentially(pReader, endKey);




×








UNCOV

5999



    TSDB_CHECK_CODE(code, lino, _end);





×







6000



  }










6001













UNCOV

6002



_end:




×








UNCOV

6003



  if (code != TSDB_CODE_SUCCESS) {





×







6004



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6005



  }











UNCOV

6006



  return code;




×







6007



}










6008













UNCOV

6009



static int32_t doTsdbNextDataBlockFilesFirst(STsdbReader* pReader) {




×








UNCOV

6010



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

6011



  int32_t        lino = 0;




×








UNCOV

6012



  SReaderStatus* pStatus = NULL;




×








UNCOV

6013



  SSDataBlock*   pBlock = NULL;




×







6014













UNCOV

6015



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6016













UNCOV

6017



  pStatus = &pReader->status;




×








UNCOV

6018



  pBlock = pReader->resBlockInfo.pResBlock;




×







6019













UNCOV

6020



  if (pStatus->loadFromFile) {





×








UNCOV

6021



    code = buildBlockFromFiles(pReader);




×








UNCOV

6022



    TSDB_CHECK_CODE(code, lino, _end);





×







6023













UNCOV

6024



    if (pBlock->info.rows <= 0) {





×








UNCOV

6025



      code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

6026



      TSDB_CHECK_CODE(code, lino, _end);





×







6027













UNCOV

6028



      int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;





×








UNCOV

6029



      code = buildBlockFromBufferSequentially(pReader, endKey);




×








UNCOV

6030



      TSDB_CHECK_CODE(code, lino, _end);





×







6031



    }










6032



  } else {  // no data in files, let's try the buffer











UNCOV

6033



    int64_t endKey = (ASCENDING_TRAVERSE(pReader->info.order)) ? INT64_MAX : INT64_MIN;





×








UNCOV

6034



    code = buildBlockFromBufferSequentially(pReader, endKey);




×








UNCOV

6035



    TSDB_CHECK_CODE(code, lino, _end);





×







6036



  }










6037













UNCOV

6038



_end:




×








UNCOV

6039



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

6040



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6041



  }











UNCOV

6042



  return code;




×







6043



}










6044













UNCOV

6045



static int32_t doTsdbNextDataBlock2(STsdbReader* pReader, bool* hasNext) {




×








UNCOV

6046



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

6047



  int32_t      lino = 0;




×








UNCOV

6048



  SSDataBlock* pBlock = NULL;




×







6049













UNCOV

6050



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6051












6052



  // cleanup the data that belongs to the previous data block











UNCOV

6053



  pBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

6054



  blockDataCleanup(pBlock);




×







6055













UNCOV

6056



  *hasNext = false;




×







6057













UNCOV

6058



  SReaderStatus* pStatus = &pReader->status;




×








UNCOV

6059



  if (tSimpleHashGetSize(pStatus->pTableMap) == 0) {





×








UNCOV

6060



    goto _end;




×







6061



  }










6062













UNCOV

6063



  if (!pReader->bFilesetDelimited) {





×








UNCOV

6064



    code = doTsdbNextDataBlockFilesFirst(pReader);




×







6065



  } else {











UNCOV

6066



    code = doTsdbNextDataBlockFilesetDelimited(pReader);




×







6067



  }










6068













UNCOV

6069



  *hasNext = pBlock->info.rows > 0;




×








UNCOV

6070



  TSDB_CHECK_CODE(code, lino, _end);





×







6071













UNCOV

6072



_end:




×








UNCOV

6073



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

6074



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6075



  }











UNCOV

6076



  return code;




×







6077



}










6078













UNCOV

6079



int32_t tsdbNextDataBlock2(STsdbReader* pReader, bool* hasNext) {




×








UNCOV

6080



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

6081



  int32_t        lino = 0;




×








UNCOV

6082



  SReaderStatus* pStatus = NULL;




×








UNCOV

6083



  bool           acquired = false;




×







6084













UNCOV

6085



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6086



  TSDB_CHECK_NULL(hasNext, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6087













UNCOV

6088



  *hasNext = false;




×







6089













UNCOV

6090



  code = pReader->code;




×








UNCOV

6091



  TSDB_CHECK_CODE(code, lino, _end);





×







6092













UNCOV

6093



  if (isEmptyQueryTimeWindow(&pReader->info.window) || pReader->step == EXTERNAL_ROWS_NEXT) {





×








UNCOV

6094



    goto _end;




×







6095



  }










6096













UNCOV

6097



  pStatus = &pReader->status;




×







6098












6099



  // NOTE: the following codes is used to perform test for suspend/resume for tsdbReader when it blocks the commit










6100



  // the data should be ingested in round-robin and all the child tables should be createted before ingesting data










6101



  // the version range of query will be used to identify the correctness of suspend/resume functions.










6102



  // this function will be blocked before loading the SECOND block from vnode-buffer, and restart itself from sst-files










6103



#if SUSPEND_RESUME_TEST










6104



  if (!pReader->status.suspendInvoked && !pReader->status.loadFromFile) {










6105



    tsem_wait(&pReader->resumeAfterSuspend);










6106



  }










6107



#endif










6108













UNCOV

6109



  code = tsdbAcquireReader(pReader);




×








UNCOV

6110



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6111



  acquired = true;




×







6112













UNCOV

6113



  tsdbTrace("tsdb/read: %p, take read mutex, code: %d", pReader, code);





×







6114













UNCOV

6115



  if (pReader->flag == READER_STATUS_SUSPEND) {





×








UNCOV

6116



    code = tsdbReaderResume2(pReader);




×








UNCOV

6117



    TSDB_CHECK_CODE(code, lino, _end);





×







6118



  }










6119













UNCOV

6120



  if (pReader->innerReader[0] != NULL && pReader->step == 0) {





×








UNCOV

6121



    code = doTsdbNextDataBlock2(pReader->innerReader[0], hasNext);




×








UNCOV

6122



    TSDB_CHECK_CODE(code, lino, _end);





×







6123













UNCOV

6124



    pReader->step = EXTERNAL_ROWS_PREV;




×








UNCOV

6125



    if (*hasNext) {





×








UNCOV

6126



      pStatus = &pReader->innerReader[0]->status;




×








UNCOV

6127



      if (pStatus->composedDataBlock) {





×








UNCOV

6128



        tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6129



        code = tsdbReleaseReader(pReader);




×








UNCOV

6130



        acquired = false;




×








UNCOV

6131



        TSDB_CHECK_CODE(code, lino, _end);





×







6132



      }










6133













UNCOV

6134



      return code;




×







6135



    }










6136



  }










6137













UNCOV

6138



  if (pReader->step == EXTERNAL_ROWS_PREV) {





×







6139



    // prepare for the main scan











UNCOV

6140



    if (tSimpleHashGetSize(pReader->status.pTableMap) > 0) {





×








UNCOV

6141



      code = doOpenReaderImpl(pReader);




×







6142



    }










6143













UNCOV

6144



    int32_t step = 1;




×








UNCOV

6145



    resetAllDataBlockScanInfo(pReader->status.pTableMap, pReader->innerReader[0]->info.window.ekey, step);




×








UNCOV

6146



    TSDB_CHECK_CODE(code, lino, _end);





×







6147













UNCOV

6148



    pReader->step = EXTERNAL_ROWS_MAIN;




×







6149



  }










6150













UNCOV

6151



  code = doTsdbNextDataBlock2(pReader, hasNext);




×








UNCOV

6152



  TSDB_CHECK_CODE(code, lino, _end);





×







6153













UNCOV

6154



  if (*hasNext) {





×








UNCOV

6155



    if (pStatus->composedDataBlock) {





×








UNCOV

6156



      tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6157



      code = tsdbReleaseReader(pReader);




×








UNCOV

6158



      acquired = false;




×








UNCOV

6159



      TSDB_CHECK_CODE(code, lino, _end);





×







6160



    }











UNCOV

6161



    return code;




×







6162



  }










6163













UNCOV

6164



  if (pReader->step == EXTERNAL_ROWS_MAIN && pReader->innerReader[1] != NULL) {





×







6165



    // prepare for the next row scan











UNCOV

6166



    if (tSimpleHashGetSize(pReader->status.pTableMap) > 0) {





×








UNCOV

6167



      code = doOpenReaderImpl(pReader->innerReader[1]);




×







6168



    }










6169













UNCOV

6170



    int32_t step = -1;




×








UNCOV

6171



    resetAllDataBlockScanInfo(pReader->innerReader[1]->status.pTableMap, pReader->info.window.ekey, step);




×








UNCOV

6172



    TSDB_CHECK_CODE(code, lino, _end);





×







6173













UNCOV

6174



    code = doTsdbNextDataBlock2(pReader->innerReader[1], hasNext);




×








UNCOV

6175



    TSDB_CHECK_CODE(code, lino, _end);





×







6176













UNCOV

6177



    pReader->step = EXTERNAL_ROWS_NEXT;




×








UNCOV

6178



    if (*hasNext) {





×








UNCOV

6179



      pStatus = &pReader->innerReader[1]->status;




×








UNCOV

6180



      if (pStatus->composedDataBlock) {





×








UNCOV

6181



        tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6182



        code = tsdbReleaseReader(pReader);




×








UNCOV

6183



        acquired = false;




×








UNCOV

6184



        TSDB_CHECK_CODE(code, lino, _end);





×







6185



      }










6186













UNCOV

6187



      return code;




×







6188



    }










6189



  }










6190













UNCOV

6191



  tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6192



  code = tsdbReleaseReader(pReader);




×








UNCOV

6193



  acquired = false;




×








UNCOV

6194



  TSDB_CHECK_CODE(code, lino, _end);





×







6195













UNCOV

6196



_end:




×








UNCOV

6197



  if (code != TSDB_CODE_SUCCESS) {





×








UNCOV

6198



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6199



  }











UNCOV

6200



  if (acquired) {





×








UNCOV

6201



    tsdbTrace("tsdb/read: %p, unlock read mutex", pReader);





×








UNCOV

6202



    (void)tsdbReleaseReader(pReader);




×







6203



  }











UNCOV

6204



  return code;




×







6205



}










6206













UNCOV

6207



static int32_t doFillNullColSMA(SBlockLoadSuppInfo* pSup, int32_t numOfRows, int32_t numOfCols,




×







6208



                                SColumnDataAgg* pTsAgg) {










6209



  // do fill all null column value SMA info











UNCOV

6210



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

6211



  int32_t lino = 0;




×








UNCOV

6212



  int32_t i = 0, j = 0;




×








UNCOV

6213



  int32_t size = 0;




×







6214













UNCOV

6215



  TSDB_CHECK_NULL(pSup, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6216













UNCOV

6217



  size = (int32_t)TARRAY2_SIZE(&pSup->colAggArray);




×








UNCOV

6218



  code = TARRAY2_INSERT_PTR(&pSup->colAggArray, 0, pTsAgg);





×








UNCOV

6219



  TSDB_CHECK_CODE(code, lino, _end);





×







6220













UNCOV

6221



  size++;




×







6222













UNCOV

6223



  while (j < numOfCols && i < size) {





×








UNCOV

6224



    SColumnDataAgg* pAgg = &pSup->colAggArray.data[i];




×








UNCOV

6225



    if (pAgg->colId == pSup->colId[j]) {





×








UNCOV

6226



      i += 1;




×








UNCOV

6227



      j += 1;




×








UNCOV

6228



    } else if (pAgg->colId < pSup->colId[j]) {





×








UNCOV

6229



      i += 1;




×







6230



    } else if (pSup->colId[j] < pAgg->colId) {





×







6231



      if (pSup->colId[j] != PRIMARYKEY_TIMESTAMP_COL_ID) {





×







6232



        SColumnDataAgg nullColAgg = {.colId = pSup->colId[j], .numOfNull = numOfRows};




×







6233



        code = TARRAY2_INSERT_PTR(&pSup->colAggArray, i, &nullColAgg);





×







6234



        TSDB_CHECK_CODE(code, lino, _end);





×







6235












6236



        i += 1;




×







6237



        size++;




×







6238



      }










6239



      j += 1;




×







6240



    }










6241



  }










6242













UNCOV

6243



  while (j < numOfCols) {





×








UNCOV

6244



    if (pSup->colId[j] != PRIMARYKEY_TIMESTAMP_COL_ID) {





×








UNCOV

6245



      SColumnDataAgg nullColAgg = {.colId = pSup->colId[j], .numOfNull = numOfRows};




×








UNCOV

6246



      code = TARRAY2_INSERT_PTR(&pSup->colAggArray, i, &nullColAgg);





×








UNCOV

6247



      TSDB_CHECK_CODE(code, lino, _end);





×







6248













UNCOV

6249



      i += 1;




×







6250



    }











UNCOV

6251



    j++;




×







6252



  }










6253













UNCOV

6254



_end:




×








UNCOV

6255



  if (code != TSDB_CODE_SUCCESS) {





×







6256



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6257



  }











UNCOV

6258



  return code;




×







6259



}










6260













UNCOV

6261



int32_t tsdbRetrieveDatablockSMA2(STsdbReader* pReader, SSDataBlock* pDataBlock, bool* allHave, bool* hasNullSMA) {




×








UNCOV

6262



  int32_t             code = TSDB_CODE_SUCCESS;




×








UNCOV

6263



  int32_t             lino = 0;




×








UNCOV

6264



  SColumnDataAgg**    pBlockSMA = NULL;




×








UNCOV

6265



  SFileDataBlockInfo* pBlockInfo = NULL;




×







6266













UNCOV

6267



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6268



  TSDB_CHECK_NULL(pDataBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6269



  TSDB_CHECK_NULL(allHave, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6270













UNCOV

6271



  pBlockSMA = &pDataBlock->pBlockAgg;




×








UNCOV

6272



  *allHave = false;




×








UNCOV

6273



  *pBlockSMA = NULL;




×







6274













UNCOV

6275



  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {





×








UNCOV

6276



    goto _end;




×







6277



  }










6278












6279



  // there is no statistics data for composed block











UNCOV

6280



  if (pReader->status.composedDataBlock || (!pReader->suppInfo.smaValid)) {





×








UNCOV

6281



    goto _end;




×







6282



  }










6283













UNCOV

6284



  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

6285



  TSDB_CHECK_CODE(code, lino, _end);





×







6286













UNCOV

6287



  SBlockLoadSuppInfo* pSup = &pReader->suppInfo;




×







6288













UNCOV

6289



  SSDataBlock* pResBlock = pReader->resBlockInfo.pResBlock;




×








UNCOV

6290



  if (pResBlock->info.id.uid != pBlockInfo->uid) {





×







6291



    goto _end;




×







6292



  }










6293












6294



  //  int64_t st = taosGetTimestampUs();











UNCOV

6295



  TARRAY2_CLEAR(&pSup->colAggArray, 0);




×







6296












6297



  SBrinRecord pRecord;











UNCOV

6298



  blockInfoToRecord(&pRecord, pBlockInfo, pSup);




×








UNCOV

6299



  code = tsdbDataFileReadBlockSma(pReader->pFileReader, &pRecord, &pSup->colAggArray);




×








UNCOV

6300



  if (code != TSDB_CODE_SUCCESS) {





×







6301



    tsdbDebug("vgId:%d, failed to load block SMA for uid %" PRIu64 ", code:%s, %s", 0, pBlockInfo->uid, tstrerror(code),





×







6302



              pReader->idStr);










6303



    TSDB_CHECK_CODE(code, lino, _end);





×







6304



  }










6305













UNCOV

6306



  if (pSup->colAggArray.size > 0) {





×








UNCOV

6307



    *allHave = true;




×







6308



  } else {










6309



    *pBlockSMA = NULL;




×







6310



    goto _end;




×







6311



  }










6312












6313



  // always load the first primary timestamp column data











UNCOV

6314



  SColumnDataAgg* pTsAgg = &pSup->tsColAgg;




×







6315













UNCOV

6316



  pTsAgg->numOfNull = 0;




×








UNCOV

6317



  pTsAgg->colId = PRIMARYKEY_TIMESTAMP_COL_ID;




×








UNCOV

6318



  pTsAgg->min = pResBlock->info.window.skey;




×








UNCOV

6319



  pTsAgg->max = pResBlock->info.window.ekey;




×







6320












6321



  // update the number of NULL data rows











UNCOV

6322



  size_t numOfCols = pSup->numOfCols;




×







6323













UNCOV

6324



  if (pResBlock->pBlockAgg == NULL) {





×








UNCOV

6325



    size_t num = taosArrayGetSize(pResBlock->pDataBlock);




×








UNCOV

6326



    pResBlock->pBlockAgg = taosMemoryCalloc(num, sizeof(SColumnDataAgg));





×








UNCOV

6327



    TSDB_CHECK_NULL(pResBlock->pBlockAgg, code, lino, _end, terrno);





×








UNCOV

6328



    for (int i = 0; i < num; ++i) {





×








UNCOV

6329



      pResBlock->pBlockAgg[i].colId = -1;




×







6330



    }










6331



  }










6332












6333



  // do fill all null column value SMA info











UNCOV

6334



  code = doFillNullColSMA(pSup, pBlockInfo->numRow, numOfCols, pTsAgg);




×








UNCOV

6335



  TSDB_CHECK_CODE(code, lino, _end);





×







6336













UNCOV

6337



  size_t size = pSup->colAggArray.size;




×







6338













UNCOV

6339



  int32_t i = 0, j = 0;




×








UNCOV

6340



  while (j < numOfCols && i < size) {





×








UNCOV

6341



    SColumnDataAgg* pAgg = &pSup->colAggArray.data[i];




×








UNCOV

6342



    if (pAgg->colId == pSup->colId[j]) {





×








UNCOV

6343



      pResBlock->pBlockAgg[pSup->slotId[j]] = *pAgg;




×








UNCOV

6344



      i += 1;




×








UNCOV

6345



      j += 1;




×








UNCOV

6346



    } else if (pAgg->colId < pSup->colId[j]) {





×








UNCOV

6347



      i += 1;




×







6348



    } else if (pSup->colId[j] < pAgg->colId) {





×







6349



      pResBlock->pBlockAgg[pSup->slotId[j]].colId = -1;




×







6350



      *allHave = false;




×







6351



      j += 1;




×







6352



    }










6353



  }










6354













UNCOV

6355



  *pBlockSMA = pResBlock->pBlockAgg;




×








UNCOV

6356



  pReader->cost.smaDataLoad += 1;




×







6357












6358



  //  double elapsedTime = (taosGetTimestampUs() - st) / 1000.0;











UNCOV

6359



  pReader->cost.smaLoadTime += 0;  // elapsedTime;




×







6360













UNCOV

6361



  tsdbDebug("vgId:%d, succeed to load block SMA for uid %" PRIu64 ", %s", 0, pBlockInfo->uid, pReader->idStr);





×







6362













UNCOV

6363



_end:




×








UNCOV

6364



  if (code != TSDB_CODE_SUCCESS) {





×







6365



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6366



  }











UNCOV

6367



  return code;




×







6368



}










6369













UNCOV

6370



static int32_t doRetrieveDataBlock(STsdbReader* pReader, SSDataBlock** pBlock) {




×








UNCOV

6371



  int32_t              code = TSDB_CODE_SUCCESS;




×








UNCOV

6372



  int32_t              lino = 0;




×








UNCOV

6373



  SReaderStatus*       pStatus = NULL;




×








UNCOV

6374



  SFileDataBlockInfo*  pBlockInfo = NULL;




×








UNCOV

6375



  STableBlockScanInfo* pBlockScanInfo = NULL;




×








UNCOV

6376



  bool                 reset = false;




×







6377













UNCOV

6378



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6379



  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6380













UNCOV

6381



  pStatus = &pReader->status;




×








UNCOV

6382



  *pBlock = NULL;




×







6383













UNCOV

6384



  code = getCurrentBlockInfo(&pStatus->blockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

6385



  TSDB_CHECK_CODE(code, lino, _end);





×







6386













UNCOV

6387



  code = pReader->code;




×








UNCOV

6388



  TSDB_CHECK_CODE(code, lino, _end);





×







6389













UNCOV

6390



  code = getTableBlockScanInfo(pStatus->pTableMap, pBlockInfo->uid, &pBlockScanInfo, pReader->idStr);




×








UNCOV

6391



  TSDB_CHECK_CODE(code, lino, _end);





×







6392













UNCOV

6393



  reset = true;




×








UNCOV

6394



  code = doLoadFileBlockData(pReader, &pStatus->blockIter, &pStatus->fileBlockData, pBlockScanInfo->uid);




×








UNCOV

6395



  TSDB_CHECK_CODE(code, lino, _end);





×







6396













UNCOV

6397



  code = copyBlockDataToSDataBlock(pReader, &pBlockScanInfo->lastProcKey);




×








UNCOV

6398



  TSDB_CHECK_CODE(code, lino, _end);





×







6399













UNCOV

6400



  *pBlock = pReader->resBlockInfo.pResBlock;




×







6401













UNCOV

6402



_end:




×








UNCOV

6403



  if (code != TSDB_CODE_SUCCESS) {





×







6404



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6405



    if (reset) {





×







6406



      tBlockDataReset(&pStatus->fileBlockData);




×







6407



    }










6408



  }











UNCOV

6409



  return code;




×







6410



}










6411













UNCOV

6412



int32_t tsdbRetrieveDataBlock2(STsdbReader* pReader, SSDataBlock** pBlock, SArray* pIdList) {




×








UNCOV

6413



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

6414



  int32_t      lino = 0;




×








UNCOV

6415



  STsdbReader* pTReader = NULL;




×







6416













UNCOV

6417



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6418



  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6419













UNCOV

6420



  *pBlock = NULL;




×







6421













UNCOV

6422



  pTReader = pReader;




×








UNCOV

6423



  if (pReader->type == TIMEWINDOW_RANGE_EXTERNAL) {





×








UNCOV

6424



    if (pReader->step == EXTERNAL_ROWS_PREV) {





×








UNCOV

6425



      pTReader = pReader->innerReader[0];




×








UNCOV

6426



    } else if (pReader->step == EXTERNAL_ROWS_NEXT) {





×








UNCOV

6427



      pTReader = pReader->innerReader[1];




×







6428



    }










6429



  }










6430













UNCOV

6431



  SReaderStatus* pStatus = &pTReader->status;




×








UNCOV

6432



  if (pStatus->composedDataBlock || pReader->info.execMode == READER_EXEC_ROWS) {





×







6433



    //    tsdbReaderSuspend2(pReader);










6434



    //    tsdbReaderResume2(pReader);











UNCOV

6435



    *pBlock = pTReader->resBlockInfo.pResBlock;




×








UNCOV

6436



    goto _end;




×







6437



  }










6438













UNCOV

6439



  code = doRetrieveDataBlock(pTReader, pBlock);




×







6440













UNCOV

6441



  tsdbTrace("tsdb/read-retrieve: %p, unlock read mutex", pReader);





×








UNCOV

6442



  (void) tsdbReleaseReader(pReader);




×








UNCOV

6443



  TSDB_CHECK_CODE(code, lino, _end);





×







6444












6445



  //  tsdbReaderSuspend2(pReader);










6446



  //  tsdbReaderResume2(pReader);











UNCOV

6447



_end:




×








UNCOV

6448



  if (code != TSDB_CODE_SUCCESS) {





×







6449



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6450



  }











UNCOV

6451



  return code;




×







6452



}










6453













UNCOV

6454



int32_t tsdbReaderReset2(STsdbReader* pReader, SQueryTableDataCond* pCond) {




×








UNCOV

6455



  int32_t code = TSDB_CODE_SUCCESS;




×








UNCOV

6456



  int32_t lino = 0;




×








UNCOV

6457



  bool    acquired = false;




×







6458













UNCOV

6459



  tsdbTrace("tsdb/reader-reset: %p, take read mutex", pReader);





×








UNCOV

6460



  code = tsdbAcquireReader(pReader);




×








UNCOV

6461



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6462



  acquired = true;




×







6463













UNCOV

6464



  if (pReader->flag == READER_STATUS_SUSPEND) {





×








UNCOV

6465



    code = tsdbReaderResume2(pReader);




×








UNCOV

6466



    TSDB_CHECK_CODE(code, lino, _end);





×







6467



  }










6468













UNCOV

6469



  if (isEmptyQueryTimeWindow(&pReader->info.window) || pReader->pReadSnap == NULL) {





×








UNCOV

6470



    tsdbDebug("tsdb reader reset return %p, %s", pReader->pReadSnap, pReader->idStr);





×








UNCOV

6471



    code = tsdbReleaseReader(pReader);




×








UNCOV

6472



    acquired = false;




×








UNCOV

6473



    TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6474



    goto _end;




×







6475



  }










6476













UNCOV

6477



  SReaderStatus*  pStatus = &pReader->status;




×








UNCOV

6478



  SDataBlockIter* pBlockIter = &pStatus->blockIter;




×







6479













UNCOV

6480



  TSDB_CHECK_NULL(pCond, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6481



  pReader->info.order = pCond->order;




×








UNCOV

6482



  pReader->type = TIMEWINDOW_RANGE_CONTAINED;




×








UNCOV

6483



  code = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows, &pReader->info.window);




×








UNCOV

6484



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6485



  pStatus->loadFromFile = true;




×








UNCOV

6486



  pStatus->pTableIter = NULL;




×







6487












6488



  // allocate buffer in order to load data blocks from file











UNCOV

6489



  memset(&pReader->suppInfo.tsColAgg, 0, sizeof(SColumnDataAgg));




×







6490













UNCOV

6491



  pReader->suppInfo.tsColAgg.colId = PRIMARYKEY_TIMESTAMP_COL_ID;




×








UNCOV

6492



  tsdbDataFileReaderClose(&pReader->pFileReader);




×







6493













UNCOV

6494



  int32_t numOfTables = tSimpleHashGetSize(pStatus->pTableMap);




×







6495













UNCOV

6496



  code = initFilesetIterator(&pStatus->fileIter, pReader->pReadSnap->pfSetArray, pReader);




×








UNCOV

6497



  TSDB_CHECK_CODE(code, lino, _end);





×







6498













UNCOV

6499



  code = resetDataBlockIterator(pBlockIter, pReader->info.order, shouldFreePkBuf(&pReader->suppInfo), pReader->idStr);




×








UNCOV

6500



  TSDB_CHECK_CODE(code, lino, _end);





×







6501













UNCOV

6502



  code = resetTableListIndex(&pReader->status, pReader->idStr);




×








UNCOV

6503



  TSDB_CHECK_CODE(code, lino, _end);





×







6504













UNCOV

6505



  bool    asc = ASCENDING_TRAVERSE(pReader->info.order);




×








UNCOV

6506



  int32_t step = asc ? 1 : -1;





×








UNCOV

6507



  int64_t ts = 0;




×








UNCOV

6508



  if (asc) {





×








UNCOV

6509



    ts = (pReader->info.window.skey > INT64_MIN) ? pReader->info.window.skey - 1 : pReader->info.window.skey;





×







6510



  } else {











UNCOV

6511



    ts = (pReader->info.window.ekey < INT64_MAX) ? pReader->info.window.ekey + 1 : pReader->info.window.ekey;





×







6512



  }











UNCOV

6513



  resetAllDataBlockScanInfo(pStatus->pTableMap, ts, step);




×







6514












6515



  // no data in files, let's try buffer in memory











UNCOV

6516



  if (pStatus->fileIter.numOfFiles == 0) {





×








UNCOV

6517



    pStatus->loadFromFile = false;




×








UNCOV

6518



    code = resetTableListIndex(pStatus, pReader->idStr);




×








UNCOV

6519



    TSDB_CHECK_CODE(code, lino, _end);





×







6520



  } else {











UNCOV

6521



    code = initForFirstBlockInFile(pReader, pBlockIter);




×








UNCOV

6522



    if (code != TSDB_CODE_SUCCESS) {





×







6523



      tsdbError("%p reset reader failed, numOfTables:%d, query range:%" PRId64 " - %" PRId64 " in query %s", pReader,





×







6524



                numOfTables, pReader->info.window.skey, pReader->info.window.ekey, pReader->idStr);










6525



      TSDB_CHECK_CODE(code, lino, _end);





×







6526



    }










6527



  }










6528













UNCOV

6529



  tsdbDebug("%p reset reader, suid:%" PRIu64 ", numOfTables:%d, skey:%" PRId64 ", query range:%" PRId64 " - %" PRId64





×







6530



            " in query %s",










6531



            pReader, pReader->info.suid, numOfTables, pCond->twindows.skey, pReader->info.window.skey,










6532



            pReader->info.window.ekey, pReader->idStr);










6533













UNCOV

6534



  code = tsdbReleaseReader(pReader);




×








UNCOV

6535



  acquired = false;




×








UNCOV

6536



  TSDB_CHECK_CODE(code, lino, _end);





×







6537













UNCOV

6538



_end:




×








UNCOV

6539



  if (code != TSDB_CODE_SUCCESS) {





×







6540



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6541



  }











UNCOV

6542



  if (acquired) {





×







6543



    (void)tsdbReleaseReader(pReader);




×







6544



  }











UNCOV

6545



  return code;




×







6546



}










6547













UNCOV

6548



static int32_t getBucketIndex(int32_t startRow, int32_t bucketRange, int32_t numOfRows, int32_t numOfBucket) {




×








UNCOV

6549



  if (numOfRows < startRow) {





×







6550



    return 0;




×







6551



  }











UNCOV

6552



  int32_t bucketIndex = ((numOfRows - startRow) / bucketRange);




×








UNCOV

6553



  if (bucketIndex == numOfBucket) {





×







6554



    bucketIndex -= 1;




×







6555



  }











UNCOV

6556



  return bucketIndex;




×







6557



}










6558













UNCOV

6559



int32_t tsdbGetFileBlocksDistInfo2(STsdbReader* pReader, STableBlockDistInfo* pTableBlockInfo) {




×








UNCOV

6560



  int32_t       code = TSDB_CODE_SUCCESS;




×








UNCOV

6561



  int32_t       lino = 0;




×








UNCOV

6562



  const int32_t numOfBuckets = 20.0;




×








UNCOV

6563



  bool          acquired = false;




×







6564













UNCOV

6565



  TSDB_CHECK_NULL(pTableBlockInfo, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6566













UNCOV

6567



  pTableBlockInfo->totalSize = 0;




×








UNCOV

6568



  pTableBlockInfo->totalRows = 0;




×








UNCOV

6569



  pTableBlockInfo->numOfVgroups = 1;




×







6570












6571



  // find the start data block in file











UNCOV

6572



  code = tsdbAcquireReader(pReader);




×








UNCOV

6573



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6574



  acquired = true;




×







6575













UNCOV

6576



  if (pReader->flag == READER_STATUS_SUSPEND) {





×








UNCOV

6577



    code = tsdbReaderResume2(pReader);




×








UNCOV

6578



    TSDB_CHECK_CODE(code, lino, _end);





×







6579



  }










6580













UNCOV

6581



  SMergeTreeConf conf = {




×







6582



      .pReader = pReader,











UNCOV

6583



      .pSchema = pReader->info.pSchema,




×








UNCOV

6584



      .pCols = pReader->suppInfo.colId,




×








UNCOV

6585



      .numOfCols = pReader->suppInfo.numOfCols,




×








UNCOV

6586



      .suid = pReader->info.suid,




×







6587



  };










6588













UNCOV

6589



  SReaderStatus* pStatus = &pReader->status;




×








UNCOV

6590



  if (pStatus->pCurrentFileset != NULL) {





×








UNCOV

6591



    pTableBlockInfo->numOfSttRows += tsdbGetRowsInSttFiles(pStatus->pCurrentFileset, pStatus->pLDataIterArray,




×








UNCOV

6592



                                                           pReader->pTsdb, &conf, pReader->idStr);




×







6593



  }










6594













UNCOV

6595



  STsdbCfg* pc = &pReader->pTsdb->pVnode->config.tsdbCfg;




×








UNCOV

6596



  pTableBlockInfo->defMinRows = pc->minRows;




×








UNCOV

6597



  pTableBlockInfo->defMaxRows = pc->maxRows;




×







6598













UNCOV

6599



  int32_t bucketRange = ceil(((double)(pc->maxRows - pc->minRows)) / numOfBuckets);




×







6600













UNCOV

6601



  pTableBlockInfo->numOfFiles += 1;




×







6602













UNCOV

6603



  int32_t numOfTables = (int32_t)tSimpleHashGetSize(pStatus->pTableMap);




×







6604













UNCOV

6605



  SDataBlockIter* pBlockIter = &pStatus->blockIter;




×








UNCOV

6606



  pTableBlockInfo->numOfFiles += pStatus->fileIter.numOfFiles;




×







6607













UNCOV

6608



  if (pBlockIter->numOfBlocks > 0) {





×








UNCOV

6609



    pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;




×







6610



  }










6611













UNCOV

6612



  pTableBlockInfo->numOfTables = numOfTables;




×








UNCOV

6613



  bool hasNext = (pBlockIter->numOfBlocks > 0);




×







6614












6615



  while (true) {











UNCOV

6616



    if (hasNext) {





×








UNCOV

6617



      SFileDataBlockInfo* pBlockInfo = NULL;




×








UNCOV

6618



      code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);




×








UNCOV

6619



      TSDB_CHECK_CODE(code, lino, _end);





×







6620













UNCOV

6621



      int32_t numOfRows = pBlockInfo->numRow;




×







6622













UNCOV

6623



      pTableBlockInfo->totalRows += numOfRows;




×







6624













UNCOV

6625



      if (numOfRows > pTableBlockInfo->maxRows) {





×








UNCOV

6626



        pTableBlockInfo->maxRows = numOfRows;




×







6627



      }










6628













UNCOV

6629



      if (numOfRows < pTableBlockInfo->minRows) {





×








UNCOV

6630



        pTableBlockInfo->minRows = numOfRows;




×







6631



      }










6632













UNCOV

6633



      pTableBlockInfo->totalSize += pBlockInfo->blockSize;




×







6634













UNCOV

6635



      int32_t bucketIndex = getBucketIndex(pTableBlockInfo->defMinRows, bucketRange, numOfRows, numOfBuckets);




×








UNCOV

6636



      pTableBlockInfo->blockRowsHisto[bucketIndex]++;




×







6637













UNCOV

6638



      hasNext = blockIteratorNext(&pStatus->blockIter);




×







6639



    } else {











UNCOV

6640



      code = initForFirstBlockInFile(pReader, pBlockIter);




×








UNCOV

6641



      TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6642



      if (pStatus->loadFromFile == false) {





×








UNCOV

6643



        break;




×







6644



      }










6645












6646



      // add the data in stt files of new fileset











UNCOV

6647



      if (pStatus->pCurrentFileset != NULL) {





×








UNCOV

6648



        pTableBlockInfo->numOfSttRows += tsdbGetRowsInSttFiles(pStatus->pCurrentFileset, pStatus->pLDataIterArray,




×








UNCOV

6649



                                                               pReader->pTsdb, &conf, pReader->idStr);




×







6650



      }










6651













UNCOV

6652



      pTableBlockInfo->numOfBlocks += pBlockIter->numOfBlocks;




×








UNCOV

6653



      hasNext = (pBlockIter->numOfBlocks > 0);




×







6654



    }










6655



  }










6656












6657



  // record the data in stt files











UNCOV

6658



_end:




×








UNCOV

6659



  if (code != TSDB_CODE_SUCCESS) {





×







6660



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6661



  }











UNCOV

6662



  if (acquired) {





×








UNCOV

6663



    (void)tsdbReleaseReader(pReader);




×







6664



  }











UNCOV

6665



  return code;




×







6666



}










6667













UNCOV

6668



static void getMemTableTimeRange(STsdbReader* pReader, int64_t* pMaxKey, int64_t* pMinKey) {




×








UNCOV

6669



  SReaderStatus* pStatus = &pReader->status;




×







6670













UNCOV

6671



  int32_t iter = 0;




×








UNCOV

6672



  int64_t maxKey = INT64_MIN;




×








UNCOV

6673



  int64_t minKey = INT64_MAX;




×







6674













UNCOV

6675



  void* pHashIter = tSimpleHashIterate(pStatus->pTableMap, NULL, &iter);




×








UNCOV

6676



  while (pHashIter != NULL) {





×








UNCOV

6677



    STableBlockScanInfo* pBlockScanInfo = *(STableBlockScanInfo**)pHashIter;




×







6678













UNCOV

6679



    STbData* d = NULL;




×








UNCOV

6680



    if (pReader->pReadSnap->pMem != NULL) {





×








UNCOV

6681



      d = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pMem, pReader->info.suid, pBlockScanInfo->uid);




×








UNCOV

6682



      if (d != NULL) {





×








UNCOV

6683



        if (d->maxKey > maxKey) {





×








UNCOV

6684



          maxKey = d->maxKey;




×







6685



        }











UNCOV

6686



        if (d->minKey < minKey) {





×








UNCOV

6687



          minKey = d->minKey;




×







6688



        }










6689



      }










6690



    }










6691













UNCOV

6692



    STbData* di = NULL;




×








UNCOV

6693



    if (pReader->pReadSnap->pIMem != NULL) {





×








UNCOV

6694



      di = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pIMem, pReader->info.suid, pBlockScanInfo->uid);




×








UNCOV

6695



      if (di != NULL) {





×








UNCOV

6696



        if (di->maxKey > maxKey) {





×








UNCOV

6697



          maxKey = di->maxKey;




×







6698



        }











UNCOV

6699



        if (di->minKey < minKey) {





×








UNCOV

6700



          minKey = di->minKey;




×







6701



        }










6702



      }










6703



    }










6704












6705



    // current table is exhausted, let's try the next table











UNCOV

6706



    pHashIter = tSimpleHashIterate(pStatus->pTableMap, pHashIter, &iter);




×







6707



  }










6708













UNCOV

6709



  *pMaxKey = maxKey;




×








UNCOV

6710



  *pMinKey = minKey;




×








UNCOV

6711



}




×







6712













UNCOV

6713



int64_t tsdbGetNumOfRowsInMemTable2(STsdbReader* pReader, uint32_t* rows) {




×








UNCOV

6714



  int32_t        code = TSDB_CODE_SUCCESS;




×








UNCOV

6715



  int32_t        lino = 0;




×








UNCOV

6716



  SReaderStatus* pStatus = NULL;




×








UNCOV

6717



  bool           acquired = false;




×







6718













UNCOV

6719



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×








UNCOV

6720



  TSDB_CHECK_NULL(rows, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6721













UNCOV

6722



  *rows = 0;




×








UNCOV

6723



  pStatus = &pReader->status;




×








UNCOV

6724



  code = tsdbAcquireReader(pReader);




×








UNCOV

6725



  TSDB_CHECK_CODE(code, lino, _end);





×








UNCOV

6726



  acquired = true;




×







6727













UNCOV

6728



  if (pReader->flag == READER_STATUS_SUSPEND) {





×








UNCOV

6729



    code = tsdbReaderResume2(pReader);




×








UNCOV

6730



    TSDB_CHECK_CODE(code, lino, _end);





×







6731



  }










6732













UNCOV

6733



  int32_t iter = 0;




×








UNCOV

6734



  pStatus->pTableIter = tSimpleHashIterate(pStatus->pTableMap, NULL, &iter);




×







6735













UNCOV

6736



  while (pStatus->pTableIter != NULL) {





×








UNCOV

6737



    STableBlockScanInfo* pBlockScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;




×







6738













UNCOV

6739



    STbData* d = NULL;




×








UNCOV

6740



    if (pReader->pReadSnap->pMem != NULL) {





×








UNCOV

6741



      d = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pMem, pReader->info.suid, pBlockScanInfo->uid);




×








UNCOV

6742



      if (d != NULL) {





×








UNCOV

6743



        *rows += tsdbGetNRowsInTbData(d);




×







6744



      }










6745



    }










6746













UNCOV

6747



    STbData* di = NULL;




×








UNCOV

6748



    if (pReader->pReadSnap->pIMem != NULL) {





×








UNCOV

6749



      di = tsdbGetTbDataFromMemTable(pReader->pReadSnap->pIMem, pReader->info.suid, pBlockScanInfo->uid);




×








UNCOV

6750



      if (di != NULL) {





×








UNCOV

6751



        *rows += tsdbGetNRowsInTbData(di);




×







6752



      }










6753



    }










6754












6755



    // current table is exhausted, let's try the next table











UNCOV

6756



    pStatus->pTableIter = tSimpleHashIterate(pStatus->pTableMap, pStatus->pTableIter, &iter);




×







6757



  }










6758













UNCOV

6759



_end:




×








UNCOV

6760



  if (code != TSDB_CODE_SUCCESS) {





×







6761



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6762



  }











UNCOV

6763



  if (acquired) {





×








UNCOV

6764



    (void)tsdbReleaseReader(pReader);




×







6765



  }











UNCOV

6766



  return code;




×







6767



}










6768













UNCOV

6769



int32_t tsdbGetTableSchema(SMeta* pMeta, int64_t uid, STSchema** pSchema, int64_t* suid) {




×








UNCOV

6770



  SMetaReader mr = {0};




×








UNCOV

6771



  metaReaderDoInit(&mr, pMeta, META_READER_LOCK);




×








UNCOV

6772



  int32_t code = metaReaderGetTableEntryByUidCache(&mr, uid);




×








UNCOV

6773



  if (code != TSDB_CODE_SUCCESS) {





×







6774



    code = TSDB_CODE_TDB_INVALID_TABLE_ID;




×







6775



    metaReaderClear(&mr);




×







6776



    return code;




×







6777



  }










6778













UNCOV

6779



  *suid = 0;




×







6780












6781



  // only child table and ordinary table is allowed, super table is not allowed.











UNCOV

6782



  if (mr.me.type == TSDB_CHILD_TABLE) {





×








UNCOV

6783



    tDecoderClear(&mr.coder);




×








UNCOV

6784



    *suid = mr.me.ctbEntry.suid;




×








UNCOV

6785



    code = metaReaderGetTableEntryByUidCache(&mr, *suid);




×








UNCOV

6786



    if (code != TSDB_CODE_SUCCESS) {





×







6787



      code = TSDB_CODE_TDB_INVALID_TABLE_ID;




×







6788



      metaReaderClear(&mr);




×







6789



      return code;




×







6790



    }











UNCOV

6791



  } else if (mr.me.type == TSDB_NORMAL_TABLE) {  // do nothing





×







6792



  } else {










6793



    code = TSDB_CODE_INVALID_PARA;




×







6794



    tsdbError("invalid mr.me.type:%d, code:%s", mr.me.type, tstrerror(code));





×







6795



    metaReaderClear(&mr);




×







6796



    return code;




×







6797



  }










6798













UNCOV

6799



  metaReaderClear(&mr);




×







6800












6801



  // get the newest table schema version











UNCOV

6802



  code = metaGetTbTSchemaEx(pMeta, *suid, uid, -1, pSchema);




×








UNCOV

6803



  return code;




×







6804



}










6805













UNCOV

6806



int32_t tsdbTakeReadSnap2(STsdbReader* pReader, _query_reseek_func_t reseek, STsdbReadSnap** ppSnap, const char* id) {




×








UNCOV

6807



  int32_t        code = 0;




×








UNCOV

6808



  STsdb*         pTsdb = pReader->pTsdb;




×








UNCOV

6809



  SVersionRange* pRange = &pReader->info.verRange;




×








UNCOV

6810



  int32_t        lino = 0;




×








UNCOV

6811



  *ppSnap = NULL;




×







6812












6813



  // lock











UNCOV

6814



  code = taosThreadMutexLock(&pTsdb->mutex);




×








UNCOV

6815



  if (code != TSDB_CODE_SUCCESS) {





×







6816



    tsdbError("%s failed to lock tsdb, code:%s", id, tstrerror(code));





×







6817



    return code;




×







6818



  }










6819












6820



  // alloc











UNCOV

6821



  STsdbReadSnap* pSnap = (STsdbReadSnap*)taosMemoryCalloc(1, sizeof(STsdbReadSnap));





×








UNCOV

6822



  if (pSnap == NULL) {





×







6823



    (void) taosThreadMutexUnlock(&pTsdb->mutex);




×







6824



    TSDB_CHECK_NULL(pSnap, code, lino, _exit, terrno);





×







6825



  }










6826












6827



  // take snapshot











UNCOV

6828



  if (pTsdb->mem && (pRange->minVer <= pTsdb->mem->maxVer && pRange->maxVer >= pTsdb->mem->minVer)) {





×








UNCOV

6829



    pSnap->pMem = pTsdb->mem;




×








UNCOV

6830



    pSnap->pNode = taosMemoryMalloc(sizeof(*pSnap->pNode));





×








UNCOV

6831



    if (pSnap->pNode == NULL) {





×







6832



      (void) taosThreadMutexUnlock(&pTsdb->mutex);




×







6833



      TSDB_CHECK_NULL(pSnap->pNode, code, lino, _exit, terrno);





×







6834



    }










6835













UNCOV

6836



    pSnap->pNode->pQHandle = pReader;




×








UNCOV

6837



    pSnap->pNode->reseek = reseek;




×







6838













UNCOV

6839



    code = tsdbRefMemTable(pTsdb->mem, pSnap->pNode);




×








UNCOV

6840



    TSDB_CHECK_CODE(code, lino, _exit);





×







6841



  }










6842













UNCOV

6843



  if (pTsdb->imem && (pRange->minVer <= pTsdb->imem->maxVer && pRange->maxVer >= pTsdb->imem->minVer)) {





×








UNCOV

6844



    pSnap->pIMem = pTsdb->imem;




×








UNCOV

6845



    pSnap->pINode = taosMemoryMalloc(sizeof(*pSnap->pINode));





×








UNCOV

6846



    if (pSnap->pINode == NULL) {





×







6847



      code = terrno;




×







6848












6849



      if (pTsdb->mem && pSnap->pNode) {





×







6850



        tsdbUnrefMemTable(pTsdb->mem, pSnap->pNode, true);  // unref the previous refed mem




×







6851



      }










6852












6853



      (void) taosThreadMutexUnlock(&pTsdb->mutex);




×







6854



      goto _exit;




×







6855



    }










6856













UNCOV

6857



    pSnap->pINode->pQHandle = pReader;




×








UNCOV

6858



    pSnap->pINode->reseek = reseek;




×







6859













UNCOV

6860



    code = tsdbRefMemTable(pTsdb->imem, pSnap->pINode);




×








UNCOV

6861



    TSDB_CHECK_CODE(code, lino, _exit);





×







6862



  }










6863












6864



  // fs











UNCOV

6865



  code = tsdbFSCreateRefSnapshotWithoutLock(pTsdb->pFS, &pSnap->pfSetArray);




×








UNCOV

6866



  if (code) {





×







6867



    if (pSnap->pNode) {





×







6868



      tsdbUnrefMemTable(pTsdb->mem, pSnap->pNode, true);  // unref the previous refed mem




×







6869



    }










6870












6871



    if (pSnap->pINode) {





×







6872



      tsdbUnrefMemTable(pTsdb->imem, pSnap->pINode, true);




×







6873



    }










6874












6875



    (void) taosThreadMutexUnlock(&pTsdb->mutex);




×







6876



    TSDB_CHECK_CODE(code, lino, _exit);





×







6877



  }










6878












6879



  // unlock











UNCOV

6880



  (void) taosThreadMutexUnlock(&pTsdb->mutex);




×








UNCOV

6881



  *ppSnap = pSnap;




×







6882













UNCOV

6883



  tsdbTrace("%s vgId:%d, take read snapshot", id, TD_VID(pTsdb->pVnode));





×








UNCOV

6884



  return code;




×







6885












6886



_exit:




×







6887



  tsdbError("%s vgId:%d take read snapshot failed, line:%d code:%s", id, TD_VID(pTsdb->pVnode), lino, tstrerror(code));





×







6888












6889



  if (pSnap) {





×







6890



    if (pSnap->pNode) taosMemoryFree(pSnap->pNode);





×







6891



    if (pSnap->pINode) taosMemoryFree(pSnap->pINode);





×







6892



    taosMemoryFree(pSnap);





×







6893



  }










6894



  return code;




×







6895



}










6896













UNCOV

6897



void tsdbUntakeReadSnap2(STsdbReader* pReader, STsdbReadSnap* pSnap, bool proactive) {




×








UNCOV

6898



  STsdb* pTsdb = pReader->pTsdb;




×







6899













UNCOV

6900



  if (pSnap) {





×








UNCOV

6901



    if (pSnap->pMem) {





×








UNCOV

6902



      tsdbUnrefMemTable(pSnap->pMem, pSnap->pNode, proactive);




×







6903



    }










6904













UNCOV

6905



    if (pSnap->pIMem) {





×








UNCOV

6906



      tsdbUnrefMemTable(pSnap->pIMem, pSnap->pINode, proactive);




×







6907



    }










6908













UNCOV

6909



    if (pSnap->pNode) taosMemoryFree(pSnap->pNode);





×








UNCOV

6910



    if (pSnap->pINode) taosMemoryFree(pSnap->pINode);





×







6911













UNCOV

6912



    tsdbFSDestroyRefSnapshot(&pSnap->pfSetArray);




×







6913













UNCOV

6914



    taosMemoryFree(pSnap);





×







6915



  }











UNCOV

6916



  tsdbTrace("vgId:%d, untake read snapshot", TD_VID(pTsdb->pVnode));





×








UNCOV

6917



}




×







6918












6919



// if failed, do nothing











UNCOV

6920



int32_t tsdbReaderSetId(void* p, const char* idstr) {




×








UNCOV

6921



  int32_t      code = TSDB_CODE_SUCCESS;




×








UNCOV

6922



  int32_t      lino = 0;




×








UNCOV

6923



  STsdbReader* pReader = (STsdbReader*)p;




×







6924













UNCOV

6925



  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);





×







6926













UNCOV

6927



  taosMemoryFreeClear(pReader->idStr);





×








UNCOV

6928



  pReader->idStr = taosStrdup(idstr);





×








UNCOV

6929



  TSDB_CHECK_NULL(pReader->idStr, code, lino, _end, terrno);





×







6930













UNCOV

6931



  pReader->status.fileIter.pSttBlockReader->mergeTree.idStr = pReader->idStr;




×







6932













UNCOV

6933



_end:




×








UNCOV

6934



  if (code != TSDB_CODE_SUCCESS) {





×







6935



    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));





×







6936



  }











UNCOV

6937



  return code;




×







6938



}










6939













UNCOV

6940



void tsdbReaderSetCloseFlag(STsdbReader* pReader) { /*pReader->code = TSDB_CODE_TSC_QUERY_CANCELLED;*/ }




×







6941













UNCOV

6942



void tsdbSetFilesetDelimited(STsdbReader* pReader) { pReader->bFilesetDelimited = true; }




×







6943













UNCOV

6944



void tsdbReaderSetNotifyCb(STsdbReader* pReader, TsdReaderNotifyCbFn notifyFn, void* param) {




×








UNCOV

6945



  pReader->notifyFn = notifyFn;




×








UNCOV

6946



  pReader->notifyParam = param;




×








UNCOV

6947



}




×





















    

  • 

    •