taosdata / TDengine / #5036

coverage: 73.055% (-0.005%) from 73.06%
#5036

push

travis-ci

web-flow 
func/regexp_extract: new scalar func and test cases (#35191)

46 of 59 new or added lines in 1 file covered. (77.97%)

5784 existing lines in 151 files now uncovered.

276105 of 377940 relevant lines covered (73.06%)

133708549.2 hits per line

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

95.74
/source/dnode/vnode/src/tsdb/tsdbUtil2.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 "tsdbUtil2.h"










17












18



// SDelBlock ----------










19



void tTombBlockInit(STombBlock *tombBlock) {




1,580,912✔





20



  tombBlock->numOfRecords = 0;




1,580,912✔





21



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




9,485,472✔





22



    tBufferInit(&tombBlock->buffers[i]);




7,904,560✔





23



  }










24



  return;




1,580,912✔





25



}










26












27



void tTombBlockDestroy(STombBlock *tombBlock) {




32,482,289✔





28



  tombBlock->numOfRecords = 0;




32,482,289✔





29



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




194,873,814✔





30



    tBufferDestroy(&tombBlock->buffers[i]);




162,384,389✔





31



  }










32



}




32,489,425✔





33












34



void tTombBlockClear(STombBlock *tombBlock) {




12,011,581✔





35



  tombBlock->numOfRecords = 0;




12,011,581✔





36



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




72,069,486✔





37



    tBufferClear(&tombBlock->buffers[i]);




60,057,905✔





38



  }










39



}




12,011,581✔





40












41



int32_t tTombBlockPut(STombBlock *tombBlock, const STombRecord *record) {




41,255,346✔





42



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




247,532,076✔





43



    TAOS_CHECK_RETURN(tBufferPutI64(&tombBlock->buffers[i], record->data[i]));




412,553,460✔





44



  }










45



  tombBlock->numOfRecords++;




41,255,346✔





46



  return 0;




41,255,346✔





47



}










48












49



int32_t tTombBlockGet(STombBlock *tombBlock, int32_t idx, STombRecord *record) {




195,327,138✔





50



  if (idx < 0 || idx >= tombBlock->numOfRecords) {




195,327,138✔





51



    return TSDB_CODE_OUT_OF_RANGE;




×







52



  }










53












54



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




1,171,954,933✔





55



    SBufferReader br = BUFFER_READER_INITIALIZER(sizeof(int64_t) * idx, &tombBlock->buffers[i]);




976,629,595✔





56



    TAOS_CHECK_RETURN(tBufferGetI64(&br, &record->data[i]));




976,627,102✔





57



  }










58



  return 0;




195,325,338✔





59



}










60












61



int32_t tTombRecordCompare(const STombRecord *r1, const STombRecord *r2) {




34,719,340✔





62



  if (r1->suid < r2->suid) return -1;




34,719,340✔





63



  if (r1->suid > r2->suid) return 1;




34,350,840✔





64



  if (r1->uid < r2->uid) return -1;




1,090,340✔





65



  if (r1->uid > r2->uid) return 1;




1,090,340✔





66



  if (r1->version < r2->version) return -1;




1,090,340✔





67



  if (r1->version > r2->version) return 1;




1,090,340✔





68



  return 0;




×







69



}










70












71



// STbStatisBlock ----------










72



int32_t tStatisBlockInit(STbStatisBlock *statisBlock) {




251,995,892✔





73



  int32_t code = 0;




251,995,892✔





74












75



  statisBlock->numOfPKs = 0;




251,995,892✔





76



  statisBlock->numOfRecords = 0;




252,018,193✔





77



  for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {




1,511,881,817✔





78



    tBufferInit(&statisBlock->buffers[i]);




1,259,893,241✔





79



  }










80



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




756,010,018✔





81



    TAOS_CHECK_GOTO(tValueColumnInit(&statisBlock->firstKeyPKs[i]), NULL, _exit);




503,989,690✔





82



    TAOS_CHECK_GOTO(tValueColumnInit(&statisBlock->lastKeyPKs[i]), NULL, _exit);




503,989,708✔





83



  }










84












85



_exit:




252,020,328✔





86



  if (code) {




252,020,328✔





87



    tStatisBlockDestroy(statisBlock);




×







88



  }










89



  return code;




252,010,033✔





90



}










91












92



void tStatisBlockDestroy(STbStatisBlock *statisBlock) {




271,039,684✔





93



  statisBlock->numOfPKs = 0;




271,039,684✔





94



  statisBlock->numOfRecords = 0;




271,056,593✔





95



  for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {




1,626,330,024✔





96



    tBufferDestroy(&statisBlock->buffers[i]);




1,355,254,363✔





97



  }










98



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




813,208,737✔





99



    tValueColumnDestroy(&statisBlock->firstKeyPKs[i]);




542,147,980✔





100



    tValueColumnDestroy(&statisBlock->lastKeyPKs[i]);




542,143,277✔





101



  }










