Recached

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/tsdbFSet2.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 "tsdbFSet2.h"










17



#include "vnd.h"










18













UNCOV

19



int32_t tsdbSttLvlInit(int32_t level, SSttLvl **lvl) {




×








UNCOV

20



  if (!(lvl[0] = taosMemoryMalloc(sizeof(SSttLvl)))) {





×







21



    return terrno;




×







22



  }











UNCOV

23



  lvl[0]->level = level;




×








UNCOV

24



  TARRAY2_INIT(lvl[0]->fobjArr);




×








UNCOV

25



  return 0;




×







26



}










27













UNCOV

28



static void tsdbSttLvlClearFObj(void *data) { TAOS_UNUSED(tsdbTFileObjUnref(*(STFileObj **)data)); }




×







29













UNCOV

30



void tsdbSttLvlClear(SSttLvl **lvl) {




×








UNCOV

31



  if (lvl[0] != NULL) {





×








UNCOV

32



    TARRAY2_DESTROY(lvl[0]->fobjArr, tsdbSttLvlClearFObj);





×








UNCOV

33



    taosMemoryFree(lvl[0]);





×








UNCOV

34



    lvl[0] = NULL;




×







35



  }











UNCOV

36



}




×







37













UNCOV

38



static int32_t tsdbSttLvlInitEx(STsdb *pTsdb, const SSttLvl *lvl1, SSttLvl **lvl) {




×








UNCOV

39



  int32_t code = tsdbSttLvlInit(lvl1->level, lvl);




×








UNCOV

40



  if (code) return code;





×







41












42



  const STFileObj *fobj1;











UNCOV

43



  TARRAY2_FOREACH(lvl1->fobjArr, fobj1) {





×







44



    STFileObj *fobj;











UNCOV

45



    code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj);




×








UNCOV

46



    if (code) {





×








UNCOV

47



      tsdbSttLvlClear(lvl);




×







48



      return code;




×







49



    }










50













UNCOV

51



    code = TARRAY2_APPEND(lvl[0]->fobjArr, fobj);





×








UNCOV

52



    if (code) {





×







53



      tsdbSttLvlClear(lvl);




×







54



      taosMemoryFree(fobj);





×







55



      return code;




×







56



    }










57



  }











UNCOV

58



  return 0;




×







59



}










60













UNCOV

61



static int32_t tsdbSttLvlInitRef(STsdb *pTsdb, const SSttLvl *lvl1, SSttLvl **lvl) {




×








UNCOV

62



  int32_t code = tsdbSttLvlInit(lvl1->level, lvl);




×








UNCOV

63



  if (code) return code;





×







64












65



  STFileObj *fobj1;











UNCOV

66



  TARRAY2_FOREACH(lvl1->fobjArr, fobj1) {





×








UNCOV

67



    code = tsdbTFileObjRef(fobj1);




×








UNCOV

68



    if (code) {





×








UNCOV

69



      tsdbSttLvlClear(lvl);




×







70



      return code;




×







71



    }











UNCOV

72



    code = TARRAY2_APPEND(lvl[0]->fobjArr, fobj1);





×








UNCOV

73



    if (code) {





×







74



      if (tsdbTFileObjUnref(fobj1) != 0) {





×







75



        tsdbError("failed to unref file obj, fobj:%p", fobj1);





×







76



      }










77



      tsdbSttLvlClear(lvl);




×







78



      return code;




×







79



    }










80



  }











UNCOV

81



  return 0;




×







82



}










83












84



static int32_t tsdbSttLvlFilteredInitEx(STsdb *pTsdb, const SSttLvl *lvl1, int64_t ever, SSttLvl **lvl,




×







85



                                        TFileOpArray *fopArr) {










86



  int32_t code = tsdbSttLvlInit(lvl1->level, lvl);




×







87



  if (code) return code;





×







88












89



  const STFileObj *fobj1;










90



  TARRAY2_FOREACH(lvl1->fobjArr, fobj1) {





×







91



    if (fobj1->f->maxVer <= ever) {





×







92



      STFileObj *fobj;










93



      code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj);




×







94



      if (code) {





×







95



        tsdbSttLvlClear(lvl);




×







96



        return code;




×







97



      }










98












99



      TAOS_CHECK_RETURN(TARRAY2_APPEND(lvl[0]->fobjArr, fobj));





×







100



    } else {










101



      STFileOp op = {




×







102



          .optype = TSDB_FOP_REMOVE,










103



          .fid = fobj1->f->fid,




×







104



          .of = fobj1->f[0],










105



      };










106



      TAOS_CHECK_RETURN(TARRAY2_APPEND(fopArr, op));





×







107



    }










108



  }










109



  return 0;




×







110



}










111













UNCOV

112



