taosdata / TDengine / #4971

coverage: 67.671% (-0.04%) from 67.707%
#4971

push

travis-ci

web-flow 
fix(planner): disable project block merge in non-top-level subplans (#34617)

208281 of 307783 relevant lines covered (67.67%)

130135765.28 hits per line

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

89.87
/source/libs/parser/src/parInsertSml.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 "parInsertUtil.h"










17



#include "parInt.h"










18



#include "parToken.h"










19



#include "ttime.h"










20



#include "ttokendef.h"










21












22



int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf,




6,478,126✔





23



                     int32_t msgBufLen) {










24



  SMsgBuf msg = {.buf = msgBuf, .len = msgBufLen};




6,478,126✔





25



  SToken  sToken = {0};




6,479,219✔





26



  int     code = TSDB_CODE_SUCCESS;




6,478,857✔





27



  int32_t lino = 0;




6,478,857✔





28












29



  NEXT_TOKEN(pTableName, sToken);




6,478,857✔





30



  TSDB_CHECK_CONDITION(sToken.n != 0, code, lino, end, TSDB_CODE_TSC_STMT_TBNAME_ERROR);




6,477,621✔





31



  code = insCreateSName(pName, &sToken, acctId, dbName, &msg);




6,477,621✔





32



  TSDB_CHECK_CODE(code, lino, end);




6,476,310✔





33



  NEXT_TOKEN(pTableName, sToken);




6,476,310✔





34



  TSDB_CHECK_CONDITION(sToken.n <= 0, code, lino, end, TSDB_CODE_TSC_STMT_TBNAME_ERROR);




6,478,894✔





35












36



end:




6,478,894✔





37



  if (code != 0) {




6,479,903✔





38



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




×







39



  }










40



  return code;




6,479,883✔





41



}










42












43



int32_t qCreateSName2(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf,




918,327✔





44



                      int32_t msgBufLen) {










45



  SMsgBuf msg = {.buf = msgBuf, .len = msgBufLen};




918,327✔





46



  SToken  sToken = {0};




918,445✔





47



  int     code = TSDB_CODE_SUCCESS;




918,407✔





48



  int32_t lino = 0;




918,407✔





49












50



  if (pTableName == NULL || strlen(pTableName) == 0) {




918,407✔





51



    code = TSDB_CODE_TSC_STMT_TBNAME_ERROR;




×







52



    goto end;




×







53



  }










54












55



  sToken.z = (char*)pTableName;




918,622✔





56



  sToken.n = strlen(pTableName);




918,622✔





57



  sToken.type = TK_NK_ID;




918,622✔





58












59



  code = insCreateSName(pName, &sToken, acctId, dbName, &msg);




918,622✔





60



  TSDB_CHECK_CODE(code, lino, end);




918,545✔





61












62



end:




918,545✔





63



  if (code != 0) {




918,442✔





64



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




×







65



  }










66



  return code;




918,461✔





67



}










68












69



