taosdata / TDengine / #4977

coverage: 68.456% (+0.01%) from 68.446%
#4977

push

travis-ci

web-flow 
feat(TDgpt): support multiple input data columns for anomaly detection. (#34606)

0 of 93 new or added lines in 9 files covered. (0.0%)

3178 existing lines in 120 files now uncovered.

211178 of 308486 relevant lines covered (68.46%)

135843202.71 hits per line

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

95.7
/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,452,238✔





20



  tombBlock->numOfRecords = 0;




1,452,238✔





21



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




8,713,428✔





22



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




7,261,190✔





23



  }










24



  return;




1,452,238✔





25



}










26












27



void tTombBlockDestroy(STombBlock *tombBlock) {




27,951,167✔





28



  tombBlock->numOfRecords = 0;




27,951,167✔





29



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




167,488,103✔





30



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




139,548,642✔





31



  }










32



}




27,939,461✔





33












34



void tTombBlockClear(STombBlock *tombBlock) {




9,280,702✔





35



  tombBlock->numOfRecords = 0;




9,280,702✔





36



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




55,684,212✔





37



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




46,403,510✔





38



  }










39



}




9,280,702✔





40












41



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




38,218,895✔





42



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




229,313,370✔





43



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




382,188,950✔





44



  }










45



  tombBlock->numOfRecords++;




38,218,895✔





46



  return 0;




38,218,895✔





47



}










48












49



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




623,827,791✔





50



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




623,827,791✔





51



    return TSDB_CODE_OUT_OF_RANGE;




×







52



  }










53












54



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




2,147,483,647✔





55



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




2,147,483,647✔





56



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




2,147,483,647✔





57



  }










58



  return 0;




623,846,089✔





59



}










60












61



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




31,890,747✔





62



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




31,890,747✔





63



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




31,890,747✔





64



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




1,004,972✔





65



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




1,004,972✔





66



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




1,004,972✔





67



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




1,004,972✔





68



  return 0;




×







69



}










70












71



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










72



int32_t tStatisBlockInit(STbStatisBlock *statisBlock) {




246,619,516✔





73



  int32_t code = 0;




246,619,516✔





74












75



  statisBlock->numOfPKs = 0;




246,619,516✔





76



  statisBlock->numOfRecords = 0;




246,668,607✔





77



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




1,479,664,590✔





78



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




1,233,024,802✔





79



  }










80



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




740,065,827✔





81



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




493,328,609✔





82



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




493,378,689✔





83



  }










84












85



_exit:




246,737,218✔





86



  if (code) {




246,737,218✔





87



    tStatisBlockDestroy(statisBlock);




×







88



  }










89



  return code;




246,721,077✔





90



}










91












92



void tStatisBlockDestroy(STbStatisBlock *statisBlock) {




264,001,671✔





93



  statisBlock->numOfPKs = 0;




264,001,671✔





94



  statisBlock->numOfRecords = 0;




264,026,057✔





95



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




1,584,100,974✔





96



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




1,320,017,865✔





97



  }










98



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




792,171,791✔





99



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




528,087,870✔





100



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




528,130,313✔





101



  }










102



}




264,083,921✔





103












104



void tStatisBlockClear(STbStatisBlock *statisBlock) {




267,395,868✔





105



  statisBlock->numOfPKs = 0;




267,395,868✔





106



  statisBlock->numOfRecords = 0;




267,414,276✔





107



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




1,604,058,448✔





108



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




1,336,666,940✔





109



  }










110



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




802,131,395✔





111



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




534,750,816✔





112



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




534,752,859✔





113



  }










114



  return;




267,380,579✔





115



}










116












117



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




89,967,705✔





118



  STsdbRowKey key;




89,966,187✔





119












120



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




89,974,239✔





121



  if (block->numOfRecords == 0) {




89,972,427✔





122



    block->numOfPKs = key.key.numOfPKs;




17,610,115✔





123



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




72,374,825✔





124



    return TSDB_CODE_INVALID_PARA;




46,512✔





125



  } else {










126



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




72,711,390✔





127



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




432,876✔





128



        return TSDB_CODE_INVALID_PARA;




52,924✔





129



      }










130



    }










131



  }










132












133



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




179,743,955✔





134



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




179,740,708✔





135



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




179,758,629✔





136



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




179,775,206✔





137



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




179,760,439✔





138



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




90,668,135✔





139



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




792,113✔





140



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




790,833✔





141



  }










142












143



  block->numOfRecords++;




89,866,270✔





144



  return 0;




89,862,825✔





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;




170,380,696✔





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]));




52,438,942✔





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




72,381,848✔





188



      return TSDB_CODE_INVALID_PARA;




5,880✔





189



    }










190



  }










191



  return tStatisBlockAppend(block, row);




98,809,148✔





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



  // primary keys










217



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




2,147,483,647✔





218



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




67,663,839✔





219



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










220



  }










221












222



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




2,147,483,647✔





223



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




67,664,961✔





224



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










225



  }










226












227



  return 0;




2,147,483,647✔





228



}










229












230



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










231



int32_t tBrinBlockInit(SBrinBlock *brinBlock) {




23,933✔





232



  int32_t code;










233












234



  brinBlock->numOfPKs = 0;




23,933✔





235



  brinBlock->numOfRecords = 0;




23,933✔





236



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




382,928✔





237



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




358,995✔





238



  }










