Recached

taosdata / TDengine / #5012

coverage: 72.305% (+0.005%) from 72.3%
#5012

push

travis-ci

web-flow 
merge: from main to 3.0 branch #35067

4053 of 5985 new or added lines in 68 files covered. (67.72%)

13105 existing lines in 173 files now uncovered.

257446 of 356056 relevant lines covered (72.3%)

131779375.07 hits per line

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

81.72
/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












19



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




497,123,237✔





20



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




497,123,237✔





21



    return terrno;




×







22



  }










23



  lvl[0]->level = level;




497,040,480✔





24



  TARRAY2_INIT(lvl[0]->fobjArr);




497,059,513✔





25



  return 0;




497,029,077✔





26



}










27












28



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




499,951,836✔





29












30



void tsdbSttLvlClear(SSttLvl **lvl) {




495,645,717✔





31



  if (lvl[0] != NULL) {




495,645,717✔





32



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




992,579,644✔





33



    taosMemoryFree(lvl[0]);




495,632,144✔





34



    lvl[0] = NULL;




495,661,718✔





35



  }










36



}




495,638,167✔





37












38



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




31,096,269✔





39



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




31,096,269✔





40



  if (code) return code;




31,096,269✔





41












42



  const STFileObj *fobj1;










43



  TARRAY2_FOREACH(lvl1->fobjArr, fobj1) {




64,726,656✔





44



    STFileObj *fobj;




33,629,682✔





45



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




33,630,387✔





46



    if (code) {




33,630,387✔





47



      tsdbSttLvlClear(lvl);




×







48



      return code;




×







49



    }










50












51



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




33,630,387✔





52



    if (code) {




33,630,279✔





53



      tsdbSttLvlClear(lvl);




×







54



      (void)taosThreadMutexDestroy(&fobj->mutex);




×







55



      taosMemoryFree(fobj);




×







56



      return code;




×







57



    }










58



  }










59



  return 0;




31,097,254✔





60



}










61












62



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




447,959,403✔





63



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




447,959,403✔





64



  if (code) return code;




447,854,730✔





65












66



  STFileObj *fobj1;




447,711,122✔





67



  TARRAY2_FOREACH(lvl1->fobjArr, fobj1) {




896,060,583✔





68



    code = tsdbTFileObjRef(fobj1);




448,178,283✔





69



    if (code) {




448,130,499✔






UNCOV

70



      tsdbSttLvlClear(lvl);




×







71



      return code;




×







72



    }










73



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




448,130,499✔





74



    if (code) {




448,129,334✔





75



      if (tsdbTFileObjUnref(fobj1) != 0) {




×







76



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




×







77



      }










78



      tsdbSttLvlClear(lvl);




×







79



      return code;




×







80



    }










81



  }










82



  return 0;




447,918,498✔





83



}










84












85



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




1,750✔





86



                                        TFileOpArray *fopArr) {










87



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




1,750✔





88



  if (code) return code;




1,750✔





89












90



  const STFileObj *fobj1;










91



  TARRAY2_FOREACH(lvl1->fobjArr, fobj1) {




3,500✔





92



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




1,750✔





93



      STFileObj *fobj;




1,750✔





94



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




1,750✔





95



      if (code) {




1,750✔





96



        tsdbSttLvlClear(lvl);




×







97



        return code;




×







98



      }










99












100



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




3,500✔





101



    } else {










102



      STFileOp op = {




×







103



          .optype = TSDB_FOP_REMOVE,










104



          .fid = fobj1->f->fid,




×







105



          .of = fobj1->f[0],










106



      };










107



      TAOS_CHECK_RETURN(TARRAY2_APPEND(fopArr, op));




×







108



    }










109



  }










110



  return 0;




1,750✔





111



}










112












113



static void tsdbSttLvlRemoveFObj(void *data) {




3,008,529✔





114



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




3,008,529✔





115



  if (code) {




3,008,529✔





116



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




×







117



  }










118



}




3,008,529✔





119



static void tsdbSttLvlRemove(SSttLvl **lvl) {




1,484,801✔





120



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




3,979,152✔





121



  taosMemoryFree(lvl[0]);




1,484,801✔





122



  lvl[0] = NULL;




1,484,801✔





123



}




1,484,801✔





124












125



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




5,712,811✔





126



  int32_t code = 0;




5,712,811✔





127












128



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




5,712,811✔





129



    return TSDB_CODE_INVALID_PARA;




×







130



  }










131












132



  int32_t i1 = 0, i2 = 0;