static int32_t smlBoundColumnData(SArray* cols, SBoundColInfo* pBoundInfo, SSchema* pSchema, bool isTag) {




1,245,055✔





70



  int     code = TSDB_CODE_SUCCESS;




1,245,055✔





71



  int32_t lino = 0;




1,245,055✔





72



  bool*   pUseCols = taosMemoryCalloc(pBoundInfo->numOfCols, sizeof(bool));




1,245,055✔





73



  TSDB_CHECK_NULL(pUseCols, code, lino, end, terrno);




1,245,057✔





74



  pBoundInfo->numOfBound = 0;




1,245,057✔





75



  int16_t lastColIdx = -1;  // last column found




1,245,094✔





76












77



  for (int i = 0; i < taosArrayGetSize(cols); ++i) {




14,711,464✔





78



    SSmlKv*  kv = taosArrayGet(cols, i);




13,466,493✔





79



    SToken   sToken = {.n = kv->keyLen, .z = (char*)kv->key};




13,466,185✔





80



    col_id_t t = lastColIdx + 1;




13,466,107✔





81



    col_id_t index = ((t == 0 && !isTag) ? 0 : insFindCol(&sToken, t, pBoundInfo->numOfCols, pSchema));




26,319,816✔





82



    uTrace("SML, index:%d, t:%d, ncols:%d", index, t, pBoundInfo->numOfCols);




13,465,951✔





83



    if (index < 0 && t > 0) {




13,466,134✔





84



      index = insFindCol(&sToken, 0, t, pSchema);




32,506✔





85



    }










86












87



    TSDB_CHECK_CONDITION(index >= 0, code, lino, end, TSDB_CODE_SML_INVALID_DATA);




13,466,134✔





88



    TSDB_CHECK_CONDITION(!pUseCols[index], code, lino, end, TSDB_CODE_SML_INVALID_DATA);




13,466,134✔





89












90



    lastColIdx = index;




13,466,370✔





91



    pUseCols[index] = true;




13,466,370✔





92



    pBoundInfo->pColIndex[pBoundInfo->numOfBound] = index;




13,466,407✔





93



    ++pBoundInfo->numOfBound;




13,466,253✔





94



  }










95












96



end:




1,244,968✔





97



  if (code != 0) {




1,244,929✔





98



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




×







99



  }










100



  taosMemoryFree(pUseCols);




1,244,929✔





101



  return code;




1,245,057✔





102



}










103












104



static int32_t smlMbsToUcs4(const char* mbs, size_t mbsLen, void** result, int32_t* resultLen, int32_t maxLen,




3,370,227✔





105



                            void* charsetCxt) {










106



  int     code = TSDB_CODE_SUCCESS;




3,370,227✔





107



  void*   pUcs4 = NULL;




3,370,227✔





108



  int32_t lino = 0;




3,370,227✔





109



  pUcs4 = taosMemoryCalloc(1, maxLen);




3,370,227✔





110



  TSDB_CHECK_NULL(pUcs4, code, lino, end, terrno);




3,370,278✔





111



  TSDB_CHECK_CONDITION(taosMbsToUcs4(mbs, mbsLen, (TdUcs4*)pUcs4, maxLen, resultLen, charsetCxt), code, lino, end,




3,370,278✔





112



                       terrno);










113



  *result = pUcs4;




3,370,239✔





114



  pUcs4 = NULL;




3,370,200✔





115












116



end:




3,370,200✔





117



  if (code != 0) {




3,370,200✔





118



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




×







119



  }










120



  taosMemoryFree(pUcs4);




3,370,200✔





121



  return code;




3,370,231✔





122



}










123



/**










124



 * @brief No json tag for schemaless










125



 *










126



 * @param cols










127



 * @param tags










128



 * @param pSchema










129



 * @param ppTag










130



 * @param msg










131



 * @return int32_t










132



 */










133