static void tsdbSttLvlRemoveFObj(void *data) {




×








UNCOV

113



  int32_t code = tsdbTFileObjRemove(*(STFileObj **)data);




×








UNCOV

114



  if (code) {





×







115



    tsdbError("failed to remove file obj, code:%d, error:%s", code, tstrerror(code));





×







116



  }











UNCOV

117



}




×








UNCOV

118



static void tsdbSttLvlRemove(SSttLvl **lvl) {




×








UNCOV

119



  TARRAY2_DESTROY(lvl[0]->fobjArr, tsdbSttLvlRemoveFObj);





×








UNCOV

120



  taosMemoryFree(lvl[0]);





×








UNCOV

121



  lvl[0] = NULL;




×








UNCOV

122



}




×







123













UNCOV

124



static int32_t tsdbSttLvlApplyEdit(STsdb *pTsdb, const SSttLvl *lvl1, SSttLvl *lvl2) {




×








UNCOV

125



  int32_t code = 0;




×







126













UNCOV

127



  if (lvl1->level != lvl2->level) {





×







128



    return TSDB_CODE_INVALID_PARA;




×







129



  }










130













UNCOV

131



  int32_t i1 = 0, i2 = 0;




×








UNCOV

132



  while (i1 < TARRAY2_SIZE(lvl1->fobjArr) || i2 < TARRAY2_SIZE(lvl2->fobjArr)) {





×








UNCOV

133



    STFileObj *fobj1 = i1 < TARRAY2_SIZE(lvl1->fobjArr) ? TARRAY2_GET(lvl1->fobjArr, i1) : NULL;





×








UNCOV

134



    STFileObj *fobj2 = i2 < TARRAY2_SIZE(lvl2->fobjArr) ? TARRAY2_GET(lvl2->fobjArr, i2) : NULL;





×







135













UNCOV

136



    if (fobj1 && fobj2) {





×








UNCOV

137



      if (fobj1->f->cid < fobj2->f->cid) {





×







138



        // create a file obj










139



        code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj2);




×







140



        if (code) return code;





×







141



        code = TARRAY2_INSERT_PTR(lvl2->fobjArr, i2, &fobj2);





×







142



        if (code) return code;





×







143



        i1++;




×







144



        i2++;




×








UNCOV

145



      } else if (fobj1->f->cid > fobj2->f->cid) {





×







146



        // remove a file obj











UNCOV

147



        TARRAY2_REMOVE(lvl2->fobjArr, i2, tsdbSttLvlRemoveFObj);





×







148



      } else {











UNCOV

149



        if (tsdbIsSameTFile(fobj1->f, fobj2->f)) {





×








UNCOV

150



          if (tsdbIsTFileChanged(fobj1->f, fobj2->f)) {





×







151



            fobj2->f[0] = fobj1->f[0];




×







152



          }










153



        } else {











UNCOV

154



          TARRAY2_REMOVE(lvl2->fobjArr, i2, tsdbSttLvlRemoveFObj);





×








UNCOV

155



          code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj2);




×








UNCOV

156



          if (code) return code;





×








UNCOV

157



          code = TARRAY2_SORT_INSERT(lvl2->fobjArr, fobj2, tsdbTFileObjCmpr);




×








UNCOV

158



          if (code) return code;





×







159



        }











UNCOV

160



        i1++;




×








UNCOV

161



        i2++;




×







162



      }











UNCOV

163



    } else if (fobj1) {





×







164



      // create a file obj











UNCOV

165



      code = tsdbTFileObjInit(pTsdb, fobj1->f, &fobj2);




×








UNCOV

166



      if (code) return code;





×








UNCOV

167



      code = TARRAY2_INSERT_PTR(lvl2->fobjArr, i2, &fobj2);





×








UNCOV

168



      if (code) return code;





×








UNCOV

169



      i1++;




×








UNCOV

170



      i2++;




×







171



    } else {










172



      // remove a file obj










173



      TARRAY2_REMOVE(lvl2->fobjArr, i2, tsdbSttLvlRemoveFObj);





×







174



    }










175



  }











UNCOV

176



  return 0;




×







177



}










178













UNCOV

179



static int32_t tsdbSttLvlCmprFn(const SSttLvl **lvl1, const SSttLvl **lvl2) {




×








UNCOV

180



  if (lvl1[0]->level < lvl2[0]->level) return -1;





×








UNCOV

181



  if (lvl1[0]->level > lvl2[0]->level) return 1;





×








UNCOV

182



  return 0;




×







183



}










184













UNCOV

185