5,712,811✔





133



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




13,290,102✔





134



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




7,576,709✔





135



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




7,577,291✔





136












137



    if (fobj1 && fobj2) {




7,577,291✔





138



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




6,069,608✔





139



        // create a file obj










140



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




×







141



        if (code) return code;




×







142



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




×







143



        if (code) return code;




×







144



        i1++;




×







145



        i2++;




×







146



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




6,069,608✔





147



        // remove a file obj










148



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




496,945✔





149



      } else {










150



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




5,572,663✔





151



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




5,555,430✔





152



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




×







153



          }










154



        } else {










155



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




17,233✔





156



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




17,233✔





157



          if (code) return code;




17,233✔





158



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




17,233✔





159



          if (code) return code;




17,233✔





160



        }










161



        i1++;




5,572,663✔





162



        i2++;




5,572,663✔





163



      }










164



    } else if (fobj1) {




1,507,683✔





165



      // create a file obj










166



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




1,507,683✔





167



      if (code) return code;




1,507,683✔





168



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




1,507,683✔





169



      if (code) return code;




1,507,683✔





170



      i1++;




1,507,683✔





171



      i2++;




1,507,683✔





172



    } else {










173



      // remove a file obj










174



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




×







175



    }










176



  }










177



  return 0;




5,712,811✔





178



}










179












180



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




11,300,385✔





181



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




11,300,385✔





182



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




6,396,796✔





183



  return 0;




4,536,802✔





184



}










185












186



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




23,012,903✔





187



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




23,012,903✔





188



    return TSDB_CODE_OUT_OF_MEMORY;




×







189



  }










190












191



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




23,015,574✔





192



  if (ajson == NULL) return TSDB_CODE_OUT_OF_MEMORY;




23,015,574✔





193



  const STFileObj *fobj;










194



  TARRAY2_FOREACH(lvl->fobjArr, fobj) {




47,401,187✔





195



    cJSON *item = cJSON_CreateObject();




24,384,425✔





196



    if (item == NULL) return TSDB_CODE_OUT_OF_MEMORY;




24,386,358✔





197



    (void)cJSON_AddItemToArray(ajson, item);




24,386,358✔





198












199



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




24,385,613✔





200



    if (code) return code;




24,385,613✔





201



  }










202












203



  return 0;




23,015,574✔





204



}










205












206



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




745,481✔





207



  const cJSON *item1, *item2;










208



  int32_t      level;










209












210



  item1 = cJSON_GetObjectItem(json, "level");




745,481✔





211



  if (cJSON_IsNumber(item1)) {




745,481✔





212



    level = item1->valuedouble;




745,481✔





213



  } else {










214



    return TSDB_CODE_FILE_CORRUPTED;




×







215



  }










216












217



  int32_t code = tsdbSttLvlInit(level, lvl);




745,481✔





218



  if (code) return code;




745,481✔





219












220



  item1 = cJSON_GetObjectItem(json, "files");




745,481✔





221



  if (!cJSON_IsArray(item1)) {




745,481✔





222



    tsdbSttLvlClear(lvl);




×







223



    return TSDB_CODE_FILE_CORRUPTED;




×







224



  }










225












226



  cJSON_ArrayForEach(item2, item1) {




1,521,141✔





227



    STFile tf;




775,214✔





228



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




776,135✔





229



    if (code) {




776,135✔





230



      tsdbSttLvlClear(lvl);




×







231



      return code;




×







232



    }










233












234



    STFileObj *fobj;




776,048✔





235



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




776,135✔





236



    if (code) {




776,135✔





237



      tsdbSttLvlClear(lvl);




×







238



      return code;




×







239



    }










240












241



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




776,135✔





242



    if (code) return code;




776,027✔





243



  }










244



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




744,971✔





245



  return 0;




745,373✔





246



}










247












248



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




21,025,874✔





249



  int32_t code = 0;




21,025,874✔





250



  cJSON  *item1, *item2;










251












252



  // fid










253



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




21,025,874✔





254



    return TSDB_CODE_OUT_OF_MEMORY;




×







255



  }










256












257



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




105,115,448✔





258



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




84,092,301✔





259












260



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




6,169,818✔





261



    if (code) return code;




6,168,699✔





262



  }










263












264



  // each level










265



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




21,023,147✔





266



  if (item1 == NULL) return TSDB_CODE_OUT_OF_MEMORY;




21,025,631✔





267



  const SSttLvl *lvl;