static int32_t smlBuildTagRow(SArray* cols, SBoundColInfo* tags, SSchema* pSchema, STag** ppTag, SArray** tagName,




632,708✔





134



                              SMsgBuf* msg, void* charsetCxt) {










135



  int     code = TSDB_CODE_SUCCESS;




632,708✔





136



  int32_t lino = 0;




632,708✔





137



  SArray* pTagArray = taosArrayInit(tags->numOfBound, sizeof(STagVal));




632,708✔





138



  TSDB_CHECK_NULL(pTagArray, code, lino, end, terrno);




632,864✔





139



  *tagName = taosArrayInit(8, TSDB_COL_NAME_LEN);




632,864✔





140



  TSDB_CHECK_NULL(*tagName, code, lino, end, terrno);




632,852✔





141












142



  for (int i = 0; i < tags->numOfBound; ++i) {




5,136,693✔





143



    SSchema* pTagSchema = &pSchema[tags->pColIndex[i]];




4,503,814✔





144



    SSmlKv*  kv = taosArrayGet(cols, i);




4,503,892✔





145



    TSDB_CHECK_NULL(kv, code, lino, end, terrno);




4,503,868✔





146



    bool cond = (kv->keyLen == strlen(pTagSchema->name) && memcmp(kv->key, pTagSchema->name, kv->keyLen) == 0 &&




9,007,652✔





147



                 kv->type == pTagSchema->type);




4,503,775✔





148



    TSDB_CHECK_CONDITION(cond, code, lino, end, TSDB_CODE_SML_INVALID_DATA);




4,503,877✔





149



    TSDB_CHECK_NULL(taosArrayPush(*tagName, pTagSchema->name), code, lino, end, terrno);




9,007,766✔





150



    STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};




4,503,889✔





151



    if (pTagSchema->type == TSDB_DATA_TYPE_BINARY || pTagSchema->type == TSDB_DATA_TYPE_VARBINARY ||




4,503,850✔





152



        pTagSchema->type == TSDB_DATA_TYPE_GEOMETRY) {




4,286,467✔





153



      val.pData = (uint8_t*)kv->value;




217,500✔





154



      val.nData = kv->length;




217,422✔





155



    } else if (pTagSchema->type == TSDB_DATA_TYPE_NCHAR) {




4,286,389✔





156



      code = smlMbsToUcs4(kv->value, kv->length, (void**)&val.pData, (int32_t*)&val.nData, kv->length * TSDB_NCHAR_SIZE,




3,138,279✔





157



                          charsetCxt);










158



      TSDB_CHECK_CODE(code, lino, end);




3,138,244✔





159



    } else {










160



      (void)memcpy(&val.i64, &(kv->value), kv->length);




1,148,110✔





161



    }










162



    TSDB_CHECK_NULL(taosArrayPush(pTagArray, &val), code, lino, end, terrno);




4,503,880✔





163



  }










164



  code = tTagNew(pTagArray, 1, false, ppTag);




632,801✔





165












166



end:




632,864✔





167



  if (code != 0) {




632,864✔





168



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




×







169



  }










170



  for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) {




5,136,452✔





171



    STagVal* p = (STagVal*)taosArrayGet(pTagArray, i);




4,503,666✔





172



    if (p->type == TSDB_DATA_TYPE_NCHAR) {




4,503,680✔





173



      taosMemoryFree(p->pData);




3,138,232✔





174



    }










175



  }










176



  taosArrayDestroy(pTagArray);




632,738✔





177



  return code;




632,827✔





178



}










179












180



int32_t smlInitTableDataCtx(SQuery* query, STableMeta* pTableMeta, STableDataCxt** cxt) {




69,475✔





181



  int            ret = TSDB_CODE_SUCCESS;




69,475✔





182



  int32_t        lino = 0;




69,475✔





183



  SVCreateTbReq* pCreateTbReq = NULL;




69,475✔





184



  ret = insGetTableDataCxt(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj, &pTableMeta->uid,




69,475✔





185



                           sizeof(pTableMeta->uid), pTableMeta, &pCreateTbReq, cxt, false, false);










186



  TSDB_CHECK_CODE(ret, lino, end);




69,499✔





187



  ret = initTableColSubmitData(*cxt);




69,499✔





188



  TSDB_CHECK_CODE(ret, lino, end);




69,475✔





189












190



end:




69,475✔





191



  if (ret != 0) {




69,475✔





192



    uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));




×







193



  }










194



  return ret;




69,475✔





195



}










196












197



void clearColValArraySml(SArray* pCols) {




4,517,606✔





198



  int32_t num = taosArrayGetSize(pCols);




4,517,606✔





199



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




30,668,552✔





200



    SColVal* pCol = taosArrayGet(pCols, i);




26,161,094✔





201



    if (TSDB_DATA_TYPE_NCHAR == pCol->value.type || TSDB_DATA_TYPE_GEOMETRY == pCol->value.type ||




26,800,033✔





202



        TSDB_DATA_TYPE_VARBINARY == pCol->value.type) {




26,573,090✔





203



      taosMemoryFreeClear(pCol->value.pData);




242,044✔





204



    }










205



    pCol->flag = CV_FLAG_NONE;




26,831,762✔





206



    pCol->value.val = 0;




26,824,839✔





207



  }










208



}




4,507,458✔





209












210