static int32_t tsdbSttLvlToJson(const SSttLvl *lvl, cJSON *json) {




×








UNCOV

186



  if (cJSON_AddNumberToObject(json, "level", lvl->level) == NULL) {





×







187



    return TSDB_CODE_OUT_OF_MEMORY;




×







188



  }










189













UNCOV

190



  cJSON *ajson = cJSON_AddArrayToObject(json, "files");




×








UNCOV

191



  if (ajson == NULL) return TSDB_CODE_OUT_OF_MEMORY;





×







192



  const STFileObj *fobj;











UNCOV

193



  TARRAY2_FOREACH(lvl->fobjArr, fobj) {





×








UNCOV

194



    cJSON *item = cJSON_CreateObject();




×








UNCOV

195



    if (item == NULL) return TSDB_CODE_OUT_OF_MEMORY;





×








UNCOV

196



    (void)cJSON_AddItemToArray(ajson, item);




×







197













UNCOV

198



    int32_t code = tsdbTFileToJson(fobj->f, item);




×








UNCOV

199



    if (code) return code;





×







200



  }










201













UNCOV

202



  return 0;




×







203



}










204













UNCOV

205



static int32_t tsdbJsonToSttLvl(STsdb *pTsdb, const cJSON *json, SSttLvl **lvl) {




×







206



  const cJSON *item1, *item2;










207



  int32_t      level;










208













UNCOV

209



  item1 = cJSON_GetObjectItem(json, "level");




×








UNCOV

210



  if (cJSON_IsNumber(item1)) {





×








UNCOV

211



    level = item1->valuedouble;




×







212



  } else {










213



    return TSDB_CODE_FILE_CORRUPTED;




×







214



  }










215













UNCOV

216



  int32_t code = tsdbSttLvlInit(level, lvl);




×








UNCOV

217



  if (code) return code;





×







218













UNCOV

219



  item1 = cJSON_GetObjectItem(json, "files");




×








UNCOV

220



  if (!cJSON_IsArray(item1)) {





×







221



    tsdbSttLvlClear(lvl);




×







222



    return TSDB_CODE_FILE_CORRUPTED;




×







223



  }










224













UNCOV

225



  cJSON_ArrayForEach(item2, item1) {





×







226



    STFile tf;











UNCOV

227



    code = tsdbJsonToTFile(item2, TSDB_FTYPE_STT, &tf);




×








UNCOV

228



    if (code) {





×







229



      tsdbSttLvlClear(lvl);




×







230



      return code;




×







231



    }










232












233



    STFileObj *fobj;











UNCOV

234



    code = tsdbTFileObjInit(pTsdb, &tf, &fobj);




×








UNCOV

235



    if (code) {





×







236



      tsdbSttLvlClear(lvl);




×







237



      return code;




×







238



    }










239













UNCOV

240



    code = TARRAY2_APPEND(lvl[0]->fobjArr, fobj);





×








UNCOV

241



    if (code) return code;





×







242



  }











UNCOV

243



  TARRAY2_SORT(lvl[0]->fobjArr, tsdbTFileObjCmpr);





×








UNCOV

244



  return 0;




×







245



}










246













UNCOV

247



int32_t tsdbTFileSetToJson(const STFileSet *fset, cJSON *json) {




×








UNCOV

248



  int32_t code = 0;




×







249



  cJSON  *item1, *item2;










250












251



  // fid











UNCOV

252



  if (cJSON_AddNumberToObject(json, "fid", fset->fid) == NULL) {





×







253



    return TSDB_CODE_OUT_OF_MEMORY;




×







254



  }










255













UNCOV

256



  for (int32_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×








UNCOV

257



    if (fset->farr[ftype] == NULL) continue;





×







258













UNCOV

259



    code = tsdbTFileToJson(fset->farr[ftype]->f, json);




×








UNCOV

260



    if (code) return code;





×







261



  }










262












263



  // each level











UNCOV

264



  item1 = cJSON_AddArrayToObject(json, "stt lvl");




×








UNCOV

265



  if (item1 == NULL) return TSDB_CODE_OUT_OF_MEMORY;





×







266



  const SSttLvl *lvl;











UNCOV

267



  TARRAY2_FOREACH(fset->lvlArr, lvl) {





×








UNCOV

268



    item2 = cJSON_CreateObject();




×








UNCOV

269



    if (!item2) return TSDB_CODE_OUT_OF_MEMORY;





×








UNCOV

270



    (void)cJSON_AddItemToArray(item1, item2);




×







271













UNCOV

272



    code = tsdbSttLvlToJson(lvl, item2);




×








UNCOV

273



    if (code) return code;





×







274



  }










275












276



  // about compact and commit











UNCOV

277



  if (cJSON_AddNumberToObject(json, "last compact", fset->lastCompact) == NULL) {





×







278



    return TSDB_CODE_OUT_OF_MEMORY;




×







279



  }










280













UNCOV

281



  if (cJSON_AddNumberToObject(json, "last commit", fset->lastCommit) == NULL) {





×







282



    return TSDB_CODE_OUT_OF_MEMORY;




×







283



  }










284













UNCOV

285



  return 0;




×







286



}