102



}




271,060,757✔





103












104



void tStatisBlockClear(STbStatisBlock *statisBlock) {




281,546,282✔





105



  statisBlock->numOfPKs = 0;




281,546,282✔





106



  statisBlock->numOfRecords = 0;




281,559,050✔





107



  for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {




1,689,178,959✔





108



    tBufferClear(&statisBlock->buffers[i]);




1,407,637,074✔





109



  }










110



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




844,594,359✔





111



    tValueColumnClear(&statisBlock->firstKeyPKs[i]);




563,068,031✔





112



    tValueColumnClear(&statisBlock->lastKeyPKs[i]);




563,045,663✔





113



  }










114



  return;




281,526,328✔





115



}










116












117



static int32_t tStatisBlockAppend(STbStatisBlock *block, SRowInfo *row) {




99,089,800✔





118



  STsdbRowKey key;




99,088,222✔





119












120



  tsdbRowGetKey(&row->row, &key);




99,102,631✔





121



  if (block->numOfRecords == 0) {




99,117,483✔





122



    block->numOfPKs = key.key.numOfPKs;




19,319,648✔





123



  } else if (block->numOfPKs != key.key.numOfPKs) {




79,794,892✔





124



    return TSDB_CODE_INVALID_PARA;




48,355✔





125



  } else {










126



    for (int i = 0; i < block->numOfPKs; i++) {




80,214,465✔





127



      if (key.key.pks[i].type != block->firstKeyPKs[i].type) {




532,376✔





128



        return TSDB_CODE_INVALID_PARA;




53,510✔





129



      }










130



    }










131



  }










132












133



  TAOS_CHECK_RETURN(tBufferPutI64(&block->suids, row->suid));




197,972,152✔





134



  TAOS_CHECK_RETURN(tBufferPutI64(&block->uids, row->uid));




197,999,406✔





135



  TAOS_CHECK_RETURN(tBufferPutI64(&block->firstKeyTimestamps, key.key.ts));




197,987,517✔





136



  TAOS_CHECK_RETURN(tBufferPutI64(&block->lastKeyTimestamps, key.key.ts));




198,005,252✔





137



  TAOS_CHECK_RETURN(tBufferPutI64(&block->counts, 1));




198,009,379✔





138



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




99,880,098✔





139



    TAOS_CHECK_RETURN(tValueColumnAppend(block->firstKeyPKs + i, key.key.pks + i));




875,319✔





140



    TAOS_CHECK_RETURN(tValueColumnAppend(block->lastKeyPKs + i, key.key.pks + i));




875,319✔





141



  }










142












143



  block->numOfRecords++;




98,991,463✔





144



  return 0;




98,996,331✔





145



}










146












147



static int32_t tStatisBlockUpdate(STbStatisBlock *block, SRowInfo *row) {




2,147,483,647✔





148



  STbStatisRecord record;




2,147,483,647✔





149



  STsdbRowKey     key;




2,147,483,647✔





150



  int32_t         c;










151












152



  TAOS_CHECK_RETURN(tStatisBlockGet(block, block->numOfRecords - 1, &record));




2,147,483,647✔





153



  tsdbRowGetKey(&row->row, &key);




2,147,483,647✔





154












155



  c = tRowKeyCompare(&record.lastKey, &key.key);




2,147,483,647✔





156



  if (c == 0) {




2,147,483,647✔





157



    return 0;




180,988,890✔





158



  } else if (c < 0) {




2,147,483,647✔





159



    // last ts










160



    TAOS_CHECK_RETURN(tBufferPutAt(&block->lastKeyTimestamps, (block->numOfRecords - 1) * sizeof(record.lastKey.ts),




2,147,483,647✔





161



                                   &key.key.ts, sizeof(key.key.ts)));










162












163



    // last primary keys










164



    for (int i = 0; i < block->numOfPKs; i++) {




2,147,483,647✔





165



      TAOS_CHECK_RETURN(tValueColumnUpdate(&block->lastKeyPKs[i], block->numOfRecords - 1, &key.key.pks[i]));




58,319,680✔





166



    }










167












168



    // count










169



    record.count++;




2,147,483,647✔





170



    TAOS_CHECK_RETURN(tBufferPutAt(&block->counts, (block->numOfRecords - 1) * sizeof(record.count), &record.count,




2,147,483,647✔





171



                                   sizeof(record.count)));










172



  } else {










173



    return TSDB_CODE_INVALID_PARA;




×







174



  }










175












176



  return 0;




2,147,483,647✔





177



}