int32_t smlBuildRow(STableDataCxt* pTableCxt) {




81,174✔





211



  int     ret = TSDB_CODE_SUCCESS;




81,174✔





212



  int32_t lino = 0;




81,174✔





213



  SRow**  pRow = taosArrayReserve(pTableCxt->pData->aRowP, 1);




81,174✔





214



  TSDB_CHECK_NULL(pRow, ret, lino, end, terrno);




81,150✔





215












216



  SRowBuildScanInfo sinfo = {0};




81,150✔





217



  ret = tRowBuild(pTableCxt->pValues, pTableCxt->pSchema, pRow, &sinfo);




81,150✔





218



  TSDB_CHECK_CODE(ret, lino, end);




81,174✔





219



  SRowKey key;




17,814✔





220



  tRowGetKey(*pRow, &key);




162,348✔





221



  insCheckTableDataOrder(pTableCxt, &key);




81,174✔





222



end:




81,174✔





223



  if (ret != 0) {




81,174✔





224



    uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));




×







225



  }










226



  return ret;




81,174✔





227



}










228












229



int32_t smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void* data, int32_t index, void* charsetCxt) {




211,152✔





230



  int      ret = TSDB_CODE_SUCCESS;




211,152✔





231



  int32_t  lino = 0;




211,152✔





232



  SSchema* pColSchema = schema + index;




211,152✔





233



  SColVal* pVal = taosArrayGet(pTableCxt->pValues, index);




211,189✔





234



  TSDB_CHECK_NULL(pVal, ret, lino, end, TSDB_CODE_SUCCESS);




211,177✔





235



  SSmlKv* kv = (SSmlKv*)data;




211,177✔





236



  if (kv->keyLen != strlen(pColSchema->name) || memcmp(kv->key, pColSchema->name, kv->keyLen) != 0 ||




211,177✔





237



      kv->type != pColSchema->type) {




208,965✔





238



    ret = TSDB_CODE_SML_INVALID_DATA;




3,473✔





239



    char* tmp = taosMemoryCalloc(kv->keyLen + 1, 1);




3,473✔





240



    TSDB_CHECK_NULL(tmp, ret, lino, end, terrno);




3,436✔





241



    (void)memcpy(tmp, kv->key, kv->keyLen);




3,436✔





242



    uInfo("SML data(name:%s type:%s) is not same like the db data(name:%s type:%s)", tmp, tDataTypes[kv->type].name,




3,436✔





243



          pColSchema->name, tDataTypes[pColSchema->type].name);










244



    taosMemoryFree(tmp);




3,436✔





245



    goto end;




3,436✔





246



  }










247



  if (kv->type == TSDB_DATA_TYPE_NCHAR) {




207,690✔





248



    ret = smlMbsToUcs4(kv->value, kv->length, (void**)&pVal->value.pData, &pVal->value.nData,




2,880✔





249



                       pColSchema->bytes - VARSTR_HEADER_SIZE, charsetCxt);




2,880✔





250



    TSDB_CHECK_CODE(ret, lino, end);




2,880✔





251



  } else if (kv->type == TSDB_DATA_TYPE_BINARY) {




204,810✔





252



    pVal->value.nData = kv->length;




21,498✔





253



    pVal->value.pData = (uint8_t*)kv->value;




21,535✔





254



  } else if (kv->type == TSDB_DATA_TYPE_GEOMETRY || kv->type == TSDB_DATA_TYPE_VARBINARY) {




183,386✔





255



    pVal->value.nData = kv->length;




×







256



    pVal->value.pData = taosMemoryMalloc(kv->length);




×







257



    TSDB_CHECK_NULL(pVal->value.pData, ret, lino, end, terrno);




×







258












259



    (void)memcpy(pVal->value.pData, (uint8_t*)kv->value, kv->length);




×







260



  } else {










261



    valueSetDatum(&pVal->value, kv->type, &(kv->value), kv->length);




183,386✔





262



  }










263



  pVal->flag = CV_FLAG_VALUE;




207,678✔





264












265



end:




211,151✔





266



  if (ret != 0) {




211,151✔





267



    uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));




3,436✔





268



  }