287













UNCOV

288



int32_t tsdbJsonToTFileSet(STsdb *pTsdb, const cJSON *json, STFileSet **fset) {




×







289



  int32_t      code;










290



  const cJSON *item1, *item2;










291



  int32_t      fid;










292



  STFile       tf;










293












294



  // fid











UNCOV

295



  item1 = cJSON_GetObjectItem(json, "fid");




×








UNCOV

296



  if (cJSON_IsNumber(item1)) {





×








UNCOV

297



    fid = item1->valuedouble;




×







298



  } else {










299



    return TSDB_CODE_FILE_CORRUPTED;




×







300



  }










301













UNCOV

302



  code = tsdbTFileSetInit(fid, fset);




×








UNCOV

303



  if (code) return code;





×







304













UNCOV

305



  for (tsdb_ftype_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×








UNCOV

306



    code = tsdbJsonToTFile(json, ftype, &tf);




×








UNCOV

307



    if (code == TSDB_CODE_NOT_FOUND) {





×








UNCOV

308



      continue;




×








UNCOV

309



    } else if (code) {





×







310



      tsdbTFileSetClear(fset);




×







311



      return code;




×







312



    } else {











UNCOV

313



      code = tsdbTFileObjInit(pTsdb, &tf, &(*fset)->farr[ftype]);




×








UNCOV

314



      if (code) return code;





×







315



    }










316



  }










317












318



  // each level











UNCOV

319



  item1 = cJSON_GetObjectItem(json, "stt lvl");




×








UNCOV

320



  if (cJSON_IsArray(item1)) {





×








UNCOV

321



    cJSON_ArrayForEach(item2, item1) {





×







322



      SSttLvl *lvl;











UNCOV

323



      code = tsdbJsonToSttLvl(pTsdb, item2, &lvl);




×








UNCOV

324



      if (code) {





×







325



        tsdbTFileSetClear(fset);




×







326



        return code;




×







327



      }










328













UNCOV

329



      code = TARRAY2_APPEND((*fset)->lvlArr, lvl);





×








UNCOV

330



      if (code) return code;





×







331



    }











UNCOV

332



    TARRAY2_SORT((*fset)->lvlArr, tsdbSttLvlCmprFn);





×







333



  } else {










334



    return TSDB_CODE_FILE_CORRUPTED;




×







335



  }










336



  // about compact and commit











UNCOV

337



  item1 = cJSON_GetObjectItem(json, "last compact");




×








UNCOV

338



  if (cJSON_IsNumber(item1)) {





×








UNCOV

339



    (*fset)->lastCompact = item1->valuedouble;




×







340



  } else {










341



    (*fset)->lastCompact = 0;




×







342



  }










343













UNCOV

344



  item1 = cJSON_GetObjectItem(json, "last commit");




×








UNCOV

345



  if (cJSON_IsNumber(item1)) {





×








UNCOV

346



    (*fset)->lastCommit = item1->valuedouble;




×







347



  } else {










348



    (*fset)->lastCommit = 0;




×







349



  }










350













UNCOV

351



  return 0;




×







352



}










353












354



// NOTE: the api does not remove file, only do memory operation











UNCOV

355