268



  TARRAY2_FOREACH(fset->lvlArr, lvl) {




44,040,383✔





269



    item2 = cJSON_CreateObject();




23,013,134✔





270



    if (!item2) return TSDB_CODE_OUT_OF_MEMORY;




23,015,574✔





271



    (void)cJSON_AddItemToArray(item1, item2);




23,015,574✔





272












273



    code = tsdbSttLvlToJson(lvl, item2);




23,014,967✔





274



    if (code) return code;




23,014,752✔





275



  }










276












277



  // about compact and commit










278



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




21,026,247✔





279



    return TSDB_CODE_OUT_OF_MEMORY;




×







280



  }










281












282



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




21,025,519✔





283



    return TSDB_CODE_OUT_OF_MEMORY;




×







284



  }










285












286



  if (cJSON_AddNumberToObject(json, "last migrate", fset->lastMigrate) == NULL) {




21,026,247✔





287



    return TSDB_CODE_OUT_OF_MEMORY;




×







288



  }










289












290



  if (cJSON_AddNumberToObject(json, "last rollup", fset->lastRollup) == NULL) {




21,026,247✔





291



    return TSDB_CODE_OUT_OF_MEMORY;




×







292



  }










293












294



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




21,025,502✔





295



    return TSDB_CODE_OUT_OF_MEMORY;




×







296



  }










297












298



  return 0;




21,024,964✔





299



}










300












301



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




750,285✔





302



  int32_t      code;










303



  const cJSON *item1, *item2;










304



  int32_t      fid;










305



  STFile       tf;




750,198✔





306












307



  // fid










308



  item1 = cJSON_GetObjectItem(json, "fid");




750,393✔





309



  if (cJSON_IsNumber(item1)) {




750,393✔





310



    fid = item1->valuedouble;




749,918✔





311



  } else {










312



    return TSDB_CODE_FILE_CORRUPTED;




×







313



  }










314












315



  code = tsdbTFileSetInit(fid, fset);




749,918✔





316



  if (code) return code;




750,285✔





317












318



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




3,751,239✔





319



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




3,000,228✔





320



    if (code == TSDB_CODE_NOT_FOUND) {




3,000,830✔





321



      continue;




2,407,974✔





322



    } else if (code) {




592,856✔





323



      tsdbTFileSetClear(fset);




×







324



      return code;




×







325



    } else {










326



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




592,856✔





327



      if (code) return code;




592,980✔





328



    }










329



  }










330












331



  // each level










332



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




751,011✔





333



  if (cJSON_IsArray(item1)) {




750,393✔





334



    cJSON_ArrayForEach(item2, item1) {




1,495,183✔





335



      SSttLvl *lvl;




745,394✔





336



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




745,481✔





337



      if (code) {




744,280✔





338



        tsdbTFileSetClear(fset);




×







339



        return code;




×







340



      }










341












342



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




744,280✔





343



      if (code) return code;




744,755✔





344



    }










345



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




749,918✔





346



  } else {










347



    return TSDB_CODE_FILE_CORRUPTED;




×







348



  }










349



  // about compact and commit










350



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




749,192✔





351



  if (cJSON_IsNumber(item1)) {




750,285✔





352



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




750,285✔





353



  } else {










354



    (*fset)->lastCompact = 0;




×







355



  }










356












357



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




749,192✔





358



  if (cJSON_IsNumber(item1)) {




750,285✔





359



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




750,285✔





360



  } else {










361



    (*fset)->lastCommit = 0;




×







362



  }










363












364



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




750,177✔





365



  if (cJSON_IsNumber(item1)) {




750,285✔





366



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




750,285✔





367



  } else {










368



    (*fset)->lastMigrate = 0;




×







369



  }










370












371



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




749,810✔





372



  if (cJSON_IsNumber(item1)) {




749,667✔





373



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




749,559✔





374



  } else {










375



    (*fset)->lastRollup = 0;




×







376



  }










377












378



  item1 = cJSON_GetObjectItem(json, "rlevel");




750,393✔





379



  if (cJSON_IsNumber(item1)) {




750,393✔





380



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




750,393✔





381



  } else {










382



    (*fset)->lastRollupLevel = 0;




×







383



  }










384












385



  return 0;




750,285✔





386



}










387












388



// NOTE: the api does not remove file (seems this is not true?), only do memory operation










389



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




24,667,690✔





390



  int32_t code = 0;




24,667,690✔





391