269



  return ret;




211,114✔





270



}










271












272



int32_t smlBindData(SQuery* query, bool dataFormat, SArray* tags, SArray* colsSchema, SArray* cols,




632,813✔





273



                    STableMeta* pTableMeta, char* tableName, const char* sTableName, int32_t sTableNameLen, int32_t ttl,










274



                    char* msgBuf, int32_t msgBufLen, void* charsetCxt) {










275



  int32_t lino = 0;




632,813✔





276



  int32_t ret = 0;




632,813✔





277



  SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen};




632,813✔





278












279



  SSchema*       pTagsSchema = getTableTagSchema(pTableMeta);




632,813✔





280



  SBoundColInfo  bindTags = {0};




632,828✔





281



  SVCreateTbReq* pCreateTblReq = NULL;




632,789✔





282



  SArray*        tagName = NULL;




632,828✔





283












284



  ret = insInitBoundColsInfo(getNumOfTags(pTableMeta), &bindTags);




632,828✔





285



  TSDB_CHECK_CODE(ret, lino, end);




632,815✔





286












287



  ret = smlBoundColumnData(tags, &bindTags, pTagsSchema, true);




632,815✔





288



  TSDB_CHECK_CODE(ret, lino, end);




632,776✔





289












290



  STag* pTag = NULL;




632,776✔





291



  ret = smlBuildTagRow(tags, &bindTags, pTagsSchema, &pTag, &tagName, &pBuf, charsetCxt);




632,776✔





292



  TSDB_CHECK_CODE(ret, lino, end);




632,774✔





293












294



  pCreateTblReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq));




632,774✔





295



  TSDB_CHECK_NULL(pCreateTblReq, ret, lino, end, terrno);




632,751✔





296












297



  ret = insBuildCreateTbReq(pCreateTblReq, tableName, pTag, pTableMeta->suid, NULL, tagName,




632,790✔





298



                            pTableMeta->tableInfo.numOfTags, ttl);




632,751✔





299



  TSDB_CHECK_CODE(ret, lino, end);




632,852✔





300












301



  pCreateTblReq->ctb.stbName = taosMemoryCalloc(1, sTableNameLen + 1);




632,852✔





302



  TSDB_CHECK_NULL(pCreateTblReq->ctb.stbName, ret, lino, end, terrno);




632,852✔





303












304



  (void)memcpy(pCreateTblReq->ctb.stbName, sTableName, sTableNameLen);




632,815✔





305












306



  if (dataFormat) {




632,813✔





307



    STableDataCxt** pTableCxt = (STableDataCxt**)taosHashGet(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj,




20,622✔





308



                                                             &pTableMeta->uid, sizeof(pTableMeta->uid));




20,622✔





309



    TSDB_CHECK_NULL(pTableCxt, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);




20,622✔





310



    (*pTableCxt)->pData->flags |= SUBMIT_REQ_AUTO_CREATE_TABLE;




20,622✔





311



    (*pTableCxt)->pData->pCreateTbReq = pCreateTblReq;




20,622✔





312



    (*pTableCxt)->pMeta->uid = pTableMeta->uid;




20,622✔





313



    (*pTableCxt)->pMeta->vgId = pTableMeta->vgId;




20,622✔





314



    pCreateTblReq = NULL;




20,622✔





315



    goto end;




20,622✔





316



  }










317












318



  STableDataCxt* pTableCxt = NULL;




612,191✔





319



  ret = insGetTableDataCxt(((SVnodeModifyOpStmt*)(query->pRoot))->pTableBlockHashObj, &pTableMeta->uid,




612,191✔





320



                           sizeof(pTableMeta->uid), pTableMeta, &pCreateTblReq, &pTableCxt, false, false);










321



  TSDB_CHECK_CODE(ret, lino, end);




612,242✔





322












323



  SSchema* pSchema = getTableColumnSchema(pTableMeta);




612,242✔





324



  ret = smlBoundColumnData(colsSchema, &pTableCxt->boundColsInfo, pSchema, false);




612,242✔





325



  TSDB_CHECK_CODE(ret, lino, end);