int32_t tsdbTFileSetEdit(STsdb *pTsdb, STFileSet *fset, const STFileOp *op) {




×








UNCOV

356



  int32_t code = 0;




×







357













UNCOV

358



  if (op->optype == TSDB_FOP_CREATE) {





×







359



    // create a new file










360



    STFileObj *fobj;











UNCOV

361



    code = tsdbTFileObjInit(pTsdb, &op->nf, &fobj);




×








UNCOV

362



    if (code) return code;





×







363













UNCOV

364



    if (fobj->f->type == TSDB_FTYPE_STT) {





×








UNCOV

365



      SSttLvl *lvl = tsdbTFileSetGetSttLvl(fset, fobj->f->stt->level);




×








UNCOV

366



      if (!lvl) {





×








UNCOV

367



        code = tsdbSttLvlInit(fobj->f->stt->level, &lvl);




×








UNCOV

368



        if (code) return code;





×







369













UNCOV

370



        code = TARRAY2_SORT_INSERT(fset->lvlArr, lvl, tsdbSttLvlCmprFn);




×








UNCOV

371



        if (code) return code;





×







372



      }










373













UNCOV

374



      code = TARRAY2_SORT_INSERT(lvl->fobjArr, fobj, tsdbTFileObjCmpr);




×








UNCOV

375



      if (code) return code;





×







376



    } else {











UNCOV

377



      fset->farr[fobj->f->type] = fobj;




×







378



    }











UNCOV

379



  } else if (op->optype == TSDB_FOP_REMOVE) {





×







380



    // delete a file











UNCOV

381



    if (op->of.type == TSDB_FTYPE_STT) {





×








UNCOV

382



      SSttLvl *lvl = tsdbTFileSetGetSttLvl(fset, op->of.stt->level);




×







383













UNCOV

384



      STFileObj  tfobj = {.f[0] = {.cid = op->of.cid}};




×








UNCOV

385



      STFileObj *tfobjp = &tfobj;




×








UNCOV

386



      int32_t    idx = TARRAY2_SEARCH_IDX(lvl->fobjArr, &tfobjp, tsdbTFileObjCmpr, TD_EQ);




×








UNCOV

387



      TARRAY2_REMOVE(lvl->fobjArr, idx, tsdbSttLvlClearFObj);





×







388



    } else {











UNCOV

389



      code = tsdbTFileObjUnref(fset->farr[op->of.type]);




×








UNCOV

390



      if (code) return code;





×








UNCOV

391



      fset->farr[op->of.type] = NULL;




×







392



    }










393



  } else {











UNCOV

394



    if (op->nf.type == TSDB_FTYPE_STT) {





×







395



      SSttLvl *lvl = tsdbTFileSetGetSttLvl(fset, op->of.stt->level);




×







396












397



      STFileObj   tfobj = {.f[0] = {.cid = op->of.cid}}, *tfobjp = &tfobj;




×







398



      STFileObj **fobjPtr = TARRAY2_SEARCH(lvl->fobjArr, &tfobjp, tsdbTFileObjCmpr, TD_EQ);




×







399



      if (fobjPtr) {





×







400



        tfobjp = *fobjPtr;




×







401



        tfobjp->f[0] = op->nf;




×







402



      } else {










403



        tsdbError("file not found, cid:%" PRId64, op->of.cid);





×







404



      }










405



    } else {











UNCOV

406



      fset->farr[op->nf.type]->f[0] = op->nf;




×







407



    }










408



  }










409













UNCOV

410



  return 0;




×







411



}










412













UNCOV

413



int32_t tsdbTFileSetApplyEdit(STsdb *pTsdb, const STFileSet *fset1, STFileSet *fset2) {




×








UNCOV

414



  int32_t code = 0;




×







415













UNCOV

416



  if (fset1->fid != fset2->fid) {





×







417



    return TSDB_CODE_INVALID_PARA;




×







418



  }










419













UNCOV

420



  for (tsdb_ftype_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×








UNCOV

421



    if (!fset1->farr[ftype] && !fset2->farr[ftype]) continue;





×







422













UNCOV

423



    STFileObj *fobj1 = fset1->farr[ftype];




×








UNCOV

424



    STFileObj *fobj2 = fset2->farr[ftype];




×







425













UNCOV

426



    if (fobj1 && fobj2) {





×








UNCOV

427



      if (tsdbIsSameTFile(fobj1->f, fobj2->f)) {





×








UNCOV

428



        if (tsdbIsTFileChanged(fobj1->f, fobj2->f)) {





×








UNCOV

429



          fobj2->f[0] = fobj1->f[0];




×







430



        }










431



      } else {











UNCOV

432



        if (fobj1->f->cid != fobj2->f->cid) {





×








UNCOV

433



          code = tsdbTFileObjRemove(fobj2);




×








UNCOV

434



          if (code) return code;





×







435



        } else {











UNCOV

436



          code = tsdbTFileObjRemoveUpdateLC(fobj2);




×








UNCOV

437



          if (code) return code;





×







438



        }











UNCOV

439



        code = tsdbTFileObjInit(pTsdb, fobj1->f, &fset2->farr[ftype]);




×








UNCOV

440



        if (code) return code;





×







441



      }











UNCOV

442



    } else if (fobj1) {





×







443



      // create a new file











UNCOV

444



      code = tsdbTFileObjInit(pTsdb, fobj1->f, &fset2->farr[ftype]);




×








UNCOV

445



      if (code) return code;





×







446



    } else {










447



      // remove the file










448



      code = tsdbTFileObjRemove(fobj2);




×







449



      if (code) return code;





×







450



      fset2->farr[ftype] = NULL;




×







451



    }










452



  }










453












454



  // stt part











UNCOV

455



  int32_t i1 = 0, i2 = 0;




×








UNCOV

456



  while (i1 < TARRAY2_SIZE(fset1->lvlArr) || i2 < TARRAY2_SIZE(fset2->lvlArr)) {





×








UNCOV

457



    SSttLvl *lvl1 = i1 < TARRAY2_SIZE(fset1->lvlArr) ? TARRAY2_GET(fset1->lvlArr, i1) : NULL;





×








UNCOV

458



    SSttLvl *lvl2 = i2 < TARRAY2_SIZE(fset2->lvlArr) ? TARRAY2_GET(fset2->lvlArr, i2) : NULL;





×







459













UNCOV

460



    if (lvl1 && lvl2) {





×








UNCOV

461



      if (lvl1->level < lvl2->level) {





×







462



        // add a new stt level











UNCOV

463



        code = tsdbSttLvlInitEx(pTsdb, lvl1, &lvl2);




×








UNCOV

464



        if (code) return code;





×








UNCOV

465



        code = TARRAY2_SORT_INSERT(fset2->lvlArr, lvl2, tsdbSttLvlCmprFn);




×








UNCOV

466



        if (code) return code;





×








UNCOV

467



        i1++;




×








UNCOV

468



        i2++;




×








UNCOV

469



      } else if (lvl1->level > lvl2->level) {





×







470



        // remove the stt level











UNCOV

471



        TARRAY2_REMOVE(fset2->lvlArr, i2, tsdbSttLvlRemove);





×







472



      } else {










473



        // apply edit on stt level











UNCOV

474



        code = tsdbSttLvlApplyEdit(pTsdb, lvl1, lvl2);




×








UNCOV

475



        if (code) return code;





×








UNCOV

476



        i1++;




×








UNCOV

477



        i2++;




×







478



      }











UNCOV

479



    } else if (lvl1) {





×







480



      // add a new stt level











UNCOV

481



      code = tsdbSttLvlInitEx(pTsdb, lvl1, &lvl2);




×








UNCOV

482



      if (code) return code;





×








UNCOV

483



      code = TARRAY2_SORT_INSERT(fset2->lvlArr, lvl2, tsdbSttLvlCmprFn);




×








UNCOV

484



      if (code) return code;





×








UNCOV

485



      i1++;




×








UNCOV

486



      i2++;




×







487



    } else {










488



      // remove the stt level











UNCOV

489



      TARRAY2_REMOVE(fset2->lvlArr, i2, tsdbSttLvlRemove);





×







490



    }










491



  }










492













UNCOV

493



  fset2->lastCompact = fset1->lastCompact;




×








UNCOV

494



  fset2->lastCommit = fset1->lastCommit;




×







495













UNCOV

496



  return 0;




×







497



}