392



  if (op->optype == TSDB_FOP_CREATE) {




24,667,690✔





393



    // create a new file










394



    STFileObj *fobj;




20,634,650✔





395



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




20,634,738✔





396



    if (code) return code;




20,635,686✔





397












398



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




20,635,686✔





399



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




18,829,934✔





400



      if (!lvl) {




18,829,980✔





401



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




17,301,815✔





402



        if (code) return code;




17,302,390✔





403












404



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




17,302,390✔





405



        if (code) return code;




17,301,449✔





406



      }










407












408



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




18,829,614✔





409



      if (code) return code;




18,827,513✔





410



    } else {










411



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




1,804,758✔





412



    }










413



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




4,032,004✔





414



    // delete a file










415



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




3,508,098✔





416



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




3,008,637✔





417












418



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




3,008,637✔





419



      STFileObj *tfobjp = &tfobj;




3,008,637✔





420



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




3,008,637✔





421



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




3,008,637✔





422



    } else {










423



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




499,461✔





424



      if (code) return code;




499,461✔





425



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




499,461✔





426



    }










427



  } else {










428



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




523,906✔





429



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




×







430












431



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




×







432



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




×







433



      if (fobjPtr) {




×







434



        tfobjp = *fobjPtr;




×







435



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




×







436



      } else {










437



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




×







438



      }










439



    } else {










440



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




523,906✔





441



    }










442



  }










443












444



  return 0;




24,665,434✔





445



}










446












447



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




4,853,142✔





448



  int32_t code = 0;




4,853,142✔





449












450



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




4,853,142✔





451



    return TSDB_CODE_INVALID_PARA;




×







452



  }










453












454



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




24,265,710✔





455



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




19,412,568✔





456












457



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




5,172,030✔





458



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




5,172,030✔





459












460



    if (fobj1 && fobj2) {




5,172,030✔





461



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




4,851,412✔





462



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




4,359,653✔





463



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




522,368✔





464



        }










465



      } else {










466



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




491,759✔





467



          code = tsdbTFileObjRemove(fobj2);




434,841✔





468



          if (code) return code;




434,841✔





469



        } else {










470



          code = tsdbTFileObjRemoveUpdateLC(fobj2);




56,918✔





471



          if (code) return code;




56,918✔





472



        }










473



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




491,759✔





474



        if (code) return code;




491,759✔





475



      }










476



    } else if (fobj1) {




320,618✔





477



      // create a new file










478



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




318,434✔





479



      if (code) return code;




318,434✔





480



    } else {










481



      // remove the file










482



      code = tsdbTFileObjRemove(fobj2);




2,184✔





483



      if (code) return code;




2,184✔





484



      fset2->farr[ftype] = NULL;




2,184✔





485



    }










486



  }










487












488



  // stt part










489



  int32_t i1 = 0, i2 = 0;




4,853,142✔





490



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




13,442,776✔





491



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




8,589,634✔





492



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




8,589,634✔





493












494



    if (lvl1 && lvl2) {




8,589,634✔





495



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




8,125,276✔





496



        // add a new stt level










497



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




1,187,342✔





498



        if (code) return code;




1,187,342✔





499



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




1,187,342✔





500



        if (code) return code;




1,187,342✔





501



        i1++;




1,187,342✔





502



        i2++;




1,187,342✔





503



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




6,937,934✔





504



        // remove the stt level










505



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




1,225,123✔





506



      } else {










507



        // apply edit on stt level










508



        code = tsdbSttLvlApplyEdit(pTsdb, lvl1, lvl2);




5,712,811✔





509



        if (code) return code;




5,712,811✔





510



        i1++;




5,712,811✔





511



        i2++;




5,712,811✔





512



      }










513



    } else if (lvl1) {




464,358✔





514



      // add a new stt level










515



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




239,321✔





516



      if (code) return code;




239,321✔





517



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




239,321✔





518



      if (code) return code;




239,321✔





519



      i1++;




239,321✔





520



      i2++;




239,321✔





521



    } else {










522



      // remove the stt level










523



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




225,037✔





524



    }










525



  }










526












527



  fset2->lastCompact = fset1->lastCompact;




4,853,142✔





528



  fset2->lastCommit = fset1->lastCommit;




4,853,142✔





529



  fset2->lastMigrate = fset1->lastMigrate;




4,853,142✔





530



  fset2->lastRollup = fset1->lastRollup;




4,852,560✔





531



  fset2->lastRollupLevel = fset1->lastRollupLevel;




4,853,142✔





532












533



  return 0;




4,852,560✔