612,242✔





326












327



  ret = initTableColSubmitData(pTableCxt);




612,242✔





328



  TSDB_CHECK_CODE(ret, lino, end);




612,230✔





329












330



  int32_t rowNum = taosArrayGetSize(cols);




612,230✔





331



  TSDB_CHECK_CONDITION(rowNum > 0, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);




612,242✔





332












333



  for (int32_t r = 0; r < rowNum; ++r) {




5,030,942✔





334



    void* rowData = taosArrayGetP(cols, r);




4,420,414✔





335



    TSDB_CHECK_NULL(rowData, ret, lino, end, terrno);




4,418,712✔





336












337



    // 1. set the parsed value from sql string










338



    for (int c = 0; c < pTableCxt->boundColsInfo.numOfBound; ++c) {




31,284,744✔





339



      SSchema* pColSchema = &pSchema[pTableCxt->boundColsInfo.pColIndex[c]];




26,755,838✔





340



      SColVal* pVal = taosArrayGet(pTableCxt->pValues, pTableCxt->boundColsInfo.pColIndex[c]);




26,779,894✔





341



      TSDB_CHECK_NULL(pVal, ret, lino, end, terrno);




26,505,371✔





342



      void** p = taosHashGet(rowData, pColSchema->name, strlen(pColSchema->name));




26,505,371✔





343



      if (p == NULL) {




26,829,675✔





344



        continue;




63,476✔





345



      }










346



      SSmlKv* kv = *(SSmlKv**)p;




26,766,199✔





347



      TSDB_CHECK_CONDITION(kv->type == pColSchema->type, ret, lino, end, TSDB_CODE_TSC_INVALID_OPERATION);




26,767,755✔





348












349



      if (pColSchema->type == TSDB_DATA_TYPE_TIMESTAMP) {




26,775,451✔





350



        kv->i = convertTimePrecision(kv->i, TSDB_TIME_PRECISION_NANO, pTableMeta->tableInfo.precision);




4,435,645✔





351



      }










352



      if (kv->type == TSDB_DATA_TYPE_NCHAR) {




26,777,065✔





353



        ret = smlMbsToUcs4(kv->value, kv->length, (void**)&pVal->value.pData, (int32_t*)&pVal->value.nData,




229,107✔





354



                           pColSchema->bytes - VARSTR_HEADER_SIZE, charsetCxt);




229,107✔





355



        TSDB_CHECK_CODE(ret, lino, end);




229,107✔





356



      } else if (kv->type == TSDB_DATA_TYPE_BINARY) {




26,436,921✔





357



        pVal->value.nData = kv->length;




3,356,585✔





358



        pVal->value.pData = (uint8_t*)kv->value;




3,356,661✔





359



      } else if (kv->type == TSDB_DATA_TYPE_GEOMETRY || kv->type == TSDB_DATA_TYPE_VARBINARY) {




23,090,237✔





360



        pVal->value.nData = kv->length;




8,568✔





361



        pVal->value.pData = taosMemoryMalloc(kv->length);




9,160✔





362



        TSDB_CHECK_NULL(pVal->value.pData, ret, lino, end, terrno);




9,136✔





363



        (void)memcpy(pVal->value.pData, (uint8_t*)kv->value, kv->length);




9,136✔





364



      } else {










365



        valueSetDatum(&pVal->value, kv->type, &(kv->value), kv->length);




23,106,718✔





366



      }










367



      pVal->flag = CV_FLAG_VALUE;




26,770,602✔





368



    }










369












370



    SRow** pRow = taosArrayReserve(pTableCxt->pData->aRowP, 1);




4,435,781✔





371



    TSDB_CHECK_NULL(pRow, ret, lino, end, terrno);




4,394,612✔





372



    SRowBuildScanInfo sinfo = {0};




4,394,612✔





373



    ret = tRowBuild(pTableCxt->pValues, pTableCxt->pSchema, pRow, &sinfo);




4,422,251✔





374



    TSDB_CHECK_CODE(ret, lino, end);




4,435,867✔





375



    SRowKey key = {0};




4,435,867✔





376



    tRowGetKey(*pRow, &key);




8,869,440✔





377



    insCheckTableDataOrder(pTableCxt, &key);




4,433,943✔





378



    clearColValArraySml(pTableCxt->pValues);




4,440,568✔





379



  }