498













UNCOV

499



int32_t tsdbTFileSetInit(int32_t fid, STFileSet **fset) {




×








UNCOV

500



  fset[0] = taosMemoryCalloc(1, sizeof(STFileSet));





×








UNCOV

501



  if (fset[0] == NULL) {





×







502



    return terrno;




×







503



  }










504













UNCOV

505



  fset[0]->fid = fid;




×








UNCOV

506



  fset[0]->maxVerValid = VERSION_MAX;




×








UNCOV

507



  TARRAY2_INIT(fset[0]->lvlArr);




×







508












509



  // block commit variables











UNCOV

510



  (void)taosThreadCondInit(&fset[0]->canCommit, NULL);




×








UNCOV

511



  (*fset)->numWaitCommit = 0;




×








UNCOV

512



  (*fset)->blockCommit = false;




×







513













UNCOV

514



  for (int32_t i = 0; i < sizeof((*fset)->conds) / sizeof((*fset)->conds[0]); ++i) {





×








UNCOV

515



    struct STFileSetCond *cond = &(*fset)->conds[i];




×








UNCOV

516



    cond->running = false;




×








UNCOV

517



    cond->numWait = 0;




×








UNCOV

518



    (void)taosThreadCondInit(&cond->cond, NULL);




×







519



  }










520













UNCOV

521



  return 0;




×







522



}










523













UNCOV

524



int32_t tsdbTFileSetInitCopy(STsdb *pTsdb, const STFileSet *fset1, STFileSet **fset) {




×








UNCOV

525



  int32_t code = tsdbTFileSetInit(fset1->fid, fset);




×








UNCOV

526



  if (code) return code;





×







527













UNCOV

528



  for (int32_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×








UNCOV

529



    if (fset1->farr[ftype] == NULL) continue;





×







530













UNCOV

531



    code = tsdbTFileObjInit(pTsdb, fset1->farr[ftype]->f, &fset[0]->farr[ftype]);




×








UNCOV

532



    if (code) {





×







533



      tsdbTFileSetClear(fset);




×







534



      return code;




×







535



    }










536



  }










537












538



  const SSttLvl *lvl1;











UNCOV

539



  TARRAY2_FOREACH(fset1->lvlArr, lvl1) {





×







540



    SSttLvl *lvl;











UNCOV

541



    code = tsdbSttLvlInitEx(pTsdb, lvl1, &lvl);




×








UNCOV

542



    if (code) {





×








UNCOV

543



      tsdbTFileSetClear(fset);




×







544



      return code;




×







545



    }










546













UNCOV

547



    code = TARRAY2_APPEND(fset[0]->lvlArr, lvl);





×








UNCOV

548



    if (code) return code;





×







549



  }










550













UNCOV

551



  (*fset)->lastCompact = fset1->lastCompact;




×








UNCOV

552



  (*fset)->lastCommit = fset1->lastCommit;




×







553













UNCOV

554



  return 0;




×







555



}