178












179



int32_t tStatisBlockPut(STbStatisBlock *block, SRowInfo *row, int32_t maxRecords) {




2,147,483,647✔





180



  if (block->numOfRecords > 0) {




2,147,483,647✔





181



    int64_t       lastUid;




2,147,483,647✔





182



    SBufferReader br = BUFFER_READER_INITIALIZER(sizeof(int64_t) * (block->numOfRecords - 1), &block->uids);




2,147,483,647✔





183



    TAOS_CHECK_RETURN(tBufferGetI64(&br, &lastUid));




2,147,483,647✔





184












185



    if (lastUid == row->uid) {




2,147,483,647✔





186



      return tStatisBlockUpdate(block, row);




2,147,483,647✔





187



    } else if (block->numOfRecords >= maxRecords) {




79,805,158✔





188



      return TSDB_CODE_INVALID_PARA;




6,388✔





189



    }










190



  }










191



  return tStatisBlockAppend(block, row);




101,740,393✔





192



}










193












194



int32_t tStatisBlockGet(STbStatisBlock *statisBlock, int32_t idx, STbStatisRecord *record) {




2,147,483,647✔





195



  SBufferReader reader;




2,147,483,647✔





196












197



  if (idx < 0 || idx >= statisBlock->numOfRecords) {




2,147,483,647✔





198



    return TSDB_CODE_OUT_OF_RANGE;




×







199



  }










200












201



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->suid), &statisBlock->suids);




2,147,483,647✔





202



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->suid));




2,147,483,647✔





203












204



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->uid), &statisBlock->uids);




2,147,483,647✔





205



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->uid));




2,147,483,647✔





206












207



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->firstKey.ts), &statisBlock->firstKeyTimestamps);




2,147,483,647✔





208



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.ts));




2,147,483,647✔





209












210



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->lastKey.ts), &statisBlock->lastKeyTimestamps);




2,147,483,647✔





211



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.ts));




2,147,483,647✔





212












213



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->count), &statisBlock->counts);




2,147,483,647✔





214



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->count));




2,147,483,647✔





215












216



  if (statisBlock->numOfPKs > TD_MAX_PK_COLS) {




2,147,483,647✔






UNCOV

217



    return TSDB_CODE_FILE_CORRUPTED;




×







218



  }










219












220



  // primary keys










221



  for (record->firstKey.numOfPKs = 0; record->firstKey.numOfPKs < statisBlock->numOfPKs; record->firstKey.numOfPKs++) {




2,147,483,647✔





222



    TAOS_CHECK_RETURN(tValueColumnGet(&statisBlock->firstKeyPKs[record->firstKey.numOfPKs], idx,




115,707,838✔





223



                                      &record->firstKey.pks[record->firstKey.numOfPKs]));










224



  }










225












226



  for (record->lastKey.numOfPKs = 0; record->lastKey.numOfPKs < statisBlock->numOfPKs; record->lastKey.numOfPKs++) {




2,147,483,647✔





227



    TAOS_CHECK_RETURN(tValueColumnGet(&statisBlock->lastKeyPKs[record->lastKey.numOfPKs], idx,




115,707,978✔





228



                                      &record->lastKey.pks[record->lastKey.numOfPKs]));










229



  }










230












231



  return 0;




2,147,483,647✔





232



}










233












234



// SBrinRecord ----------










235



int32_t tBrinBlockInit(SBrinBlock *brinBlock) {




26,766✔





236



  int32_t code;










237












238



  brinBlock->numOfPKs = 0;




26,766✔





239



  brinBlock->numOfRecords = 0;




26,766✔





240



  for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {




428,256✔





241



    tBufferInit(&brinBlock->buffers[i]);




401,490✔





242



  }










243



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




80,298✔





244



    TAOS_CHECK_GOTO(tValueColumnInit(&brinBlock->firstKeyPKs[i]), NULL, _exit);




53,532✔





245



    TAOS_CHECK_GOTO(tValueColumnInit(&brinBlock->lastKeyPKs[i]), NULL, _exit);




53,532✔





246



  }










247












248



_exit:




26,766✔





249



  if (code) {




26,766✔






UNCOV

250



    tBrinBlockDestroy(brinBlock);




×







251



  }










252



  return code;




26,766✔





253



}










254












255