380












381



end:




622,513✔





382



  if (ret != 0) {




632,852✔





383



    uError("%s failed at %d since %s", __func__, lino, tstrerror(ret));




×







384



    ret = buildInvalidOperationMsg(&pBuf, tstrerror(ret));




×







385



  }










386



  qDestroyBoundColInfo(&bindTags);




632,852✔





387



  tdDestroySVCreateTbReq(pCreateTblReq);




632,789✔





388



  taosMemoryFree(pCreateTblReq);




632,789✔





389



  taosArrayDestroy(tagName);




632,752✔





390



  return ret;




632,737✔





391



}










392












393



int32_t smlInitHandle(SQuery** query) {




531,504✔





394



  int32_t             lino = 0;




531,504✔





395



  int32_t             code = 0;




531,504✔





396



  SQuery*             pQuery = NULL;




531,504✔





397



  SVnodeModifyOpStmt* stmt = NULL;




531,504✔





398



  TSDB_CHECK_NULL(query, code, lino, end, TSDB_CODE_INVALID_PARA);




531,504✔





399












400



  *query = NULL;




531,504✔





401



  code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);




531,504✔





402



  TSDB_CHECK_CODE(code, lino, end);




531,528✔





403



  pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;




531,528✔





404



  pQuery->haveResultSet = false;




531,528✔





405



  pQuery->msgType = TDMT_VND_SUBMIT;




531,528✔





406



  code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&stmt);




531,528✔





407



  TSDB_CHECK_CODE(code, lino, end);




531,516✔





408



  stmt->pTableBlockHashObj = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);




531,516✔





409



  TSDB_CHECK_NULL(stmt->pTableBlockHashObj, code, lino, end, terrno);




531,540✔





410



  stmt->freeHashFunc = insDestroyTableDataCxtHashMapSml;




531,540✔





411



  stmt->freeArrayFunc = insDestroyVgroupDataCxtList;




531,540✔





412












413



  pQuery->pRoot = (SNode*)stmt;




531,540✔





414



  *query = pQuery;




531,540✔





415



  return code;




531,540✔





416












417



end:




×







418



  if (code != 0) {




×







419



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




×







420



  }










421



  nodesDestroyNode((SNode*)stmt);




×







422



  qDestroyQuery(pQuery);




×







423



  return code;




×







424



}










425












426



int32_t smlBuildOutput(SQuery* handle, SHashObj* pVgHash) {




406,412✔





427



  int32_t lino = 0;




406,412✔





428



  int32_t code = 0;




406,412✔





429












430



  SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)(handle)->pRoot;




406,412✔





431



  code = insMergeTableDataCxt(pStmt->pTableBlockHashObj, &pStmt->pVgDataBlocks, true);




406,375✔





432



  TSDB_CHECK_CODE(code, lino, end);




406,387✔





433



  code = insBuildVgDataBlocks(pVgHash, pStmt->pVgDataBlocks, &pStmt->pDataBlocks, false);




406,387✔





434



  TSDB_CHECK_CODE(code, lino, end);




406,289✔





435












436



end:




406,289✔





437



  if (code != 0) {




406,289✔





438



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




×







439



  }










440



  return code;




406,289✔





441



}










442












443



int32_t smlBuildOutputRaw(SQuery* handle, SHashObj* pVgHash) {




×







444



  int32_t lino = 0;




×







445



  int32_t code = 0;




×







446












447



  SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)(handle)->pRoot;




×







448



  code = insBuildVgDataBlocks(pVgHash, pStmt->pVgDataBlocks, &pStmt->pDataBlocks, false);




×







449



  TSDB_CHECK_CODE(code, lino, end);




×







450












451



  end:




×







452



  if (code != 0) {




×







453



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




×







454



  }










455



  return code;




×







456



}
























    

  • 

    •