534



}










535












536



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




495,926,702✔





537



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




495,926,702✔





538



  if (fset[0] == NULL) {




495,638,696✔





539



    return terrno;




×







540



  }










541












542



  fset[0]->fid = fid;




495,660,004✔





543



  fset[0]->maxVerValid = VERSION_MAX;




495,705,118✔





544



  TARRAY2_INIT(fset[0]->lvlArr);




495,716,764✔





545












546



  // block commit variables










547



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




495,783,353✔





548



  (*fset)->numWaitCommit = 0;




495,845,394✔





549



  (*fset)->blockCommit = false;




495,905,490✔





550












551



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




1,487,216,327✔





552



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




991,425,703✔





553



    cond->running = false;




991,372,864✔





554



    cond->numWait = 0;




991,503,519✔





555



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




991,509,294✔





556



  }










557












558



  return 0;




495,790,624✔





559



}










560












561



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




25,445,875✔





562



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




25,445,875✔





563



  if (code) return code;




25,443,930✔





564












565



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




127,223,929✔





566



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




101,779,982✔





567












568



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




10,334,803✔





569



    if (code) {




10,335,898✔





570



      tsdbTFileSetClear(fset);




×







571



      return code;




×







572



    }










573



  }










574












575



  const SSttLvl *lvl1;










576



  TARRAY2_FOREACH(fset1->lvlArr, lvl1) {




55,114,383✔





577



    SSttLvl *lvl;




29,668,526✔





578



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




29,669,144✔





579



    if (code) {




29,670,087✔





580



      tsdbTFileSetClear(fset);




×







581



      return code;




×







582



    }










583












584



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




29,670,087✔





585



    if (code) {




29,670,203✔





586



      tsdbTFileSetClear(fset);




×







587



      return code;




×







588



    }










589



  }










590












591



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




25,446,089✔





592



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




25,446,197✔





593



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




25,445,471✔





594



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




25,445,471✔





595



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




25,446,089✔





596












597



  return 0;




25,445,238✔





598



}










599












600



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




1,053✔





601



                                    TFileOpArray *fopArr) {










602



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




1,053✔





603



  if (code) return code;




1,053✔





604












605



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




5,265✔





606



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




4,212✔





607



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




2,091✔





608



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




2,091✔





609



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




2,091✔





610



      if (code) {




2,091✔





611



        tsdbTFileSetClear(fset);




×







612



        return code;




×







613



      }










614



    } else {










615



      STFileOp op = {




×







616



          .optype = TSDB_FOP_REMOVE,










617



          .fid = fobj->f->fid,




×







618



          .of = fobj->f[0],










619



      };










620



      code = TARRAY2_APPEND(fopArr, op);




×







621



      if (code) return code;




×







622



    }










623



  }










624












625



  const SSttLvl *lvl1;










626



  TARRAY2_FOREACH(fset1->lvlArr, lvl1) {




2,803✔





627



    SSttLvl *lvl;




1,750✔





628



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




1,750✔





629



    if (code) {




1,750✔





630



      tsdbTFileSetClear(fset);




×







631



      return code;




×







632



    }










633












634



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




1,750✔





635



    if (code) return code;




1,750✔





636



  }










637












638



  return 0;




1,053✔





639



}










640












641



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




1,055✔





642



                                 STFileSetRange **fsr) {










643



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




1,055✔





644



  if (fsr[0] == NULL) {




1,055✔





645



    return terrno;




×







646



  }










647



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




1,055✔





648



  fsr[0]->sver = sver;




1,055✔





649



  fsr[0]->ever = ever;




1,055✔





650












651



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




1,055✔





652



  if (code) {




1,055✔





653



    taosMemoryFree(fsr[0]);




×







654



    fsr[0] = NULL;




×







655



  }










656



  return code;




1,055✔





657



}










658












659



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




453,487,527✔





660



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




453,487,527✔





661



  if (code) return code;




453,417,393✔





662












663



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




2,147,483,647✔





664



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




1,813,616,017✔





665












666



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




69,958,370✔





667



    if (code) {




70,022,807✔





668



      tsdbTFileSetClear(fset);




×







669



      return code;




×







670



    }










671



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




70,022,807✔





672



  }










673












674



  const SSttLvl *lvl1;