void tBrinBlockDestroy(SBrinBlock *brinBlock) {




344,412,350✔





256



  brinBlock->numOfPKs = 0;




344,412,350✔





257



  brinBlock->numOfRecords = 0;




344,441,593✔





258



  for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {




2,147,483,647✔





259



    tBufferDestroy(&brinBlock->buffers[i]);




2,147,483,647✔





260



  }










261



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




1,033,308,612✔





262



    tValueColumnDestroy(&brinBlock->firstKeyPKs[i]);




688,854,779✔





263



    tValueColumnDestroy(&brinBlock->lastKeyPKs[i]);




688,888,423✔





264



  }










265



}




344,453,833✔





266












267



void tBrinBlockClear(SBrinBlock *brinBlock) {




48,187,810✔





268



  brinBlock->numOfPKs = 0;




48,187,810✔





269



  brinBlock->numOfRecords = 0;




48,199,472✔





270



  for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {




770,722,391✔





271



    tBufferClear(&brinBlock->buffers[i]);




722,528,000✔





272



  }










273



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




144,563,294✔





274



    tValueColumnClear(&brinBlock->firstKeyPKs[i]);




96,372,583✔





275



    tValueColumnClear(&brinBlock->lastKeyPKs[i]);




96,370,301✔





276



  }










277



}




48,190,711✔





278












279



int32_t tBrinBlockPut(SBrinBlock *brinBlock, const SBrinRecord *record) {




56,860,028✔





280



  if (record->firstKey.key.numOfPKs != record->lastKey.key.numOfPKs) {




56,860,028✔






UNCOV

281



    return TSDB_CODE_INVALID_PARA;




×







282



  }










283












284



  if (brinBlock->numOfRecords == 0) {  // the first row




56,860,378✔





285



    brinBlock->numOfPKs = record->firstKey.key.numOfPKs;




877,524✔





286



  } else if (brinBlock->numOfPKs != record->firstKey.key.numOfPKs) {




55,983,808✔





287



    // if the number of primary keys are not the same,










288



    // return an error code and the caller should handle it










289



    return TSDB_CODE_INVALID_PARA;




1,582✔





290



  } else {










291



    for (int i = 0; i < brinBlock->numOfPKs; i++) {




56,027,055✔





292



      if (record->firstKey.key.pks[i].type != brinBlock->firstKeyPKs[i].type) {




45,395✔






UNCOV

293



        return TSDB_CODE_INVALID_PARA;




×







294



      }










295



    }










296



  }










297












298



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->suids, record->suid));




113,715,921✔





299



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->uids, record->uid));




113,715,147✔





300



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->firstKeyTimestamps, record->firstKey.key.ts));




113,714,245✔





301



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->firstKeyVersions, record->firstKey.version));




113,711,826✔





302



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->lastKeyTimestamps, record->lastKey.key.ts));




113,709,535✔





303



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->lastKeyVersions, record->lastKey.version));




113,710,887✔





304



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->minVers, record->minVer));




113,711,062✔





305



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->maxVers, record->maxVer));




113,708,614✔





306



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->blockOffsets, record->blockOffset));




113,708,811✔





307



  TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->smaOffsets, record->smaOffset));




113,708,509✔





308



  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->blockSizes, record->blockSize));




113,710,743✔





309



  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->blockKeySizes, record->blockKeySize));




113,710,144✔





310



  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->smaSizes, record->smaSize));




113,705,338✔





311



  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->numRows, record->numRow));




113,704,847✔





312



  TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->counts, record->count));




113,706,149✔





313












314



  if (brinBlock->numOfPKs > 0) {




56,853,384✔





315



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




99,354✔





316



      TAOS_CHECK_RETURN(tValueColumnAppend(&brinBlock->firstKeyPKs[i], &record->firstKey.key.pks[i]));




49,677✔





317



    }










318












319



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




99,354✔





320



      TAOS_CHECK_RETURN(tValueColumnAppend(&brinBlock->lastKeyPKs[i], &record->lastKey.key.pks[i]));




49,677✔





321



    }










322



  }










323












324



  brinBlock->numOfRecords++;




56,854,755✔





325












326



  return 0;




56,855,641✔





327



}










328












329



int32_t tBrinBlockGet(SBrinBlock *brinBlock, int32_t idx, SBrinRecord *record) {




920,954,381✔





330



  SBufferReader reader;




920,954,381✔





331












332



  if (idx < 0 || idx >= brinBlock->numOfRecords) {




921,308,405✔






UNCOV

333



    return TSDB_CODE_OUT_OF_RANGE;




×







334



  }










335












336



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->suids);




921,381,354✔





337



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->suid));




921,761,124✔





338












339



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->uids);




921,262,223✔





340



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->uid));




921,293,834✔





341












342



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->firstKeyTimestamps);




920,455,868✔