556












557



int32_t tsdbTFileSetFilteredInitDup(STsdb *pTsdb, const STFileSet *fset1, int64_t ever, STFileSet **fset,




×







558



                                    TFileOpArray *fopArr) {










559



  int32_t code = tsdbTFileSetInit(fset1->fid, fset);




×







560



  if (code) return code;





×







561












562



  for (int32_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×







563



    if (fset1->farr[ftype] == NULL) continue;





×







564



    STFileObj *fobj = fset1->farr[ftype];




×







565



    if (fobj->f->maxVer <= ever) {





×







566



      code = tsdbTFileObjInit(pTsdb, fobj->f, &fset[0]->farr[ftype]);




×







567



      if (code) {





×







568



        tsdbTFileSetClear(fset);




×







569



        return code;




×







570



      }










571



    } else {










572



      STFileOp op = {




×







573



          .optype = TSDB_FOP_REMOVE,










574



          .fid = fobj->f->fid,




×







575



          .of = fobj->f[0],










576



      };










577



      code = TARRAY2_APPEND(fopArr, op);





×







578



      if (code) return code;





×







579



    }










580



  }










581












582



  const SSttLvl *lvl1;










583



  TARRAY2_FOREACH(fset1->lvlArr, lvl1) {





×







584



    SSttLvl *lvl;










585



    code = tsdbSttLvlFilteredInitEx(pTsdb, lvl1, ever, &lvl, fopArr);




×







586



    if (code) {





×







587



      tsdbTFileSetClear(fset);




×







588



      return code;




×







589



    }










590












591



    code = TARRAY2_APPEND(fset[0]->lvlArr, lvl);





×







592



    if (code) return code;





×







593



  }










594












595



  return 0;




×







596



}










597












598



int32_t tsdbTFileSetRangeInitRef(STsdb *pTsdb, const STFileSet *fset1, int64_t sver, int64_t ever,




×







599



                                 STFileSetRange **fsr) {










600



  fsr[0] = taosMemoryCalloc(1, sizeof(*fsr[0]));





×







601



  if (fsr[0] == NULL) {





×







602



    return terrno;




×







603



  }










604



  fsr[0]->fid = fset1->fid;




×







605



  fsr[0]->sver = sver;




×







606



  fsr[0]->ever = ever;




×







607












608



  int32_t code = tsdbTFileSetInitRef(pTsdb, fset1, &fsr[0]->fset);




×







609



  if (code) {





×







610



    taosMemoryFree(fsr[0]);





×







611



    fsr[0] = NULL;




×







612



  }










613



  return code;




×







614



}










615













UNCOV

616



int32_t tsdbTFileSetInitRef(STsdb *pTsdb, const STFileSet *fset1, STFileSet **fset) {




×








UNCOV

617



  int32_t code = tsdbTFileSetInit(fset1->fid, fset);




×








UNCOV

618



  if (code) return code;





×







619













UNCOV

620



  for (int32_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×








UNCOV

621



    if (fset1->farr[ftype] == NULL) continue;





×







622













UNCOV

623



    code = tsdbTFileObjRef(fset1->farr[ftype]);




×








UNCOV

624



    if (code) {





×







625



      tsdbTFileSetClear(fset);




×







626



      return code;




×







627



    }











UNCOV

628



    fset[0]->farr[ftype] = fset1->farr[ftype];




×







629



  }










630












631



  const SSttLvl *lvl1;











UNCOV

632



  TARRAY2_FOREACH(fset1->lvlArr, lvl1) {





×







633



    SSttLvl *lvl;











UNCOV

634



    code = tsdbSttLvlInitRef(pTsdb, lvl1, &lvl);




×








UNCOV

635



    if (code) {





×







636



      tsdbSttLvlClear(&lvl);




×







637



      tsdbTFileSetClear(fset);




×







638



      return code;




×







639



    }










640













UNCOV

641



    code = TARRAY2_APPEND(fset[0]->lvlArr, lvl);





×








UNCOV

642



    if (code) {





×







643



      tsdbSttLvlClear(&lvl);




×







644



      tsdbTFileSetClear(fset);




×







645



      return code;




×







646



    }










647



  }










648













UNCOV

649



  (*fset)->lastCompact = fset1->lastCompact;




×








UNCOV

650



  (*fset)->lastCommit = fset1->lastCommit;




×







651













UNCOV

652



  return 0;




×







653



}










654












655



void tsdbTFileSetRangeClear(STFileSetRange **fsr) {




×







656



  if (!fsr[0]) return;





×







657












658



  tsdbTFileSetClear(&fsr[0]->fset);




×







659



  taosMemoryFree(fsr[0]);





×







660



  fsr[0] = NULL;




×







661



  return;




×







662



}