239



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




71,799✔





240



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




47,866✔





241



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




47,866✔





242



  }










243












244



_exit:




23,933✔





245



  if (code) {




23,933✔





246



    tBrinBlockDestroy(brinBlock);




×







247



  }










248



  return code;




23,933✔





249



}










250












251



void tBrinBlockDestroy(SBrinBlock *brinBlock) {




441,510,148✔





252



  brinBlock->numOfPKs = 0;




441,510,148✔





253



  brinBlock->numOfRecords = 0;




441,627,327✔





254



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




2,147,483,647✔





255



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




2,147,483,647✔





256



  }










257



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




1,325,159,016✔





258



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




883,367,813✔





259



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




883,350,566✔





260



  }










261



}




441,791,203✔





262












263



void tBrinBlockClear(SBrinBlock *brinBlock) {




45,128,151✔





264



  brinBlock->numOfPKs = 0;




45,128,151✔





265



  brinBlock->numOfRecords = 0;




45,137,890✔





266



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




721,674,353✔





267



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




676,529,124✔





268



  }










269



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




135,419,084✔





270



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




90,276,616✔





271



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




90,277,856✔





272



  }










273



}




45,142,468✔





274












275



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




46,695,592✔





276



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




46,695,592✔





277



    return TSDB_CODE_INVALID_PARA;




×







278



  }










279












280



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




46,696,905✔





281



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




769,010✔





282



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




45,928,662✔





283



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










284



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











UNCOV

285



    return TSDB_CODE_INVALID_PARA;




×







286



  } else {










287



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




45,926,868✔





288



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




2,103✔





289



        return TSDB_CODE_INVALID_PARA;




×







290



      }










291



    }










292



  }










293












294



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




93,383,691✔





295



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




93,382,643✔





296



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




93,381,331✔





297



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




93,377,959✔





298



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




93,377,925✔





299



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




93,379,554✔





300



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




93,379,749✔





301



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




93,377,725✔





302



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




93,373,336✔





303



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




93,375,764✔





304



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




93,377,850✔





305



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




93,374,523✔





306



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




93,377,150✔





307



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




93,379,763✔





308



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




93,374,769✔





309












310



  if (brinBlock->numOfPKs > 0) {




46,685,894✔





311



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




8,086✔





312



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




4,043✔





313



    }










314












315



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




8,086✔





316



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




4,043✔





317



    }










318



  }










319












320



  brinBlock->numOfRecords++;




46,687,382✔





321












322



  return 0;




46,685,500✔





323



}










324












325



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




829,753,821✔





326



  SBufferReader reader;




829,753,821✔





327












328



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




829,955,173✔





329



    return TSDB_CODE_OUT_OF_RANGE;




×







330



  }










331












332



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




830,202,441✔





333



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




830,582,919✔





334












335



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




830,013,385✔





336



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




830,090,813✔





337












338



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




829,579,304✔





339



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




829,504,984✔





340












341



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




829,102,610✔





342



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




829,182,282✔





343












344



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




829,089,520✔





345



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




829,136,107✔





346












347



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




829,068,126✔





348



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




829,082,212✔





349












350



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




828,989,549✔





351



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




828,974,638✔





352












353



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




829,306,828✔





354



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




829,552,711✔





355












356



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




829,317,363✔





357



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




829,559,387✔





358












359



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




829,200,173✔





360



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




829,320,017✔





361












362



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




829,235,007✔





363



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




828,921,340✔





364












365



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




829,535,537✔





366



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




829,554,366✔





367












368



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




829,308,902✔





369



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




829,311,069✔





370












371



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




829,108,027✔





372



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




829,128,025✔





373












374



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




829,145,690✔





375



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




829,119,675✔





376












377



  // primary keys










378



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




829,408,428✔





379



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




9,488✔





380



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




9,488✔





381



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










382



  }










383












384



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




829,758,089✔





385



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




9,488✔





386



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




9,488✔





387



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










388



  }










389












390



  return 0;




829,726,629✔





391



}










392












393



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










394



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




69,215,258✔





395



  if (tbid->suid) {




69,215,258✔





396



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




63,380,881✔





397



      pSkmTb->uid = tbid->uid;




45,627,499✔





398



      return 0;




45,629,118✔





399



    }










400



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




5,855,048✔





401



    return 0;




288,492✔





402



  }










403












404



  pSkmTb->suid = tbid->suid;




23,329,324✔





405



  pSkmTb->uid = tbid->uid;




23,334,636✔





406



  tDestroyTSchema(pSkmTb->pTSchema);




23,323,288✔





407



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




23,333,122✔





408



}










409












410



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




2,147,483,647✔





411



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




2,147,483,647✔





412



    if (pSkmRow->suid) {




2,147,483,647✔





413



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




2,147,483,647✔





414



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




2,147,483,647✔





415



      return 0;




2,147,483,647✔





416



    }










417



  }










418












419



  pSkmRow->suid = tbid->suid;




14,544,276✔





420



  pSkmRow->uid = tbid->uid;




22,661,848✔





421



  tDestroyTSchema(pSkmRow->pTSchema);




22,653,938✔





422



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




22,637,767✔





423



}










424



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




×





















    

  • 

    •