343



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.key.ts));




920,608,602✔





344












345



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->firstKeyVersions);




919,624,862✔





346



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.version));




919,671,002✔





347












348



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->lastKeyTimestamps);




919,764,241✔





349



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.key.ts));




919,826,108✔





350












351



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->lastKeyVersions);




919,533,834✔





352



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.version));




919,727,115✔





353












354



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->minVers);




918,391,327✔





355



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->minVer));




919,783,520✔





356












357



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->maxVers);




919,961,321✔





358



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->maxVer));




919,683,751✔





359












360



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->blockOffsets);




919,690,131✔





361



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->blockOffset));




919,875,896✔





362












363



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->smaOffsets);




919,997,148✔





364



  TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->smaOffset));




920,047,926✔





365












366



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->blockSizes);




919,977,264✔





367



  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->blockSize));




919,932,427✔





368












369



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->blockKeySizes);




920,464,933✔





370



  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->blockKeySize));




920,469,083✔





371












372



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->smaSizes);




920,127,351✔





373



  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->smaSize));




920,159,228✔





374












375



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->numRows);




919,950,035✔





376



  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->numRow));




920,038,118✔





377












378



  reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->counts);




920,094,969✔





379



  TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->count));




920,195,134✔





380












381



  // primary keys










382



  for (record->firstKey.key.numOfPKs = 0; record->firstKey.key.numOfPKs < brinBlock->numOfPKs;




920,548,337✔





383



       record->firstKey.key.numOfPKs++) {




148,531✔





384



    TAOS_CHECK_RETURN(tValueColumnGet(&brinBlock->firstKeyPKs[record->firstKey.key.numOfPKs], idx,




148,531✔





385



                                      &record->firstKey.key.pks[record->firstKey.key.numOfPKs]));










386



  }










387












388



  for (record->lastKey.key.numOfPKs = 0; record->lastKey.key.numOfPKs < brinBlock->numOfPKs;




920,979,374✔





389



       record->lastKey.key.numOfPKs++) {




148,531✔





390



    TAOS_CHECK_RETURN(tValueColumnGet(&brinBlock->lastKeyPKs[record->lastKey.key.numOfPKs], idx,




148,531✔





391



                                      &record->lastKey.key.pks[record->lastKey.key.numOfPKs]));










392



  }










393












394



  return 0;




920,869,927✔





395



}










396












397



// other apis ----------










398



int32_t tsdbUpdateSkmTb(STsdb *pTsdb, const TABLEID *tbid, SSkmInfo *pSkmTb) {




82,630,810✔





399



  if (tbid->suid) {




82,630,810✔





400



    if (pSkmTb->suid == tbid->suid) {




75,996,201✔





401



      pSkmTb->uid = tbid->uid;




56,488,921✔





402



      return 0;




56,490,628✔





403



    }










404



  } else if (pSkmTb->uid == tbid->uid) {




6,648,019✔





405



    return 0;




351,922✔





406



  }










407












408



  pSkmTb->suid = tbid->suid;




25,846,990✔





409



  pSkmTb->uid = tbid->uid;




25,853,683✔





410



  tDestroyTSchema(pSkmTb->pTSchema);




25,837,366✔





411



  return metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, tbid->suid, tbid->uid, -1, &pSkmTb->pTSchema);




25,850,330✔





412



}










413












414



int32_t tsdbUpdateSkmRow(STsdb *pTsdb, const TABLEID *tbid, int32_t sver, SSkmInfo *pSkmRow) {




2,147,483,647✔





415



  if (pSkmRow->pTSchema && pSkmRow->suid == tbid->suid) {




2,147,483,647✔





416



    if (pSkmRow->suid) {




2,147,483,647✔





417



      if (sver == pSkmRow->pTSchema->version) return 0;




2,147,483,647✔





418



    } else if (pSkmRow->uid == tbid->uid && pSkmRow->pTSchema->version == sver) {




2,147,483,647✔





419



      return 0;




2,147,483,647✔





420



    }










421



  }










422












423



  pSkmRow->suid = tbid->suid;




1,845,932✔





424



  pSkmRow->uid = tbid->uid;




25,094,301✔





425



  tDestroyTSchema(pSkmRow->pTSchema);




25,089,018✔





426



  return metaGetTbTSchemaEx(pTsdb->pVnode->pMeta, tbid->suid, tbid->uid, sver, &pSkmRow->pTSchema);




25,103,563✔





427



}











UNCOV

428



int32_t tsdbUpdateColCmprObj(STsdb *pTsdb, const TABLEID *tbid, SHashObj **ppColCmpr) { return 0; }




×





















    

  • 

    •