663













UNCOV

664



void tsdbTFileSetRangeArrayDestroy(TFileSetRangeArray **ppArr) {




×








UNCOV

665



  if (ppArr && ppArr[0]) {





×








UNCOV

666



    TARRAY2_DESTROY(ppArr[0], tsdbTFileSetRangeClear);





×








UNCOV

667



    taosMemoryFree(ppArr[0]);





×








UNCOV

668



    ppArr[0] = NULL;




×







669



  }











UNCOV

670



}




×







671













UNCOV

672



void tsdbTFileSetClear(STFileSet **fset) {




×








UNCOV

673



  if (fset && *fset) {





×








UNCOV

674



    for (tsdb_ftype_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×








UNCOV

675



      if ((*fset)->farr[ftype] == NULL) continue;





×








UNCOV

676



      int32_t code = tsdbTFileObjUnref((*fset)->farr[ftype]);




×








UNCOV

677



      if (code) {





×







678



        tsdbError("failed to unref file, fid:%d, ftype:%d", (*fset)->fid, ftype);





×







679



      }











UNCOV

680



      (*fset)->farr[ftype] = NULL;




×







681



    }










682













UNCOV

683



    TARRAY2_DESTROY((*fset)->lvlArr, tsdbSttLvlClear);





×







684













UNCOV

685



    (void)taosThreadCondDestroy(&(*fset)->canCommit);




×








UNCOV

686



    for (int32_t i = 0; i < sizeof((*fset)->conds) / sizeof((*fset)->conds[0]); ++i) {





×








UNCOV

687



      (void)taosThreadCondDestroy(&(*fset)->conds[i].cond);




×







688



    }











UNCOV

689



    taosMemoryFreeClear(*fset);





×







690



  }











UNCOV

691



}




×







692












693



void tsdbTFileSetRemove(STFileSet *fset) {




×







694



  if (fset == NULL) return;





×







695












696



  for (tsdb_ftype_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×







697



    if (fset->farr[ftype] != NULL) {





×







698



      int32_t code = tsdbTFileObjRemove(fset->farr[ftype]);




×







699



      if (code) {





×







700



        tsdbError("failed to remove file, fid:%d, ftype:%d", fset->fid, ftype);





×







701



      }










702



      fset->farr[ftype] = NULL;




×







703



    }










704



  }










705












706



  TARRAY2_DESTROY(fset->lvlArr, tsdbSttLvlRemove);





×







707



}










708













UNCOV

709



SSttLvl *tsdbTFileSetGetSttLvl(STFileSet *fset, int32_t level) {




×








UNCOV

710



  SSttLvl   sttLvl = {.level = level};




×








UNCOV

711



  SSttLvl  *lvl = &sttLvl;




×








UNCOV

712



  SSttLvl **lvlPtr = TARRAY2_SEARCH(fset->lvlArr, &lvl, tsdbSttLvlCmprFn, TD_EQ);




×








UNCOV

713



  return lvlPtr ? lvlPtr[0] : NULL;





×







714



}










715













UNCOV

716



int32_t tsdbTFileSetCmprFn(const STFileSet **fset1, const STFileSet **fset2) {




×








UNCOV

717



  if (fset1[0]->fid < fset2[0]->fid) return -1;





×








UNCOV

718



  if (fset1[0]->fid > fset2[0]->fid) return 1;





×








UNCOV

719



  return 0;




×







720



}










721













UNCOV

722



int64_t tsdbTFileSetMaxCid(const STFileSet *fset) {




×








UNCOV

723



  int64_t maxCid = 0;




×








UNCOV

724



  for (tsdb_ftype_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×








UNCOV

725



    if (fset->farr[ftype] == NULL) continue;





×








UNCOV

726



    maxCid = TMAX(maxCid, fset->farr[ftype]->f->cid);




×







727



  }










728



  const SSttLvl   *lvl;










729



  const STFileObj *fobj;











UNCOV

730



  TARRAY2_FOREACH(fset->lvlArr, lvl) {





×








UNCOV

731



    TARRAY2_FOREACH(lvl->fobjArr, fobj) { maxCid = TMAX(maxCid, fobj->f->cid); }





×







732



  }











UNCOV

733



  return maxCid;




×







734



}










735













UNCOV

736



bool tsdbTFileSetIsEmpty(const STFileSet *fset) {




×








UNCOV

737



  for (tsdb_ftype_t ftype = TSDB_FTYPE_MIN; ftype < TSDB_FTYPE_MAX; ++ftype) {





×








UNCOV

738



    if (fset->farr[ftype] != NULL) return false;





×







739



  }











UNCOV

740



  return TARRAY2_SIZE(fset->lvlArr) == 0;




×







741



}
























    

  • 

    •