675



  TARRAY2_FOREACH(fset1->lvlArr, lvl1) {




901,362,140✔





676



    SSttLvl *lvl;




447,821,448✔





677



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




447,954,201✔





678



    if (code) {




447,909,374✔





679



      tsdbSttLvlClear(&lvl);




×







680



      tsdbTFileSetClear(fset);




×







681



      return code;




×







682



    }










683












684



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




447,909,374✔





685



    if (code) {




447,933,284✔





686



      tsdbSttLvlClear(&lvl);




×







687



      tsdbTFileSetClear(fset);




×







688



      return code;




×







689



    }










690



  }










691












692



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




453,509,877✔





693



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




453,536,464✔





694



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




453,474,695✔





695



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




453,537,817✔





696



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




453,531,525✔





697












698



  return 0;




453,556,522✔





699



}










700












701



void tsdbTFileSetRangeClear(STFileSetRange **fsr) {




3,163✔





702



  if (!fsr[0]) return;




3,163✔





703












704



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




3,163✔





705



  taosMemoryFree(fsr[0]);




3,163✔





706



  fsr[0] = NULL;




3,163✔





707



  return;




3,163✔





708



}










709












710



void tsdbTFileSetRangeArrayDestroy(TFileSetRangeArray **ppArr) {




184,157✔





711



  if (ppArr && ppArr[0]) {




184,157✔





712



    TARRAY2_DESTROY(ppArr[0], tsdbTFileSetRangeClear);




65,252✔





713



    taosMemoryFree(ppArr[0]);




62,089✔





714



    ppArr[0] = NULL;




62,089✔





715



  }










716



}




184,157✔





717












718



void tsdbTFileSetClear(STFileSet **fset) {




512,092,173✔





719



  if (fset && *fset) {




512,092,173✔





720



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




2,147,483,647✔





721



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




1,983,504,636✔





722



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




82,557,744✔





723



      if (code) {




82,582,574✔





724



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




×







725



      }










726



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




82,582,574✔





727



    }










728












729



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




990,084,508✔





730












731



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




495,952,434✔





732



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




1,487,854,406✔





733



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




991,868,484✔





734



    }










735



    taosMemoryFreeClear(*fset);




495,985,922✔





736



  }










737



}




512,078,523✔





738












739



void tsdbTFileSetRemove(STFileSet *fset) {




88,413✔





740



  if (fset == NULL) return;




88,413✔





741












742



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




442,065✔





743



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




353,652✔





744



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




7,056✔





745



      if (code) {




7,056✔





746



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




×







747



      }










748



      fset->farr[ftype] = NULL;




7,056✔





749



    }










750



  }










751












752



  TARRAY2_DESTROY(fset->lvlArr, tsdbSttLvlRemove);




123,054✔





753



}










754












755



int64_t tsdbTFileSetGetDataSize(const STFileSet *fset) {




206,470✔





756



  int64_t size = 0;




206,470✔





757



  if (fset->farr[TSDB_FTYPE_DATA]) {




206,470✔





758



    size += fset->farr[TSDB_FTYPE_DATA]->f->size;




138,736✔





759



  }










760












761



  SSttLvl *lvl;










762



  TARRAY2_FOREACH(fset->lvlArr, lvl) {




276,425✔





763



    STFileObj *fobj;










764



    TARRAY2_FOREACH(lvl->fobjArr, fobj) { size += fobj->f->size; }




147,081✔





765



  }










766



  return size;




206,470✔





767



}










768












769



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




21,836,492✔





770



  SSttLvl   sttLvl = {.level = level};




21,836,492✔





771



  SSttLvl  *lvl = &sttLvl;




21,838,949✔





772



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




21,839,565✔





773



  return lvlPtr ? lvlPtr[0] : NULL;




21,839,238✔





774



}










775












776



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




428,863,263✔





777



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




428,863,263✔





778



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




426,448,633✔





779



  return 0;




12,785,282✔





780



}










781












782



int64_t tsdbTFileSetMaxCid(const STFileSet *fset) {




748,545✔





783



  int64_t maxCid = 0;




748,545✔





784



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




3,738,153✔





785



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




2,987,481✔





786



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




590,223✔





787



  }










788



  const SSttLvl   *lvl;










789



  const STFileObj *fobj;










790



  TARRAY2_FOREACH(fset->lvlArr, lvl) {




1,495,440✔





791



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




1,517,707✔





792



  }










793



  return maxCid;




749,271✔





794



}










795












796



bool tsdbTFileSetIsEmpty(const STFileSet *fset) {




22,247,970✔





797



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




102,689,901✔





798



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




84,090,102✔





799



  }










800



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




18,599,799✔





801



}
























    

  • 

    •