taosdata / TDengine / #5044

coverage: 73.169% (+0.06%) from 73.107%
#5044

push

travis-ci

web-flow 
feat: [6659794715] cpu limit (#35153)

244 of 275 new or added lines in 23 files covered. (88.73%)

526 existing lines in 141 files now uncovered.

277745 of 379596 relevant lines covered (73.17%)

133740972.66 hits per line

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

79.34
/source/common/src/msg/streamMsg.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 "streamMsg.h"










17



#include "taos.h"










18



#include "tarray.h"










19



#include "tdatablock.h"










20



#include "thash.h"










21



#include "tlist.h"










22



#include "tmsg.h"










23



#include "os.h"










24



#include "tcommon.h"










25



#include "tsimplehash.h"










26












27



int32_t tEncodeSStreamMgmtReq(SEncoder* pEncoder, const SStreamMgmtReq* pReq) {




143,176✔





28



  int32_t code = 0;




143,176✔





29



  int32_t lino = 0;




143,176✔





30



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->reqId));




286,352✔





31



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->type));




286,352✔





32



  switch (pReq->type) {




143,176✔





33



    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {




137,610✔





34



      if (pReq->cont.pReqs) {




137,610✔





35



        int32_t num = taosArrayGetSize(pReq->cont.pReqs);




137,610✔





36



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));




137,610✔





37



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




535,194✔





38



          SStreamDbTableName* pName = taosArrayGet(pReq->cont.pReqs, i);




397,584✔





39



          TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, pName->dbFName, strlen(pName->dbFName) + 1));




795,168✔





40



          TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, pName->tbName, strlen(pName->tbName) + 1));




795,168✔





41



        }










42



      } else {










43



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));




×







44



      }










45



      break;




137,610✔





46



    }










47



    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {




5,566✔





48



      if (pReq->cont.pReqs) {




5,566✔





49



        int32_t num = taosArrayGetSize(pReq->cont.pReqs);




5,566✔





50



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, num));




5,566✔





51



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




11,132✔





52



          SStreamOReaderDeployReq* pDeploy = taosArrayGet(pReq->cont.pReqs, i);




5,566✔





53



          int32_t vgIdNum = taosArrayGetSize(pDeploy->vgIds);




5,566✔





54



          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pDeploy->execId));




11,132✔





55



          TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pDeploy->uid));




11,132✔





56



          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgIdNum));




5,566✔





57



          for (int32_t n = 0; n < vgIdNum; ++n) {




11,132✔





58



            TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *(int32_t*)taosArrayGet(pDeploy->vgIds, n)));




11,132✔





59



          }










60



        }










61



      } else {










62



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));




×







63



      }










64



      break;




5,566✔





65



    }










66



    default:




×







67



      code = TSDB_CODE_STREAM_INVALID_TASK_TYPE;




×







68



      break;




×







69



  }










70












71



_exit:




143,176✔





72












73



  return code;




143,176✔





74



}










75












76



void tFreeRunnerOReaderDeployReq(void* param) {




8,349✔





77



  SStreamOReaderDeployReq* pReq = (SStreamOReaderDeployReq*)param;




8,349✔





78



  if (pReq) {




8,349✔





79



    taosArrayDestroy(pReq->vgIds);




8,349✔





80



  }










81



}




8,349✔





82












83



void tFreeSStreamMgmtReq(SStreamMgmtReq* pReq) {




285,550✔





84



  if (NULL == pReq) {




285,550✔





85



    return;




71,588✔





86



  }










87












88



  switch (pReq->type) {




213,962✔





89



    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:




205,613✔





90



      taosArrayDestroy(pReq->cont.pReqs);




205,613✔





91



      break;




205,613✔





92



    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER:




8,349✔





93



      taosArrayDestroyEx(pReq->cont.pReqs, tFreeRunnerOReaderDeployReq);




8,349✔





94



      break;




8,349✔





95



    default:




×







96



      break;




×







97



  }










98



}










99












100












101



int32_t tCloneSStreamMgmtReq(SStreamMgmtReq* pSrc, SStreamMgmtReq** ppDst) {




71,588✔





102



  *ppDst = NULL;




71,588✔





103



  










104



  if (NULL == pSrc) {




71,588✔





105



    return TSDB_CODE_SUCCESS;




×







106



  }










107












108



  int32_t code = 0, lino = 0;




71,588✔





109



  *ppDst = taosMemoryCalloc(1, sizeof(SStreamMgmtReq));




71,588✔





110



  TSDB_CHECK_NULL(*ppDst, code, lino, _exit, terrno);




71,588✔





111












112



  memcpy(*ppDst, pSrc, sizeof(*pSrc));




71,588✔





113



  if (pSrc->cont.pReqs) {




71,588✔





114



    switch (pSrc->type) {




71,588✔





115



      case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER:




68,805✔





116



        (*ppDst)->cont.pReqs = taosArrayDup(pSrc->cont.pReqs, NULL);




68,805✔





117



        TSDB_CHECK_NULL((*ppDst)->cont.pReqs, code, lino, _exit, terrno);




68,805✔





118



        break;




68,805✔





119



      case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {




2,783✔





120



        int32_t reqNum = taosArrayGetSize(pSrc->cont.pReqs);




2,783✔





121



        (*ppDst)->cont.pReqs = taosArrayInit_s(sizeof(SStreamOReaderDeployReq), reqNum);




2,783✔





122



        TSDB_CHECK_NULL((*ppDst)->cont.pReqs, code, lino, _exit, terrno);




2,783✔





123



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




5,566✔





124



          SStreamOReaderDeployReq* pNew = taosArrayGet((*ppDst)->cont.pReqs, i);




2,783✔





125



          SStreamOReaderDeployReq* pReq = taosArrayGet(pSrc->cont.pReqs, i);




2,783✔





126



          pNew->vgIds = taosArrayDup(pReq->vgIds, NULL);




2,783✔





127



          TSDB_CHECK_NULL(pNew->vgIds, code, lino, _exit, terrno);




2,783✔





128



          pNew->execId = pReq->execId;




2,783✔





129



          pNew->uid = pReq->uid;




2,783✔





130



        }










131



        break;




2,783✔





132



      }  










133



      default:




×







134



        break;




×







135



    }










136



  }










137



  










138



_exit:




×







139












140



  if (code) {




71,588✔





141



    tFreeSStreamMgmtReq(*ppDst);




×







142



    taosMemoryFreeClear(*ppDst);




×







143



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




×







144



  }










145



  










146



  return code;




71,588✔





147



}










148












149












150



int32_t tDecodeSStreamMgmtReq(SDecoder* pDecoder, SStreamMgmtReq* pReq) {




71,588✔





151



  int32_t code = 0;




71,588✔





152



  int32_t lino = 0;




71,588✔





153












154



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->reqId));




143,176✔





155



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pReq->type));




143,176✔





156



  switch (pReq->type) {




71,588✔





157



    case STREAM_MGMT_REQ_TRIGGER_ORIGTBL_READER: {




68,805✔





158



      int32_t num = 0;




68,805✔





159



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));




68,805✔





160



      if (num > 0) {




68,805✔





161



        pReq->cont.pReqs = taosArrayInit(num, sizeof(SStreamDbTableName));




68,805✔





162



        TSDB_CHECK_NULL(pReq->cont.pReqs, code, lino, _exit, terrno);




68,805✔





163



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




267,597✔





164



          SStreamDbTableName* p = taosArrayReserve(pReq->cont.pReqs, 1);




198,792✔





165



          TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, p->dbFName));




198,792✔





166



          TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, p->tbName));




198,792✔





167



        }










168



      }










169



      break;




68,805✔





170



    }










171



    case STREAM_MGMT_REQ_RUNNER_ORIGTBL_READER: {




2,783✔





172



      int32_t num = 0, vgIdNum = 0;




2,783✔





173



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &num));




2,783✔





174



      if (num > 0) {




2,783✔





175



        pReq->cont.pReqs = taosArrayInit_s(sizeof(SStreamOReaderDeployReq), num);




2,783✔





176



        TSDB_CHECK_NULL(pReq->cont.pReqs, code, lino, _exit, terrno);




2,783✔





177



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




5,566✔





178



          SStreamOReaderDeployReq* p = taosArrayGet(pReq->cont.pReqs, i);




2,783✔





179



          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &p->execId));




5,566✔





180



          TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &p->uid));




5,566✔





181



          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgIdNum));




2,783✔





182



          if (vgIdNum > 0) {




2,783✔





183



            p->vgIds = taosArrayInit_s(sizeof(int32_t), vgIdNum);




2,783✔





184



            TSDB_CHECK_NULL(p->vgIds, code, lino, _exit, terrno);




2,783✔





185



          }










186



          for (int32_t n = 0; n < vgIdNum; ++n) {




5,566✔





187



            int32_t* vgId = taosArrayGet(p->vgIds, n);




2,783✔





188



            TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));




2,783✔





189



          }










190



        }










191



      }










192



      break;




2,783✔





193



    }










194



    default:




×







195



      code = TSDB_CODE_STREAM_INVALID_TASK_TYPE;




×







196



      break;




×







197



  }










198












199



_exit:




71,588✔





200












201



  return code;  




71,588✔





202



}










203












204



int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) {




117,259,492✔





205



  int32_t code = 0;




117,259,492✔





206



  int32_t lino;










207












208



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->type));




234,518,984✔





209



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->streamId));




234,518,984✔





210



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->taskId));




234,518,984✔





211












212



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->flags));




234,518,984✔





213



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pTask->seriousId));




234,518,984✔





214



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->deployId));




234,518,984✔





215



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->nodeId));




234,518,984✔





216



  // SKIP SESSIONID










217



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->taskIdx));




234,518,984✔





218



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->status));




234,518,984✔





219



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->detailStatus));




234,518,984✔





220



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pTask->errorCode));




234,518,984✔





221



  if (pTask->pMgmtReq) {




117,259,492✔





222



    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 1));




143,176✔





223



    TAOS_CHECK_EXIT(tEncodeSStreamMgmtReq(pEncoder, pTask->pMgmtReq));




143,176✔





224



  } else {










225



    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, 0));




117,116,316✔





226



  }










227












228



_exit:




117,116,316✔





229












230



  return code;




117,259,492✔





231



}










232












233












234



int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask) {




56,660,904✔





235



  int32_t code = 0;




56,660,904✔





236



  int32_t lino;










237












238



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pTask->type));




113,321,808✔





239



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->streamId));




113,321,808✔





240



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->taskId));




113,321,808✔





241



  










242



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->flags));




113,321,808✔





243



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pTask->seriousId));




113,321,808✔





244



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->deployId));




113,321,808✔





245



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->nodeId));




113,321,808✔





246



  // SKIP SESSIONID










247



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->taskIdx));




113,321,808✔





248



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, (int32_t*)&pTask->status));




113,321,808✔





249



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->detailStatus));




113,321,808✔





250



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pTask->errorCode));




113,321,808✔





251



  int32_t req = 0;




56,660,904✔





252



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &req));




56,660,904✔





253



  if (req) {




56,660,904✔





254



    pTask->pMgmtReq = taosMemoryCalloc(1, sizeof(SStreamMgmtReq));




71,588✔





255



    TSDB_CHECK_NULL(pTask->pMgmtReq, code, lino, _exit, terrno);




71,588✔





256



    TAOS_CHECK_EXIT(tDecodeSStreamMgmtReq(pDecoder, pTask->pMgmtReq));




71,588✔





257



  }










258












259



_exit:




56,660,904✔





260












261



  return code;




56,660,904✔





262



}










263












264



int32_t tEncodeSSTriggerRecalcProgress(SEncoder* pEncoder, const SSTriggerRecalcProgress* pProgress) {




×







265



  int32_t code = 0;




×







266



  int32_t lino;










267












268



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pProgress->recalcId));




×







269



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pProgress->progress));




×







270



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pProgress->start));




×







271



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pProgress->end));




×







272












273



_exit:




×







274












275



  return code;




×







276



}










277












278



int32_t tDecodeSSTriggerRecalcProgress(SDecoder* pDecoder, SSTriggerRecalcProgress* pProgress) {




×







279



  int32_t code = 0;




×







280



  int32_t lino;










281












282



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pProgress->recalcId));




×







283



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pProgress->progress));




×







284



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pProgress->start));




×







285



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pProgress->end));




×







286












287



_exit:




×







288












289



  return code;




×







290



}










291












292












293



int32_t tEncodeSSTriggerRuntimeStatus(SEncoder* pEncoder, const SSTriggerRuntimeStatus* pStatus) {




7,065,578✔





294



  int32_t code = 0;




7,065,578✔





295



  int32_t lino;










296












297



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->autoRecalcNum));




14,131,156✔





298



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->realtimeSessionNum));




14,131,156✔





299



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->historySessionNum));




14,131,156✔





300



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->recalcSessionNum));




14,131,156✔





301



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStatus->histroyProgress));




14,131,156✔





302












303



  int32_t recalcNum = (int32_t)taosArrayGetSize(pStatus->userRecalcs);




7,065,578✔





304



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));




7,065,578✔





305



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




7,065,578✔





306



    SSTriggerRecalcProgress* pProgress = taosArrayGet(pStatus->userRecalcs, i);




×







307



    TAOS_CHECK_EXIT(tEncodeSSTriggerRecalcProgress(pEncoder, pProgress));




×







308



  }










309












310



_exit:




7,065,578✔





311












312



  return code;




7,065,578✔





313



}










314












315



int32_t tDecodeSSTriggerRuntimeStatus(SDecoder* pDecoder, SSTriggerRuntimeStatus* pStatus) {




3,375,813✔





316



  int32_t code = 0;




3,375,813✔





317



  int32_t lino;










318












319



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->autoRecalcNum));




6,751,626✔





320



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->realtimeSessionNum));




6,751,626✔





321



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->historySessionNum));




6,751,626✔





322



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->realtimeSessionNum));




6,751,626✔





323



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pStatus->histroyProgress));




6,751,626✔





324












325



  int32_t recalcNum = 0;




3,375,813✔





326



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));




3,375,813✔





327



  if (recalcNum > 0) {




3,375,813✔





328



    pStatus->userRecalcs = taosArrayInit_s(sizeof(SSTriggerRecalcProgress), recalcNum);




×







329



    if (NULL == pStatus->userRecalcs) {




×







330



      code = terrno;




×







331



      goto _exit;




×







332



    }










333



  }










334












335



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




3,375,813✔





336



    SSTriggerRecalcProgress* pProgress = taosArrayGet(pStatus->userRecalcs, i);




×







337



    TAOS_CHECK_EXIT(tDecodeSSTriggerRecalcProgress(pDecoder, pProgress));




×







338



  }










339












340



_exit:




3,375,813✔





341












342



  return code;




3,375,813✔





343



}










344












345












346



int32_t tEncodeStreamHbMsg(SEncoder* pEncoder, const SStreamHbMsg* pReq) {




40,193,926✔





347



  int32_t code = 0;




40,193,926✔





348



  int32_t lino;










349












350



  TAOS_CHECK_EXIT(tStartEncode(pEncoder));




40,193,926✔





351



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->dnodeId));




80,387,852✔





352



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->streamGId));




80,387,852✔





353



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->snodeId));




80,387,852✔





354



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->runnerThreadNum));




80,387,852✔





355












356



  int32_t vgLeaderNum = taosArrayGetSize(pReq->pVgLeaders);




40,193,926✔





357



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgLeaderNum));




40,193,926✔





358



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




165,732,042✔





359



    int32_t* vgId = taosArrayGet(pReq->pVgLeaders, i);




125,538,116✔





360



    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));




251,076,232✔





361



  }










362



  










363



  int32_t statusNum = taosArrayGetSize(pReq->pStreamStatus);




40,193,926✔





364



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, statusNum));




40,193,926✔





365



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




152,540,326✔





366



    SStmTaskStatusMsg* pStatus = taosArrayGet(pReq->pStreamStatus, i);




112,346,400✔





367



    TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)pStatus));




112,346,400✔





368



  }










369












370



  int32_t reqNum = taosArrayGetSize(pReq->pStreamReq);




40,193,926✔





371



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, reqNum));




40,193,926✔





372



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




40,337,102✔





373



    int32_t* idx = taosArrayGet(pReq->pStreamReq, i);




143,176✔





374



    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *idx));




286,352✔





375



  }










376












377



  int32_t triggerNum = taosArrayGetSize(pReq->pTriggerStatus);




40,193,926✔





378



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, triggerNum));




40,193,926✔





379



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




47,259,504✔





380



    SSTriggerRuntimeStatus* pTrigger = taosArrayGet(pReq->pTriggerStatus, i);




7,065,578✔





381



    TAOS_CHECK_EXIT(tEncodeSSTriggerRuntimeStatus(pEncoder, pTrigger));




7,065,578✔





382



  }










383



  










384



  tEndEncode(pEncoder);




40,193,926✔





385












386



_exit:




40,193,926✔





387



  if (code) {




40,193,926✔





388



    return code;




×







389



  } else {










390



    return pEncoder->pos;




40,193,926✔





391



  }










392



}










393












394



int32_t tDecodeStreamHbMsg(SDecoder* pDecoder, SStreamHbMsg* pReq) {




19,273,300✔





395



  int32_t code = 0;




19,273,300✔





396



  int32_t lino;










397












398



  TAOS_CHECK_EXIT(tStartDecode(pDecoder));




19,273,300✔





399



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->dnodeId));




38,546,600✔





400



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->streamGId));




38,546,600✔





401



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->snodeId));




38,546,600✔





402



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->runnerThreadNum));




38,546,600✔





403












404



  int32_t vgLearderNum = 0;




19,273,300✔





405



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgLearderNum));




19,273,300✔





406



  if (vgLearderNum > 0) {




19,273,300✔





407



    pReq->pVgLeaders = taosArrayInit(vgLearderNum, sizeof(int32_t));




15,187,399✔





408



    if (NULL == pReq->pVgLeaders) {




15,187,399✔





409



      code = terrno;




×







410



      goto _exit;




×







411



    }










412



  }










413



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




80,572,389✔





414



    int32_t vgId = 0;




61,299,089✔





415



    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));




61,299,089✔





416



    if (NULL == taosArrayPush(pReq->pVgLeaders, &vgId)) {




122,598,178✔





417



      code = terrno;




×







418



      goto _exit;




×







419



    }










420



  }










421












422












423



  int32_t statusNum = 0;




19,273,300✔





424



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &statusNum));




19,273,300✔





425



  if (statusNum > 0) {




19,273,300✔





426



    pReq->pStreamStatus = taosArrayInit_s(sizeof(SStmTaskStatusMsg), statusNum);




1,633,060✔





427



    if (NULL == pReq->pStreamStatus) {




1,633,060✔





428



      code = terrno;




×







429



      goto _exit;




×







430



    }










431



  }










432



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




73,494,942✔





433



    SStmTaskStatusMsg* pTask = taosArrayGet(pReq->pStreamStatus, i);




54,221,642✔





434



    if (NULL == pTask) {




54,221,642✔





435



      code = terrno;




×







436



      goto _exit;




×







437



    }










438



    TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)pTask));




54,221,642✔





439



  }










440












441












442



  int32_t reqNum = 0;




19,273,300✔





443



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &reqNum));




19,273,300✔





444



  if (reqNum > 0) {




19,273,300✔





445



    pReq->pStreamReq = taosArrayInit_s(sizeof(int32_t), reqNum);




25,607✔





446



    if (NULL == pReq->pStreamReq) {




25,607✔





447



      code = terrno;




×







448



      goto _exit;




×







449



    }










450



  }










451



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




19,344,888✔





452



    int32_t* pIdx = taosArrayGet(pReq->pStreamReq, i);




71,588✔





453



    if (NULL == pIdx) {




71,588✔





454



      code = terrno;




×







455



      goto _exit;




×







456



    }










457



    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, pIdx));




71,588✔





458



  }










459












460












461



  int32_t triggerNum = 0;




19,273,300✔





462



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerNum));




19,273,300✔





463



  if (triggerNum > 0) {




19,273,300✔





464



    pReq->pTriggerStatus = taosArrayInit_s(sizeof(SSTriggerRuntimeStatus), triggerNum);




768,376✔





465



    if (NULL == pReq->pTriggerStatus) {




768,376✔





466



      code = terrno;




×







467



      goto _exit;




×







468



    }










469



  }










470



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




22,649,113✔





471



    SSTriggerRuntimeStatus* pStatus = taosArrayGet(pReq->pTriggerStatus, i);




3,375,813✔





472



    if (NULL == pStatus) {




3,375,813✔





473



      code = terrno;




×







474



      goto _exit;




×







475



    }










476



    TAOS_CHECK_EXIT(tDecodeSSTriggerRuntimeStatus(pDecoder, pStatus));




3,375,813✔





477



  }










478












479



  










480



  tEndDecode(pDecoder);




19,273,300✔





481












482



_exit:




19,273,300✔





483



  return code;




19,273,300✔





484



}










485












486



void tFreeSSTriggerRuntimeStatus(void* param) {




6,908,602✔





487



  SSTriggerRuntimeStatus* pStatus = (SSTriggerRuntimeStatus*)param;




6,908,602✔





488



  if (NULL == pStatus) {




6,908,602✔





489



    return;




×







490



  }










491



  taosArrayDestroy(pStatus->userRecalcs);




6,908,602✔





492



}










493












494



void tCleanupStreamHbMsg(SStreamHbMsg* pMsg, bool deepClean) {




115,451,945✔





495



  if (pMsg == NULL) {




115,451,945✔





496



    return;




×







497



  }










498












499



  taosArrayDestroy(pMsg->pVgLeaders);




115,451,945✔





500



  if (deepClean) {




115,451,945✔





501



    int32_t reqNum = taosArrayGetSize(pMsg->pStreamReq);




115,451,945✔





502



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




115,595,121✔





503



      int32_t* idx = taosArrayGet(pMsg->pStreamReq, i);




143,176✔





504



      SStmTaskStatusMsg* pTask = taosArrayGet(pMsg->pStreamStatus, *idx);




143,176✔





505



      if (NULL == pTask) {




143,176✔





506



        continue;




×







507



      }










508












509



      tFreeSStreamMgmtReq(pTask->pMgmtReq);




143,176✔





510



      taosMemoryFree(pTask->pMgmtReq);




143,176✔





511



    }










512



  }










513



  taosArrayDestroy(pMsg->pStreamReq);




115,451,945✔





514



  taosArrayDestroy(pMsg->pStreamStatus);




115,451,945✔





515



  taosArrayDestroyEx(pMsg->pTriggerStatus, tFreeSSTriggerRuntimeStatus);




115,451,945✔





516



}










517












518



int32_t tEncodeSStreamReaderDeployFromTrigger(SEncoder* pEncoder, const SStreamReaderDeployFromTrigger* pMsg) {




722,866✔





519



  int32_t code = 0;




722,866✔





520



  int32_t lino;










521












522



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, (const uint8_t*)pMsg->triggerTblName, pMsg->triggerTblName == NULL ? 0 : (int32_t)strlen(pMsg->triggerTblName) + 1));




1,445,732✔





523



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->triggerTblUid));




1,445,732✔





524



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->triggerTblSuid));




1,445,732✔





525



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerTblType));




1,445,732✔





526



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblVirt));




1,445,732✔





527



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->deleteReCalc));




1,445,732✔





528



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->deleteOutTbl));




1,445,732✔





529



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->partitionCols, pMsg->partitionCols == NULL ? 0 : (int32_t)strlen(pMsg->partitionCols) + 1));




1,445,732✔





530



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerCols, pMsg->triggerCols == NULL ? 0 : (int32_t)strlen(pMsg->triggerCols) + 1));




1,445,732✔





531



  //TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerPrevFilter, pMsg->triggerPrevFilter == NULL ? 0 : (int32_t)strlen(pMsg->triggerPrevFilter) + 1));










532



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerScanPlan, pMsg->triggerScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->triggerScanPlan) + 1));




1,445,732✔





533



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcCacheScanPlan, pMsg->calcCacheScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->calcCacheScanPlan) + 1));




1,445,732✔





534












535



_exit:




722,866✔





536












537



  return code;




722,866✔





538



}










539












540



int32_t tEncodeSStreamReaderDeployFromCalc(SEncoder* pEncoder, const SStreamReaderDeployFromCalc* pMsg) {




846,146✔





541



  int32_t code = 0;




846,146✔





542



  int32_t lino;










543












544



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));




1,692,292✔





545



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcScanPlan, pMsg->calcScanPlan == NULL ? 0 : (int32_t)strlen(pMsg->calcScanPlan) + 1));




1,692,292✔





546












547



_exit:




846,146✔





548












549



  return code;




846,146✔





550



}










551












552












553



int32_t tEncodeSStreamReaderDeployMsg(SEncoder* pEncoder, const SStreamReaderDeployMsg* pMsg) {




1,569,012✔





554



  int32_t code = 0;




1,569,012✔





555



  int32_t lino;










556












557



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerReader));




3,138,024✔





558



  if (pMsg->triggerReader) {




1,569,012✔





559



    TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployFromTrigger(pEncoder, &pMsg->msg.trigger));




722,866✔





560



  } else {










561



    TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployFromCalc(pEncoder, &pMsg->msg.calc));




846,146✔





562



  }










563



  










564



_exit:




846,146✔





565












566



  return code;




1,569,012✔





567



}










568












569



int32_t tEncodeSStreamTaskAddr(SEncoder* pEncoder, const SStreamTaskAddr* pMsg) {




2,192,718✔





570



  int32_t code = 0;




2,192,718✔





571



  int32_t lino;










572












573



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->taskId));




4,385,436✔





574



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->nodeId));




4,385,436✔





575



  TAOS_CHECK_EXIT(tEncodeSEpSet(pEncoder, &pMsg->epset));




2,192,718✔





576












577



_exit:




2,192,718✔





578












579



  return code;




2,192,718✔





580



}










581












582



int32_t tEncodeSStreamRunnerTarget(SEncoder* pEncoder, const SStreamRunnerTarget* pMsg) {




1,439,196✔





583



  int32_t code = 0;




1,439,196✔





584



  int32_t lino;










585












586



  TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, &pMsg->addr));




1,439,196✔





587



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));




2,878,392✔





588












589



_exit:




1,439,196✔





590












591



  return code;




1,439,196✔





592



}










593












594












595



int32_t tEncodeSStreamTriggerDeployMsg(SEncoder* pEncoder, const SStreamTriggerDeployMsg* pMsg) {




486,670✔





596



  int32_t code = 0;




486,670✔





597



  int32_t lino;










598












599



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerType));




973,340✔





600



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->igDisorder));




973,340✔





601



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->fillHistory));




973,340✔





602



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->fillHistoryFirst));




973,340✔





603



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->lowLatencyCalc));




973,340✔





604



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->igNoDataTrigger));




973,340✔





605



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->enableMultiGroupCalc));




973,340✔





606



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblVirt));




973,340✔





607



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->triggerHasPF));




973,340✔





608



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->isTriggerTblStb));




973,340✔





609



  int32_t partitionColsLen = pMsg->partitionCols == NULL ? 0 : (int32_t)strlen((char*)pMsg->partitionCols) + 1;




486,670✔





610



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->partitionCols, partitionColsLen));




973,340✔





611












612



  int32_t addrSize = (int32_t)taosArrayGetSize(pMsg->pNotifyAddrUrls);




486,670✔





613



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));




486,670✔





614



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




604,156✔





615



    const char *url = taosArrayGetP(pMsg->pNotifyAddrUrls, i);




117,486✔





616



    TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, url, NULL == url ? 0 : (int32_t)strlen(url) + 1));




234,972✔





617



  }










618



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->notifyEventTypes));




973,340✔





619



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->addOptions));




973,340✔





620



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->notifyHistory));




973,340✔





621












622



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->maxDelay));




973,340✔





623



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->fillHistoryStartTime));




973,340✔





624



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->watermark));




973,340✔





625



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->expiredTime));




973,340✔





626



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->idleTimeoutMs));




973,340✔





627












628



  switch (pMsg->triggerType) {




486,670✔





629



    case WINDOW_TYPE_SESSION: {




17,946✔





630



      // session trigger










631



      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->trigger.session.slotId));




35,892✔





632



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.session.sessionVal));




35,892✔





633



      break;




17,946✔





634



    }










635



    case WINDOW_TYPE_STATE: {




177,714✔





636



      /*










637



       * state trigger – always v2 format:










638



       * I16(STATE_WIN_SLOT_SENTINEL_V2) + I32(slotNum)










639



       *   + N*I16(slotId) + ...










640



       */










641



      int32_t slotNum = pMsg->trigger.stateWin.pSlotIds == NULL ?




355,428✔





642



        0 : taosArrayGetSize(pMsg->trigger.stateWin.pSlotIds);




177,714✔





643



      TAOS_CHECK_EXIT(




177,714✔





644



        tEncodeI16(pEncoder, STATE_WIN_SLOT_SENTINEL_V2));










645



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, slotNum));




177,714✔





646



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




379,250✔





647



        TAOS_CHECK_EXIT(tEncodeI16(




403,072✔





648



          pEncoder,










649



          *(int16_t*)taosArrayGet(










650



            pMsg->trigger.stateWin.pSlotIds, i)));










651



      }










652



      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->trigger.stateWin.extend));




355,428✔





653



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.stateWin.trueForType));




355,428✔





654



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.stateWin.trueForCount));




355,428✔





655



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.stateWin.trueForDuration));




355,428✔





656



      int32_t stateWindowZerothLen =




177,714✔





657



          pMsg->trigger.stateWin.zeroth == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.stateWin.zeroth) + 1;




177,714✔





658



      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.stateWin.zeroth, stateWindowZerothLen));




355,428✔





659



      int32_t stateWindowExprLen =




177,714✔





660



          pMsg->trigger.stateWin.expr == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.stateWin.expr) + 1;




177,714✔





661



      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.stateWin.expr, stateWindowExprLen));




355,428✔





662



      break;




177,714✔





663



    }










664



    case WINDOW_TYPE_INTERVAL: {




166,868✔





665



      // slide trigger










666



      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.intervalUnit));




333,736✔





667



      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.slidingUnit));




333,736✔





668



      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.offsetUnit));




333,736✔





669



      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.soffsetUnit));




333,736✔





670



      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.sliding.precision));




333,736✔





671



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.interval));




333,736✔





672



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.offset));




333,736✔





673



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.sliding));




333,736✔





674



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.sliding.soffset));




333,736✔





675



      break;




166,868✔





676



    }










677



    case WINDOW_TYPE_EVENT: {




52,894✔





678



      // event trigger










679



      int32_t eventWindowStartCondLen = pMsg->trigger.event.startCond == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.event.startCond) + 1;




52,894✔





680



      int32_t eventWindowEndCondLen = pMsg->trigger.event.endCond == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.event.endCond) + 1;




52,894✔





681












682



      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.event.startCond, eventWindowStartCondLen));




105,788✔





683



      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.event.endCond, eventWindowEndCondLen));




105,788✔





684



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.event.trueForType));




105,788✔





685



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->trigger.event.trueForCount));




105,788✔





686



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.event.trueForDuration));




105,788✔





687



      break;




52,894✔





688



    }










689



    case WINDOW_TYPE_COUNT: {




48,452✔





690



      // count trigger










691



      int32_t countWindowCondColsLen = pMsg->trigger.count.condCols == NULL ? 0 : (int32_t)strlen((char*)pMsg->trigger.count.condCols) + 1;




48,452✔





692



      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->trigger.count.condCols, countWindowCondColsLen));




96,904✔





693












694



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.count.countVal));




96,904✔





695



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.count.sliding));




96,904✔





696



      break;




48,452✔





697



    }










698



    case WINDOW_TYPE_PERIOD: {




22,796✔





699



      // period trigger










700



      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.periodUnit));




45,592✔





701



      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.offsetUnit));




45,592✔





702



      TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->trigger.period.precision));




45,592✔





703



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.period.period));




45,592✔





704



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->trigger.period.offset));




45,592✔





705



      break;




22,796✔





706



    }










707



    default:




×







708



      TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INTERNAL_ERROR);




×







709



      break;




×







710



  }










711












712



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->eventTypes));




973,340✔





713



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->placeHolderBitmap));




973,340✔





714



  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->calcTsSlotId));




973,340✔





715



  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->triTsSlotId));




973,340✔





716



  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->calcPkSlotId));




973,340✔





717



  TAOS_CHECK_EXIT(tEncodeI16(pEncoder, pMsg->triPkSlotId));




973,340✔





718



  int32_t triggerPrevFilterLen = (pMsg->triggerPrevFilter == NULL) ? 0 : ((int32_t)strlen(pMsg->triggerPrevFilter) + 1);




486,670✔





719



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerPrevFilter, triggerPrevFilterLen));




973,340✔





720



  int32_t triggerScanPlanLen = (pMsg->triggerScanPlan == NULL) ? 0 : ((int32_t)strlen(pMsg->triggerScanPlan) + 1);




486,670✔





721



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->triggerScanPlan, triggerScanPlanLen));




973,340✔





722



  int32_t calcCacheScanPlanLen = (pMsg->calcCacheScanPlan == NULL) ? 0 : ((int32_t)strlen(pMsg->calcCacheScanPlan) + 1);




486,670✔





723



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->calcCacheScanPlan, calcCacheScanPlanLen));




973,340✔





724












725



  int32_t readerNum = taosArrayGetSize(pMsg->readerList);




486,670✔





726



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));




486,670✔





727



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




1,077,942✔





728



    SStreamTaskAddr* pAddr = (SStreamTaskAddr*)taosArrayGet(pMsg->readerList, i);




591,272✔





729



    TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, pAddr));




591,272✔





730



  }










731












732



  int32_t runnerNum = taosArrayGetSize(pMsg->runnerList);




486,670✔





733



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));




486,670✔





734



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




1,925,866✔





735



    SStreamRunnerTarget* pTarget = (SStreamRunnerTarget*)taosArrayGet(pMsg->runnerList, i);




1,439,196✔





736



    TAOS_CHECK_EXIT(tEncodeSStreamRunnerTarget(pEncoder, pTarget));




1,439,196✔





737



  }










738












739



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->leaderSnodeId));




973,340✔





740



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->streamName, (int32_t)strlen(pMsg->streamName) + 1));




973,340✔





741



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->precision));




973,340✔





742



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->nodelayCreateSubtable));




973,340✔





743












744



_exit:




486,670✔





745












746



  return code;




486,670✔





747



}










748












749












750



int32_t tSerializeSFieldWithOptions(SEncoder* pEncoder, const SFieldWithOptions *pField) {




8,091,042✔





751



  int32_t code = 0;




8,091,042✔





752



  int32_t lino;










753












754



  TAOS_CHECK_EXIT(tEncodeCStr(pEncoder, pField->name));




16,182,084✔





755



  TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pField->type));




16,182,084✔





756



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pField->flags));




16,182,084✔





757



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pField->bytes));




16,182,084✔





758



  TAOS_CHECK_EXIT(tEncodeU32(pEncoder, pField->compress));




16,182,084✔





759



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pField->typeMod));




16,182,084✔





760












761



_exit:




8,091,042✔





762












763



  return code;




8,091,042✔





764



}










765












766












767



int32_t tEncodeSStreamRunnerDeployMsg(SEncoder* pEncoder, const SStreamRunnerDeployMsg* pMsg) {




1,669,368✔





768



  int32_t code = 0;




1,669,368✔





769



  int32_t lino;










770












771



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->execReplica));




3,338,736✔





772



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->streamName, (int32_t)strlen(pMsg->streamName) + 1));




3,338,736✔





773



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->pPlan, NULL == pMsg->pPlan ? 0 : (int32_t)strlen(pMsg->pPlan) + 1));




3,338,736✔





774



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->outDBFName, NULL == pMsg->outDBFName ? 0 : (int32_t)strlen(pMsg->outDBFName) + 1));




3,338,736✔





775



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->outTblName, NULL == pMsg->outTblName ? 0 : (int32_t)strlen(pMsg->outTblName) + 1));




3,338,736✔





776



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->outTblType));




3,338,736✔





777



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->calcNotifyOnly));




3,338,736✔





778



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->topPlan));




3,338,736✔





779












780



  int32_t addrSize = (int32_t)taosArrayGetSize(pMsg->pNotifyAddrUrls);




1,669,368✔





781



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, addrSize));




1,669,368✔





782



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




2,001,012✔





783



    const char *url = taosArrayGetP(pMsg->pNotifyAddrUrls, i);




331,644✔





784



    TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, url, NULL == url ? 0 : (int32_t)strlen(url) + 1));




663,288✔





785



  }










786



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->addOptions));




3,338,736✔





787












788



  int32_t outColNum = (int32_t)taosArrayGetSize(pMsg->outCols);




1,669,368✔





789



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outColNum));




1,669,368✔





790



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




8,469,504✔





791



    SFieldWithOptions *pCol = taosArrayGet(pMsg->outCols, i);




6,800,136✔





792



    TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pCol));




6,800,136✔





793



  }










794












795



  int32_t outTagNum = (int32_t)taosArrayGetSize(pMsg->outTags);




1,669,368✔





796



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, outTagNum));




1,669,368✔





797



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




2,960,274✔





798



    SFieldWithOptions *pTag = taosArrayGet(pMsg->outTags, i);




1,290,906✔





799



    TAOS_CHECK_EXIT(tSerializeSFieldWithOptions(pEncoder, pTag));




1,290,906✔





800



  }










801












802



  TAOS_CHECK_EXIT(tEncodeU64(pEncoder, pMsg->outStbUid));




3,338,736✔





803



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pMsg->outStbSversion));




3,338,736✔





804












805



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->subTblNameExpr, NULL == pMsg->subTblNameExpr ? 0 : (int32_t)strlen(pMsg->subTblNameExpr) + 1));




3,338,736✔





806



  TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pMsg->tagValueExpr, NULL == pMsg->tagValueExpr ? 0 : (int32_t)strlen(pMsg->tagValueExpr) + 1));




3,338,736✔





807












808



  int32_t forceOutColsSize = (int32_t)taosArrayGetSize(pMsg->forceOutCols);




1,669,368✔





809



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, forceOutColsSize));




1,669,368✔





810



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




1,817,484✔





811



    SStreamOutCol *pCoutCol = (SStreamOutCol*)taosArrayGet(pMsg->forceOutCols, i);




148,116✔





812



    int32_t        exprLen = pCoutCol->expr == NULL ? 0 : (int32_t)strlen((char*)pCoutCol->expr) + 1;




148,116✔





813












814



    TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pCoutCol->expr, exprLen));




296,232✔





815



    TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.type));




296,232✔





816



    TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.precision));




296,232✔





817



    TAOS_CHECK_EXIT(tEncodeU8(pEncoder, pCoutCol->type.scale));




296,232✔





818



    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pCoutCol->type.bytes));




296,232✔





819



  }










820












821



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pMsg->lowLatencyCalc));




3,338,736✔





822












823



  // colCids and tagCids - always encode size (0 if NULL) for compatibility










824



  int32_t colCidsSize = (int32_t)taosArrayGetSize(pMsg->colCids);




1,669,368✔





825



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, colCidsSize));




1,669,368✔





826



  if (colCidsSize > 0) {




1,669,368✔





827



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




109,998✔





828



      int16_t* pCid = (int16_t*)taosArrayGet(pMsg->colCids, i);




81,348✔





829



      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));




162,696✔





830



    }










831



  }










832












833



  int32_t tagCidsSize = (int32_t)taosArrayGetSize(pMsg->tagCids);




1,669,368✔





834



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, tagCidsSize));




1,669,368✔





835



  if (tagCidsSize > 0) {




1,669,368✔





836



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




55,248✔





837



      int16_t* pCid = (int16_t*)taosArrayGet(pMsg->tagCids, i);




32,388✔





838



      TAOS_CHECK_EXIT(tEncodeI16(pEncoder, *pCid));




64,776✔





839



    }










840



  }










841












842



_exit:




1,669,368✔





843












844



  return code;




1,669,368✔





845



}










846












847



int32_t tEncodeSStmTaskDeploy(SEncoder* pEncoder, const SStmTaskDeploy* pTask) {




3,725,050✔





848



  int32_t code = 0;




3,725,050✔





849



  int32_t lino;










850












851



  TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));




3,725,050✔





852



  switch (pTask->task.type) {




3,725,050✔





853



    case STREAM_READER_TASK:




1,569,012✔





854



      TAOS_CHECK_EXIT(tEncodeSStreamReaderDeployMsg(pEncoder, &pTask->msg.reader));




1,569,012✔





855



      break;




1,569,012✔





856



    case STREAM_TRIGGER_TASK:




486,670✔





857



      TAOS_CHECK_EXIT(tEncodeSStreamTriggerDeployMsg(pEncoder, &pTask->msg.trigger));




486,670✔





858



      break;




486,670✔





859



    case STREAM_RUNNER_TASK:




1,669,368✔





860



      TAOS_CHECK_EXIT(tEncodeSStreamRunnerDeployMsg(pEncoder, &pTask->msg.runner));




1,669,368✔





861



      break;




1,669,368✔





862



    default:




×







863



      TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INTERNAL_ERROR);




×







864



      break;




×







865



  }










866



  










867



_exit:




3,725,050✔





868












869



  return code;




3,725,050✔





870



}










871












872












873



int32_t tEncodeSStmStreamDeploy(SEncoder* pEncoder, const SStmStreamDeploy* pStream) {




677,554✔





874



  int32_t code = 0;




677,554✔





875



  int32_t lino;










876












877



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pStream->streamId));




1,355,108✔





878












879



  int32_t readerNum = taosArrayGetSize(pStream->readerTasks);




677,554✔





880



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));




677,554✔





881



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




2,246,566✔





882



    SStmTaskDeploy* pDeploy = taosArrayGet(pStream->readerTasks, i);




1,569,012✔





883



    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));




1,569,012✔





884



  }










885












886



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pStream->triggerTask ? 1 : 0));




1,355,108✔





887



  if (pStream->triggerTask) {




677,554✔





888



    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pStream->triggerTask));




486,670✔





889



  }










890



  










891



  int32_t runnerNum = taosArrayGetSize(pStream->runnerTasks);




677,554✔





892



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));




677,554✔





893



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




2,346,922✔





894



    SStmTaskDeploy* pDeploy = taosArrayGet(pStream->runnerTasks, i);




1,669,368✔





895



    TAOS_CHECK_EXIT(tEncodeSStmTaskDeploy(pEncoder, pDeploy));




1,669,368✔





896



  }










897












898



_exit:




677,554✔





899












900



  return code;




677,554✔





901



}










902












903



int32_t tEncodeSStreamMsg(SEncoder* pEncoder, const SStreamMsg* pMsg) {




1,188,042✔





904



  int32_t code = 0;




1,188,042✔





905



  int32_t lino = 0;




1,188,042✔





906












907



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pMsg->msgType));




2,376,084✔





908












909



_exit:




1,188,042✔





910



  return code;




1,188,042✔





911



}










912












913



int32_t tDecodeSStreamMsg(SDecoder* pDecoder, SStreamMsg* pMsg) {




594,148✔





914



  int32_t code = 0;




594,148✔





915



  int32_t lino;










916












917



  int32_t type = 0;




594,148✔





918



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &type));




594,148✔





919



  pMsg->msgType = type;




594,148✔





920












921



_exit:




594,148✔





922



  return code;




594,148✔





923



}










924












925



int32_t tEncodeSStreamStartTaskMsg(SEncoder* pEncoder, const SStreamStartTaskMsg* pStart) {




473,470✔





926



  int32_t code = 0;




473,470✔





927



  int32_t lino;










928












929



  TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pStart->header));




473,470✔





930












931



_exit:




473,470✔





932












933



  return code;




473,470✔





934



}










935












936



int32_t tEncodeSStreamTaskStart(SEncoder* pEncoder, const SStreamTaskStart* pTask) {




473,470✔





937



  int32_t code = 0;




473,470✔





938



  int32_t lino;










939












940



  TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));




473,470✔





941



  TAOS_CHECK_EXIT(tEncodeSStreamStartTaskMsg(pEncoder, (SStreamStartTaskMsg*)&pTask->startMsg));




473,470✔





942












943



_exit:




473,470✔





944












945



  return code;




473,470✔





946



}










947












948



int32_t tEncodeSStreamUndeployTaskMsg(SEncoder* pEncoder, const SStreamUndeployTaskMsg* pUndeploy) {




563,500✔





949



  int32_t code = 0;




563,500✔





950



  int32_t lino;










951












952



  TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pUndeploy->header));




563,500✔





953



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pUndeploy->doCheckpoint));




1,127,000✔





954



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pUndeploy->doCleanup));




1,127,000✔





955












956



_exit:




563,500✔





957












958



  return code;




563,500✔





959



}










960












961



int32_t tEncodeSStreamTaskUndeploy(SEncoder* pEncoder, const SStreamTaskUndeploy* pTask) {




563,500✔





962



  int32_t code = 0;




563,500✔





963



  int32_t lino;










964












965



  TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, (SStreamTask*)&pTask->task));




563,500✔





966



  TAOS_CHECK_EXIT(tEncodeSStreamUndeployTaskMsg(pEncoder, (SStreamUndeployTaskMsg*)&pTask->undeployMsg));




563,500✔





967












968



_exit:




563,500✔





969












970



  return code;




563,500✔





971



}










972












973












974



int32_t tEncodeSStreamRecalcReq(SEncoder* pEncoder, const SStreamRecalcReq* recalc) {




7,896✔





975



  int32_t code = 0;




7,896✔





976



  int32_t lino;










977












978



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->recalcId));




15,792✔





979



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->start));




15,792✔





980



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, recalc->end));




15,792✔





981












982



_exit:




7,896✔





983












984



  return code;




7,896✔





985



}










986












987



int32_t tEncodeSStreamMgmtRspCont(SEncoder* pEncoder, SStreamMsgType msgType, const SStreamMgmtRspCont* pRsp) {




151,072✔





988



  int32_t code = 0;




151,072✔





989



  int32_t lino;










990












991



  switch (msgType) {




151,072✔





992



    case STREAM_MSG_ORIGTBL_READER_INFO: {




137,610✔





993



      int32_t vgNum = taosArrayGetSize(pRsp->vgIds);




137,610✔





994



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));




137,610✔





995












996



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




533,590✔





997



        int32_t* vgId = taosArrayGet(pRsp->vgIds, i);




395,980✔





998



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));




791,960✔





999



      }










1000












1001



      int32_t readerNum = taosArrayGetSize(pRsp->readerList);




137,610✔





1002



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, readerNum));




137,610✔





1003



      










1004



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




267,950✔





1005



        SStreamTaskAddr* addr = taosArrayGet(pRsp->readerList, i);




130,340✔





1006



        TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, addr));




130,340✔





1007



      }










1008



      break;




137,610✔





1009



    }










1010



    case STREAM_MSG_UPDATE_RUNNER: {




×







1011



      int32_t runnerNum = taosArrayGetSize(pRsp->runnerList);




×







1012



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, runnerNum));




×







1013



      










1014



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




×







1015



        SStreamRunnerTarget* target = taosArrayGet(pRsp->runnerList, i);




×







1016



        TAOS_CHECK_EXIT(tEncodeSStreamRunnerTarget(pEncoder, target));




×







1017



      }










1018



      break;




×







1019



    }










1020



    case STREAM_MSG_USER_RECALC: {




7,896✔





1021



      int32_t recalcNum = taosArrayGetSize(pRsp->recalcList);




7,896✔





1022



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, recalcNum));




7,896✔





1023



      










1024



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




15,792✔





1025



        SStreamRecalcReq* recalc = taosArrayGet(pRsp->recalcList, i);




7,896✔





1026



        TAOS_CHECK_EXIT(tEncodeSStreamRecalcReq(pEncoder, recalc));




7,896✔





1027



      }










1028



      break;




7,896✔





1029



    }










1030



    case STREAM_MSG_RUNNER_ORIGTBL_READER: {




5,566✔





1031



      int32_t rspNum = taosArrayGetSize(pRsp->execRspList);




5,566✔





1032



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));




5,566✔





1033



      










1034



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




11,132✔





1035



        SStreamOReaderDeployRsp* pDeployRsp = taosArrayGet(pRsp->execRspList, i);




5,566✔





1036



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pDeployRsp->execId));




11,132✔





1037



        int32_t vgNum = taosArrayGetSize(pDeployRsp->vgList);




5,566✔





1038



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, vgNum));




5,566✔





1039



        for (int32_t n = 0; n < vgNum; ++n) {




11,132✔





1040



          TAOS_CHECK_EXIT(tEncodeSStreamTaskAddr(pEncoder, taosArrayGet(pDeployRsp->vgList, n)));




5,566✔





1041



        }










1042



      }










1043



      break;




5,566✔





1044



    }










1045



    default:




×







1046



      break;




×







1047



  }










1048












1049



_exit:




151,072✔





1050












1051



  return code;




151,072✔





1052



}










1053












1054



int32_t tEncodeSStreamMgmtRsp(SEncoder* pEncoder, const SStreamMgmtRsp* pRsp) {




151,072✔





1055



  int32_t code = 0;




151,072✔





1056



  int32_t lino;










1057












1058



  TAOS_CHECK_EXIT(tEncodeSStreamMsg(pEncoder, &pRsp->header));




151,072✔





1059



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->reqId));




302,144✔





1060



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->code));




302,144✔





1061



  TAOS_CHECK_EXIT(tEncodeStreamTask(pEncoder, &pRsp->task));




151,072✔





1062



  TAOS_CHECK_EXIT(tEncodeSStreamMgmtRspCont(pEncoder, pRsp->header.msgType, (SStreamMgmtRspCont*)&pRsp->cont));




151,072✔





1063












1064



_exit:




151,072✔





1065












1066



  return code;




151,072✔





1067



}










1068












1069












1070



int32_t tEncodeStreamHbRsp(SEncoder* pEncoder, const SMStreamHbRspMsg* pRsp) {




38,217,604✔





1071



  int32_t code = 0;




38,217,604✔





1072



  int32_t lino;










1073












1074



  TAOS_CHECK_EXIT(tStartEncode(pEncoder));




38,217,604✔





1075



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->streamGId));




76,435,208✔





1076



  int32_t deployNum = taosArrayGetSize(pRsp->deploy.streamList);




38,217,604✔





1077



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, deployNum));




38,217,604✔





1078



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




38,895,158✔





1079



    SStmStreamDeploy* pStream = (SStmStreamDeploy*)taosArrayGet(pRsp->deploy.streamList, i);




677,554✔





1080



    TAOS_CHECK_EXIT(tEncodeSStmStreamDeploy(pEncoder, pStream));




677,554✔





1081



  }










1082












1083



  int32_t startNum = taosArrayGetSize(pRsp->start.taskList);




38,217,604✔





1084



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, startNum));




38,217,604✔





1085



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




38,691,074✔





1086



    SStreamTaskStart* pTask = (SStreamTaskStart*)taosArrayGet(pRsp->start.taskList, i);




473,470✔





1087



    TAOS_CHECK_EXIT(tEncodeSStreamTaskStart(pEncoder, pTask));




473,470✔





1088



  }










1089












1090



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pRsp->undeploy.undeployAll));




76,435,208✔





1091



  if (!pRsp->undeploy.undeployAll) {




38,217,604✔





1092



    int32_t undeployNum = taosArrayGetSize(pRsp->undeploy.taskList);




38,217,604✔





1093



    TAOS_CHECK_EXIT(tEncodeI32(pEncoder, undeployNum));




38,217,604✔





1094



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




38,781,104✔





1095



      SStreamTaskUndeploy* pTask = (SStreamTaskUndeploy*)taosArrayGet(pRsp->undeploy.taskList, i);




563,500✔





1096



      TAOS_CHECK_EXIT(tEncodeSStreamTaskUndeploy(pEncoder, pTask));




563,500✔





1097



    }










1098



  }










1099












1100



  int32_t rspNum = taosArrayGetSize(pRsp->rsps.rspList);




38,217,604✔





1101



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, rspNum));




38,217,604✔





1102



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




38,368,676✔





1103



    SStreamMgmtRsp* pMgmtRsp = (SStreamMgmtRsp*)taosArrayGet(pRsp->rsps.rspList, i);




151,072✔





1104



    TAOS_CHECK_EXIT(tEncodeSStreamMgmtRsp(pEncoder, pMgmtRsp));




151,072✔





1105



  }










1106



  










1107



_exit:




38,217,604✔





1108












1109



  tEndEncode(pEncoder);




38,217,604✔





1110












1111



  return code;




38,217,604✔





1112



}










1113












1114



int32_t tDecodeSStreamReaderDeployFromTrigger(SDecoder* pDecoder, SStreamReaderDeployFromTrigger* pMsg) {




361,481✔





1115



  int32_t code = 0;




361,481✔





1116



  int32_t lino;










1117












1118



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerTblName, NULL));




722,962✔





1119



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->triggerTblUid));




722,962✔





1120



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->triggerTblSuid));




722,962✔





1121



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerTblType));




722,962✔





1122



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblVirt));




722,962✔





1123



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->deleteReCalc));




722,962✔





1124



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->deleteOutTbl));




722,962✔





1125



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->partitionCols, NULL));




722,962✔





1126



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerCols, NULL));




722,962✔





1127



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerScanPlan, NULL));




722,962✔





1128



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcCacheScanPlan, NULL));




722,962✔





1129












1130



_exit:




361,481✔





1131












1132



  return code;




361,481✔





1133



}










1134












1135












1136



int32_t tDecodeSStreamReaderDeployFromCalc(SDecoder* pDecoder, SStreamReaderDeployFromCalc* pMsg) {




419,572✔





1137



  int32_t code = 0;




419,572✔





1138



  int32_t lino;










1139












1140



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));




839,144✔





1141



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcScanPlan, NULL));




839,144✔





1142












1143



_exit:




419,572✔





1144












1145



  return code;




419,572✔





1146



}










1147












1148












1149



int32_t tDecodeSStreamReaderDeployMsg(SDecoder* pDecoder, SStreamReaderDeployMsg* pMsg) {




781,053✔





1150



  int32_t code = 0;




781,053✔





1151



  int32_t lino;










1152












1153



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerReader));




1,562,106✔





1154



  if (pMsg->triggerReader) {




781,053✔





1155



    TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployFromTrigger(pDecoder, &pMsg->msg.trigger));




361,481✔





1156



  } else {










1157



    TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployFromCalc(pDecoder, &pMsg->msg.calc));




419,572✔





1158



  }










1159



  










1160



_exit:




419,572✔





1161












1162



  return code;




781,053✔





1163



}










1164












1165












1166



int32_t tDecodeSStreamTaskAddr(SDecoder* pDecoder, SStreamTaskAddr* pMsg) {




1,086,006✔





1167



  int32_t code = 0;




1,086,006✔





1168



  int32_t lino;










1169












1170



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->taskId));




2,172,012✔





1171



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->nodeId));




2,172,012✔





1172



  TAOS_CHECK_EXIT(tDecodeSEpSet(pDecoder, &pMsg->epset));




1,086,006✔





1173












1174



_exit:




1,086,006✔





1175












1176



  return code;




1,086,006✔





1177



}










1178












1179












1180



int32_t tDecodeSStreamRunnerTarget(SDecoder* pDecoder, SStreamRunnerTarget* pMsg) {




709,143✔





1181



  int32_t code = 0;




709,143✔





1182



  int32_t lino;










1183












1184



  TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, &pMsg->addr));




709,143✔





1185



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));




1,418,286✔





1186












1187



_exit:




709,143✔





1188












1189



  return code;




709,143✔





1190



}










1191












1192












1193



int32_t tDecodeSStreamTriggerDeployMsg(SDecoder* pDecoder, SStreamTriggerDeployMsg* pMsg) {




239,850✔





1194



  int32_t code = 0;




239,850✔





1195



  int32_t lino;










1196












1197



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerType));




479,700✔





1198



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->igDisorder));




479,700✔





1199



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->fillHistory));




479,700✔





1200



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->fillHistoryFirst));




479,700✔





1201



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->lowLatencyCalc));




479,700✔





1202



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->igNoDataTrigger));




479,700✔





1203



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->enableMultiGroupCalc));




479,700✔





1204



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblVirt));




479,700✔





1205



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->triggerHasPF));




479,700✔





1206



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->isTriggerTblStb));




479,700✔





1207



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->partitionCols, NULL));




479,700✔





1208












1209



  int32_t addrSize = 0;




239,850✔





1210



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));




239,850✔





1211



  if (addrSize > 0) {




239,850✔





1212



    pMsg->pNotifyAddrUrls = taosArrayInit_s(POINTER_BYTES, addrSize);




58,743✔





1213



    TSDB_CHECK_NULL(pMsg->pNotifyAddrUrls, code, lino, _exit, terrno);




58,743✔





1214



  }










1215



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




298,593✔





1216



    const char **url = taosArrayGet(pMsg->pNotifyAddrUrls, i);




58,743✔





1217



    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)url, NULL));




58,743✔





1218



  }










1219



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->notifyEventTypes));




479,700✔





1220



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->addOptions));




479,700✔





1221



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->notifyHistory));




479,700✔





1222












1223



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->maxDelay));




479,700✔





1224



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->fillHistoryStartTime));




479,700✔





1225



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->watermark));




479,700✔





1226



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->expiredTime));




479,700✔





1227



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->idleTimeoutMs));




479,700✔





1228












1229



  switch (pMsg->triggerType) {




239,850✔





1230



    case WINDOW_TYPE_SESSION:




8,973✔





1231



      // session trigger










1232



      TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->trigger.session.slotId));




17,946✔





1233



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.session.sessionVal));




17,946✔





1234



      break;




8,973✔





1235



    case WINDOW_TYPE_STATE: {




88,857✔





1236



      /*










1237



        state trigger










1238



        v1 format: single slotId as int16 (may be -1 for expression key)










1239



        v2 format: first int16 is STATE_WIN_SLOT_SENTINEL_V2 (-2), then slotIds array










1240



        decoder is compatible with v1/v2 (to support reading legacy or old-end data).










1241



      */










1242



      int16_t firstI16 = 0;




88,857✔





1243



      TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &firstI16));




88,857✔





1244



      if (firstI16 == STATE_WIN_SLOT_SENTINEL_V2) {




88,857✔





1245



        // v2 format: sentinel + I32(slotNum) + N*I16(slotId)










1246



        int32_t slotNum = 0;




88,857✔





1247



        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &slotNum));




88,857✔





1248



        if (slotNum > 0) {




88,857✔





1249



          pMsg->trigger.stateWin.pSlotIds = taosArrayInit(slotNum, sizeof(int16_t));




88,857✔





1250



          TSDB_CHECK_NULL(pMsg->trigger.stateWin.pSlotIds, code, lino, _exit, terrno);




88,857✔





1251



        }










1252



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




189,625✔





1253



          int16_t slotId = -1;




100,768✔





1254



          TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &slotId));




100,768✔





1255



          TSDB_CHECK_NULL(taosArrayPush(pMsg->trigger.stateWin.pSlotIds, &slotId), code, lino, _exit, terrno);




201,536✔





1256



        }










1257



      } else {










1258



        // v1 format: firstI16 is the single slotId (>= 0 for column, -1 for expr)










1259



        pMsg->trigger.stateWin.pSlotIds = taosArrayInit(1, sizeof(int16_t));




×







1260



        TSDB_CHECK_NULL(pMsg->trigger.stateWin.pSlotIds, code, lino, _exit, terrno);




×







1261



        TSDB_CHECK_NULL(taosArrayPush(pMsg->trigger.stateWin.pSlotIds, &firstI16), code, lino, _exit, terrno);




×







1262



      }










1263



      TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->trigger.stateWin.extend));




177,714✔





1264



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.stateWin.trueForType));




177,714✔





1265



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.stateWin.trueForCount));




177,714✔





1266



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.stateWin.trueForDuration));




177,714✔





1267



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.stateWin.zeroth, NULL));




177,714✔





1268



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.stateWin.expr, NULL));




177,714✔





1269



      break;




88,857✔





1270



    }










1271



    










1272



    case WINDOW_TYPE_INTERVAL:




83,498✔





1273



      // slide trigger










1274



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.intervalUnit));




166,996✔





1275



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.slidingUnit));




166,996✔





1276



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.offsetUnit));




166,996✔





1277



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.soffsetUnit));




166,996✔





1278



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.sliding.precision));




166,996✔





1279



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.interval));




166,996✔





1280



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.offset));




166,996✔





1281



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.sliding));




166,996✔





1282



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.sliding.soffset));




166,996✔





1283



      break;




83,498✔





1284



    










1285



    case WINDOW_TYPE_EVENT:




26,447✔





1286



      // event trigger










1287



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.event.startCond, NULL));




52,894✔





1288



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.event.endCond, NULL));




52,894✔





1289



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.event.trueForType));




52,894✔





1290



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->trigger.event.trueForCount));




52,894✔





1291



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.event.trueForDuration));




52,894✔





1292



      break;




26,447✔





1293



    










1294



    case WINDOW_TYPE_COUNT:




24,226✔





1295



      // count trigger










1296



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->trigger.count.condCols, NULL));




48,452✔





1297



      










1298



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.count.countVal));




48,452✔





1299



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.count.sliding));




48,452✔





1300



      break;




24,226✔





1301



    










1302



    case WINDOW_TYPE_PERIOD:




7,849✔





1303



      // period trigger










1304



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t*)&pMsg->trigger.period.periodUnit));




15,698✔





1305



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t*)&pMsg->trigger.period.offsetUnit));




15,698✔





1306



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->trigger.period.precision));




15,698✔





1307



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.period.period));




15,698✔





1308



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->trigger.period.offset));




15,698✔





1309



      break;




7,849✔





1310



    default:




×







1311



      TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INTERNAL_ERROR);




×







1312



      break;




×







1313



  }










1314












1315



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->eventTypes));




479,700✔





1316



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->placeHolderBitmap));




479,700✔





1317



  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->calcTsSlotId));




479,700✔





1318



  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->triTsSlotId));




479,700✔





1319



  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->calcPkSlotId));




479,700✔





1320



  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pMsg->triPkSlotId));




479,700✔





1321



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerPrevFilter, NULL));




479,700✔





1322



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->triggerScanPlan, NULL));




479,700✔





1323



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->calcCacheScanPlan, NULL));




479,700✔





1324












1325



  int32_t readerNum = 0;




239,850✔





1326



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));




239,850✔





1327



  if (readerNum > 0) {




239,850✔





1328



    pMsg->readerList = taosArrayInit_s(sizeof(SStreamTaskAddr), readerNum);




238,784✔





1329



    TSDB_CHECK_NULL(pMsg->readerList, code, lino, _exit, terrno);




238,784✔





1330



  }










1331



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




535,588✔





1332



    SStreamTaskAddr* pAddr = (SStreamTaskAddr*)taosArrayGet(pMsg->readerList, i);




295,738✔





1333



    TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));




295,738✔





1334



  }










1335












1336



  int32_t runnerNum = 0;




239,850✔





1337



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));




239,850✔





1338



  if (runnerNum > 0) {




239,850✔





1339



    pMsg->runnerList = taosArrayInit_s(sizeof(SStreamRunnerTarget), runnerNum);




236,381✔





1340



    TSDB_CHECK_NULL(pMsg->runnerList, code, lino, _exit, terrno);




236,381✔





1341



  }










1342



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




948,993✔





1343



    SStreamRunnerTarget* pTarget = (SStreamRunnerTarget*)taosArrayGet(pMsg->runnerList, i);




709,143✔





1344



    TAOS_CHECK_EXIT(tDecodeSStreamRunnerTarget(pDecoder, pTarget));




709,143✔





1345



  }










1346












1347



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->leaderSnodeId));




479,700✔





1348



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->streamName, NULL));




479,700✔





1349



  if (!tDecodeIsEnd(pDecoder)) {




239,850✔





1350



    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->precision));




479,700✔





1351



  }










1352



  if (!tDecodeIsEnd(pDecoder)) {




239,850✔





1353



    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->nodelayCreateSubtable));




479,700✔





1354



  }










1355












1356



_exit:




239,850✔





1357












1358



  return code;




239,850✔





1359



}










1360












1361












1362












1363



int32_t tDeserializeSFieldWithOptions(SDecoder *pDecoder, SFieldWithOptions *pField) {




4,024,677✔





1364



  int32_t code = 0;




4,024,677✔





1365



  int32_t lino;










1366












1367



  TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, pField->name));




4,024,677✔





1368



  TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pField->type));




8,049,354✔





1369



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pField->flags));




8,049,354✔





1370



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pField->bytes));




8,049,354✔





1371



  TAOS_CHECK_EXIT(tDecodeU32(pDecoder, &pField->compress));




8,049,354✔





1372



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pField->typeMod));




8,049,354✔





1373












1374



_exit:




4,024,677✔





1375












1376



  return code;




4,024,677✔





1377



}










1378












1379



void destroySStreamOutCols(void* p){




74,058✔





1380



  if (p == NULL) return;




74,058✔





1381



  SStreamOutCol* col = (SStreamOutCol*)p;




74,058✔





1382



  taosMemoryFreeClear(col->expr);




74,058✔





1383



}










1384












1385



int32_t tDecodeSStreamRunnerDeployMsg(SDecoder* pDecoder, SStreamRunnerDeployMsg* pMsg) {




824,211✔





1386



  int32_t code = 0;




824,211✔





1387



  int32_t lino;










1388












1389



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->execReplica));




1,648,422✔





1390



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->streamName, NULL));




1,648,422✔





1391



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->pPlan, NULL));




1,648,422✔





1392



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->outDBFName, NULL));




1,648,422✔





1393



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->outTblName, NULL));




1,648,422✔





1394



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->outTblType));




1,648,422✔





1395



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->calcNotifyOnly));




1,648,422✔





1396



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->topPlan));




1,648,422✔





1397












1398



  int32_t addrSize = 0;




824,211✔





1399



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));




824,211✔





1400



  if (addrSize > 0) {




824,211✔





1401



    pMsg->pNotifyAddrUrls = taosArrayInit_s(POINTER_BYTES, addrSize);




165,822✔





1402



    TSDB_CHECK_NULL(pMsg->pNotifyAddrUrls, code, lino, _exit, terrno);




165,822✔





1403



  }










1404



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




990,033✔





1405



    const char **url = taosArrayGet(pMsg->pNotifyAddrUrls, i);




165,822✔





1406



    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)url, NULL));




165,822✔





1407



  }










1408



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pMsg->addOptions));




1,648,422✔





1409












1410



  int32_t outColNum = 0;




824,211✔





1411



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outColNum));




824,211✔





1412



  if (outColNum > 0) {




824,211✔





1413



    pMsg->outCols = taosArrayInit_s(sizeof(SFieldWithOptions), outColNum);




824,211✔





1414



    TSDB_CHECK_NULL(pMsg->outCols, code, lino, _exit, terrno);




824,211✔





1415



  }










1416



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




4,203,327✔





1417



    SFieldWithOptions *pCol = taosArrayGet(pMsg->outCols, i);




3,379,116✔





1418



    TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pCol));




3,379,116✔





1419



  }










1420












1421



  int32_t outTagNum = 0;




824,211✔





1422



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outTagNum));




824,211✔





1423



  if (outTagNum > 0) {




824,211✔





1424



    pMsg->outTags = taosArrayInit_s(sizeof(SFieldWithOptions), outTagNum);




335,706✔





1425



    TSDB_CHECK_NULL(pMsg->outTags, code, lino, _exit, terrno);




335,706✔





1426



  }










1427



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




1,469,772✔





1428



    SFieldWithOptions *pTag = taosArrayGet(pMsg->outTags, i);




645,561✔





1429



    TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pTag));




645,561✔





1430



  }










1431












1432



  TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pMsg->outStbUid));




1,648,422✔





1433



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pMsg->outStbSversion));




1,648,422✔





1434












1435



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->subTblNameExpr, NULL));




1,648,422✔





1436



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pMsg->tagValueExpr, NULL));




1,648,422✔





1437












1438



  int32_t forceOutColsSize = 0;




824,211✔





1439



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &forceOutColsSize));




824,211✔





1440



  if (forceOutColsSize > 0) {




824,211✔





1441



    pMsg->forceOutCols = taosArrayInit_s(sizeof(SStreamOutCol), forceOutColsSize);




13,362✔





1442



    TSDB_CHECK_NULL(pMsg->forceOutCols, code, lino, _exit, terrno);




13,362✔





1443



  }










1444



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




898,269✔





1445



    SStreamOutCol *pCoutCol = (SStreamOutCol*)taosArrayGet(pMsg->forceOutCols, i);




74,058✔





1446












1447



    TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pCoutCol->expr, NULL));




148,116✔





1448



    TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.type));




148,116✔





1449



    TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.precision));




148,116✔





1450



    TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pCoutCol->type.scale));




148,116✔





1451



    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pCoutCol->type.bytes));




148,116✔





1452



  }










1453












1454



  if (!tDecodeIsEnd(pDecoder)) {




824,211✔





1455



    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pMsg->lowLatencyCalc));




1,648,422✔





1456



  }










1457












1458



  // colCids and tagCids - always decode size, create array only if size > 0










1459



  // For backward compatibility, check if there's more data before decoding










1460



  if (!tDecodeIsEnd(pDecoder)) {




824,211✔





1461



    int32_t colCidsSize = 0;




824,211✔





1462



    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &colCidsSize));




824,211✔





1463



    if (colCidsSize > 0 && colCidsSize <= TSDB_MAX_COLUMNS) {  // Sanity check




824,211✔





1464



      pMsg->colCids = taosArrayInit(colCidsSize, sizeof(int16_t));




14,325✔





1465



      TSDB_CHECK_NULL(pMsg->colCids, code, lino, _exit, terrno);




14,325✔





1466



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




54,999✔





1467



        int16_t cid = 0;




40,674✔





1468



        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));




40,674✔





1469



        if (taosArrayPush(pMsg->colCids, &cid) == NULL) {




81,348✔





1470



          TAOS_CHECK_EXIT(terrno);




×







1471



        }










1472



      }










1473



    }










1474



  }










1475



  // Try to decode tagCids if there's more data










1476



  if (!tDecodeIsEnd(pDecoder)) {




824,211✔





1477



    int32_t tagCidsSize = 0;




824,211✔





1478



    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &tagCidsSize));




824,211✔





1479



    if (tagCidsSize > 0 && tagCidsSize <= TSDB_MAX_TAGS) {  // Sanity check




824,211✔





1480



      pMsg->tagCids = taosArrayInit(tagCidsSize, sizeof(int16_t));




11,430✔





1481



      TSDB_CHECK_NULL(pMsg->tagCids, code, lino, _exit, terrno);




11,430✔





1482



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




27,624✔





1483



        int16_t cid = 0;




16,194✔





1484



        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &cid));




16,194✔





1485



        if (taosArrayPush(pMsg->tagCids, &cid) == NULL) {




32,388✔





1486



          TAOS_CHECK_EXIT(terrno);




×







1487



        }










1488



      }










1489



    }










1490



  }










1491












1492



_exit:




822,477✔





1493












1494



  return code;




824,211✔





1495



}










1496












1497



int32_t tDecodeSStmTaskDeploy(SDecoder* pDecoder, SStmTaskDeploy* pTask) {




1,845,114✔





1498



  int32_t code = 0;




1,845,114✔





1499



  int32_t lino;










1500












1501



  TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));




1,845,114✔





1502



  switch (pTask->task.type) {




1,845,114✔





1503



    case STREAM_READER_TASK:




781,053✔





1504



      TAOS_CHECK_EXIT(tDecodeSStreamReaderDeployMsg(pDecoder, &pTask->msg.reader));




781,053✔





1505



      break;




781,053✔





1506



    case STREAM_TRIGGER_TASK:




239,850✔





1507



      TAOS_CHECK_EXIT(tDecodeSStreamTriggerDeployMsg(pDecoder, &pTask->msg.trigger));




239,850✔





1508



      break;




239,850✔





1509



    case STREAM_RUNNER_TASK:




824,211✔





1510



      TAOS_CHECK_EXIT(tDecodeSStreamRunnerDeployMsg(pDecoder, &pTask->msg.runner));




824,211✔





1511



      break;




824,211✔





1512



    default:




×







1513



      TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INTERNAL_ERROR);




×







1514



      break;




×







1515



  }










1516



  










1517



_exit:




1,845,114✔





1518












1519



  return code;




1,845,114✔





1520



}










1521












1522












1523



int32_t tDecodeSStmStreamDeploy(SDecoder* pDecoder, SStmStreamDeploy* pStream) {




335,346✔





1524



  int32_t code = 0;




335,346✔





1525



  int32_t lino;










1526












1527



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pStream->streamId));




670,692✔





1528












1529



  int32_t readerNum = 0;




335,346✔





1530



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));




335,346✔





1531



  if (readerNum > 0) {




335,346✔





1532



    pStream->readerTasks = taosArrayInit_s(sizeof(SStmTaskDeploy), readerNum);




308,429✔





1533



    TSDB_CHECK_NULL(pStream->readerTasks, code, lino, _exit, terrno);




308,429✔





1534



  }










1535



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




1,116,399✔





1536



    SStmTaskDeploy* pTask = taosArrayGet(pStream->readerTasks, i);




781,053✔





1537



    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));




781,053✔





1538



  }










1539












1540



  int32_t triggerTask = 0;




335,346✔





1541



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &triggerTask));




335,346✔





1542



  if (triggerTask) {




335,346✔





1543



    pStream->triggerTask = taosMemoryCalloc(1, sizeof(SStmTaskDeploy));




239,850✔





1544



    TSDB_CHECK_NULL(pStream->triggerTask, code, lino, _exit, terrno);




239,850✔





1545



    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pStream->triggerTask));




239,850✔





1546



  }










1547



  










1548



  int32_t runnerNum = 0;




335,346✔





1549



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));




335,346✔





1550



  if (runnerNum > 0) {




335,346✔





1551



    pStream->runnerTasks = taosArrayInit_s(sizeof(SStmTaskDeploy), runnerNum);




243,901✔





1552



    TSDB_CHECK_NULL(pStream->runnerTasks, code, lino, _exit, terrno);




243,901✔





1553



  }










1554



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




1,159,557✔





1555



    SStmTaskDeploy* pTask = taosArrayGet(pStream->runnerTasks, i);




824,211✔





1556



    TAOS_CHECK_EXIT(tDecodeSStmTaskDeploy(pDecoder, pTask));




824,211✔





1557



  }










1558












1559



_exit:




335,346✔





1560












1561



  return code;




335,346✔





1562



}










1563












1564












1565



int32_t tDecodeSStreamStartTaskMsg(SDecoder* pDecoder, SStreamStartTaskMsg* pStart) {




236,799✔





1566



  int32_t code = 0;




236,799✔





1567



  int32_t lino;










1568












1569



  TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pStart->header));




236,799✔





1570












1571



_exit:




236,799✔





1572












1573



  return code;




236,799✔





1574



}










1575












1576












1577



int32_t tDecodeSStreamTaskStart(SDecoder* pDecoder, SStreamTaskStart* pTask) {




236,799✔





1578



  int32_t code = 0;




236,799✔





1579



  int32_t lino;










1580












1581



  TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));




236,799✔





1582



  TAOS_CHECK_EXIT(tDecodeSStreamStartTaskMsg(pDecoder, (SStreamStartTaskMsg*)&pTask->startMsg));




236,799✔





1583












1584



_exit:




236,799✔





1585












1586



  return code;




236,799✔





1587



}










1588












1589












1590



int32_t tDecodeSStreamUndeployTaskMsg(SDecoder* pDecoder, SStreamUndeployTaskMsg* pUndeploy) {




281,813✔





1591



  int32_t code = 0;




281,813✔





1592



  int32_t lino;










1593












1594



  TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pUndeploy->header));




281,813✔





1595



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pUndeploy->doCheckpoint));




563,626✔





1596



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pUndeploy->doCleanup));




563,626✔





1597












1598



_exit:




281,813✔





1599












1600



  return code;




281,813✔





1601



}










1602












1603












1604



int32_t tDecodeSStreamTaskUndeploy(SDecoder* pDecoder, SStreamTaskUndeploy* pTask) {




281,813✔





1605



  int32_t code = 0;




281,813✔





1606



  int32_t lino;










1607












1608



  TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, (SStreamTask*)&pTask->task));




281,813✔





1609



  TAOS_CHECK_EXIT(tDecodeSStreamUndeployTaskMsg(pDecoder, (SStreamUndeployTaskMsg*)&pTask->undeployMsg));




281,813✔





1610












1611



_exit:




281,813✔





1612












1613



  return code;




281,813✔





1614



}










1615












1616



int32_t tDecodeSStreamRecalcReq(SDecoder* pDecoder, SStreamRecalcReq* recalc) {




3,948✔





1617



  int32_t code = 0;




3,948✔





1618



  int32_t lino;










1619












1620



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->recalcId));




7,896✔





1621



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->start));




7,896✔





1622



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &recalc->end));




7,896✔





1623












1624



_exit:




3,948✔





1625












1626



  return code;




3,948✔





1627



}










1628












1629



int32_t tDecodeSStreamMgmtRspCont(SDecoder* pDecoder, SStreamMsgType msgType, SStreamMgmtRspCont* pCont) {




75,536✔





1630



  int32_t code = 0;




75,536✔





1631



  int32_t lino;










1632












1633



  switch (msgType) {




75,536✔





1634



    case STREAM_MSG_ORIGTBL_READER_INFO: {




68,805✔





1635



      int32_t vgNum = 0;




68,805✔





1636



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));  




68,805✔





1637



      if (vgNum > 0) {




68,805✔





1638



        pCont->vgIds = taosArrayInit_s(sizeof(int32_t), vgNum);




68,003✔





1639



        TSDB_CHECK_NULL(pCont->vgIds, code, lino, _exit, terrno);




68,003✔





1640



      }










1641



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




266,795✔





1642



        int32_t *vgId = taosArrayGet(pCont->vgIds, i);




197,990✔





1643



        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, vgId));  




197,990✔





1644



      }










1645












1646



      int32_t readerNum = 0;




68,805✔





1647



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &readerNum));  




68,805✔





1648



      if (readerNum > 0) {




68,805✔





1649



        pCont->readerList = taosArrayInit_s(sizeof(SStreamTaskAddr), readerNum);




56,642✔





1650



        TSDB_CHECK_NULL(pCont->readerList, code, lino, _exit, terrno);




56,642✔





1651



      }










1652



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




133,975✔





1653



        SStreamTaskAddr *addr = taosArrayGet(pCont->readerList, i);




65,170✔





1654



        TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, addr));  




65,170✔





1655



      }










1656



      break;




68,805✔





1657



    }










1658



    case STREAM_MSG_UPDATE_RUNNER: {




×







1659



      int32_t runnerNum = 0;




×







1660



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &runnerNum));  




×







1661



      if (runnerNum > 0) {




×







1662



        pCont->runnerList = taosArrayInit_s(sizeof(SStreamRunnerTarget), runnerNum);




×







1663



        TSDB_CHECK_NULL(pCont->runnerList, code, lino, _exit, terrno);




×







1664



      }










1665



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




×







1666



        SStreamRunnerTarget *target = taosArrayGet(pCont->runnerList, i);




×







1667



        TAOS_CHECK_EXIT(tDecodeSStreamRunnerTarget(pDecoder, target));  




×







1668



      }










1669



      break;




×







1670



    }










1671



    case STREAM_MSG_USER_RECALC: {




3,948✔





1672



      int32_t recalcNum = 0;




3,948✔





1673



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &recalcNum));  




3,948✔





1674



      if (recalcNum > 0) {




3,948✔





1675



        pCont->recalcList = taosArrayInit_s(sizeof(SStreamRecalcReq), recalcNum);




3,948✔





1676



        TSDB_CHECK_NULL(pCont->recalcList, code, lino, _exit, terrno);




3,948✔





1677



      }










1678



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




7,896✔





1679



        SStreamRecalcReq *recalc = taosArrayGet(pCont->recalcList, i);




3,948✔





1680



        TAOS_CHECK_EXIT(tDecodeSStreamRecalcReq(pDecoder, recalc));  




3,948✔





1681



      }










1682



      break;




3,948✔





1683



    }










1684



    case STREAM_MSG_RUNNER_ORIGTBL_READER: {




2,783✔





1685



      int32_t rspNum = 0, vgNum = 0;




2,783✔





1686



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));  




2,783✔





1687



      if (rspNum > 0) {




2,783✔





1688



        pCont->execRspList = taosArrayInit_s(sizeof(SStreamOReaderDeployRsp), rspNum);




2,783✔





1689



        TSDB_CHECK_NULL(pCont->execRspList, code, lino, _exit, terrno);




2,783✔





1690



      }










1691



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




5,566✔





1692



        SStreamOReaderDeployRsp *pDeployRsp = taosArrayGet(pCont->execRspList, i);




2,783✔





1693



        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pDeployRsp->execId));  




5,566✔





1694



        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgNum));




2,783✔





1695



        if (vgNum > 0) {




2,783✔





1696



          pDeployRsp->vgList = taosArrayInit_s(sizeof(SStreamTaskAddr), vgNum);




2,783✔





1697



          TSDB_CHECK_NULL(pDeployRsp->vgList, code, lino, _exit, terrno);




2,783✔





1698



        }










1699



        for (int32_t n = 0; n < vgNum; ++n) {




5,566✔





1700



          SStreamTaskAddr* pAddr = taosArrayGet(pDeployRsp->vgList, n);




2,783✔





1701



          TAOS_CHECK_EXIT(tDecodeSStreamTaskAddr(pDecoder, pAddr));  




2,783✔





1702



        }










1703



      }










1704



      break;




2,783✔





1705



    }










1706



    default:




×







1707



      break;




×







1708



  }










1709












1710



_exit:




75,536✔





1711












1712



  return code;




75,536✔





1713



}










1714












1715












1716



int32_t tDecodeSStreamMgmtRsp(SDecoder* pDecoder, SStreamMgmtRsp* pRsp) {




75,536✔





1717



  int32_t code = 0;




75,536✔





1718



  int32_t lino;










1719












1720



  TAOS_CHECK_EXIT(tDecodeSStreamMsg(pDecoder, &pRsp->header));




75,536✔





1721



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->reqId));




151,072✔





1722



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->code));




151,072✔





1723



  TAOS_CHECK_EXIT(tDecodeStreamTask(pDecoder, &pRsp->task));




75,536✔





1724



  TAOS_CHECK_EXIT(tDecodeSStreamMgmtRspCont(pDecoder, pRsp->header.msgType, &pRsp->cont));




75,536✔





1725












1726



_exit:




75,536✔





1727












1728



  return code;




75,536✔





1729



}










1730












1731



void tFreeSStreamOReaderDeployRsp(void* param) {




5,566✔





1732



  if (NULL == param) {




5,566✔





1733



    return;




×







1734



  }










1735












1736



  SStreamOReaderDeployRsp* pRsp = (SStreamOReaderDeployRsp*)param;




5,566✔





1737



  taosArrayDestroy(pRsp->vgList);




5,566✔





1738



}










1739












1740



void tFreeSStreamMgmtRsp(void* param) {




151,072✔





1741



  if (NULL == param) {




151,072✔





1742



    return;




×







1743



  }










1744



  










1745



  SStreamMgmtRsp* pRsp = (SStreamMgmtRsp*)param;




151,072✔





1746












1747



  taosArrayDestroy(pRsp->cont.vgIds);




151,072✔





1748



  taosArrayDestroy(pRsp->cont.readerList);




151,072✔





1749



  taosArrayDestroy(pRsp->cont.runnerList);




151,072✔





1750



  taosArrayDestroy(pRsp->cont.recalcList);




151,072✔





1751



  taosArrayDestroyEx(pRsp->cont.execRspList, tFreeSStreamOReaderDeployRsp);




151,072✔





1752



}










1753












1754



void tFreeSStreamReaderDeployMsg(SStreamReaderDeployMsg* pReader) {




781,053✔





1755



  if (NULL == pReader) {




781,053✔





1756



    return;




×







1757



  }










1758



  










1759



  if (pReader->triggerReader) {




781,053✔





1760



    SStreamReaderDeployFromTrigger* pMsg = (SStreamReaderDeployFromTrigger*)&pReader->msg.trigger;




361,481✔





1761



    taosMemoryFree(pMsg->triggerTblName);




361,481✔





1762



    taosMemoryFree(pMsg->partitionCols);




361,481✔





1763



    taosMemoryFree(pMsg->triggerCols);




361,481✔





1764



    taosMemoryFree(pMsg->triggerScanPlan);




361,481✔





1765



    taosMemoryFree(pMsg->calcCacheScanPlan);




361,481✔





1766



  } else {










1767



    SStreamReaderDeployFromCalc* pMsg = (SStreamReaderDeployFromCalc*)&pReader->msg.calc;




419,572✔





1768



    taosMemoryFree(pMsg->calcScanPlan);




419,572✔





1769



  }










1770



}










1771












1772



void tFreeStreamNotifyUrl(void* param) {




×







1773



  if (NULL == param) {




×







1774



    return;




×







1775



  }










1776












1777



  taosMemoryFree(*(void**)param);




×







1778



}










1779












1780



void tFreeSStreamTriggerDeployMsg(SStreamTriggerDeployMsg* pTrigger) {




239,850✔





1781



  if (NULL == pTrigger) {




239,850✔





1782



    return;




×







1783



  }










1784



  










1785



  taosArrayDestroyEx(pTrigger->pNotifyAddrUrls, tFreeStreamNotifyUrl);




239,850✔





1786



  switch (pTrigger->triggerType) {




239,850✔





1787



    case WINDOW_TYPE_STATE:




88,857✔





1788



      taosArrayDestroy(pTrigger->trigger.stateWin.pSlotIds);




88,857✔





1789



      taosMemoryFree(pTrigger->trigger.stateWin.zeroth);




88,857✔





1790



      taosMemoryFree(pTrigger->trigger.stateWin.expr);




88,857✔





1791



      break;




88,857✔





1792



    case WINDOW_TYPE_EVENT:




26,447✔





1793



      taosMemoryFree(pTrigger->trigger.event.startCond);




26,447✔





1794



      taosMemoryFree(pTrigger->trigger.event.endCond);




26,447✔





1795



      break;




26,447✔





1796



    case WINDOW_TYPE_COUNT:




24,226✔





1797



      taosMemoryFree(pTrigger->trigger.count.condCols);  




24,226✔





1798



      break;




24,226✔





1799



    default:




100,320✔





1800



      break;




100,320✔





1801



  }










1802












1803



  taosMemoryFree(pTrigger->partitionCols);




239,850✔





1804



  taosMemoryFree(pTrigger->triggerPrevFilter);




239,850✔





1805



  taosMemoryFree(pTrigger->triggerScanPlan);




239,850✔





1806



  taosMemoryFree(pTrigger->calcCacheScanPlan);




239,850✔





1807












1808



  taosArrayDestroy(pTrigger->readerList);




239,850✔





1809



  taosArrayDestroy(pTrigger->runnerList);




239,850✔





1810



  taosMemoryFree(pTrigger->streamName);




239,850✔





1811



}










1812












1813



void tFreeSStreamOutCol(void* param) {




×







1814



  if (NULL == param) {




×







1815



    return;




×







1816



  }










1817












1818



  SStreamOutCol* pOut = (SStreamOutCol*)param;




×







1819



  taosMemoryFree(pOut->expr);




×







1820



}










1821












1822



void tFreeSStreamRunnerDeployMsg(SStreamRunnerDeployMsg* pRunner) {




824,211✔





1823



  if (NULL == pRunner) {




824,211✔





1824



    return;




×







1825



  }










1826












1827



  taosMemoryFree(pRunner->streamName);




824,211✔





1828



  taosMemoryFree(pRunner->pPlan);




824,211✔





1829



  taosMemoryFree(pRunner->outDBFName);




824,211✔





1830



  taosMemoryFree(pRunner->outTblName);




824,211✔





1831












1832



  taosArrayDestroyEx(pRunner->pNotifyAddrUrls, tFreeStreamNotifyUrl);




824,211✔





1833



  taosArrayDestroy(pRunner->outCols);




824,211✔





1834



  taosArrayDestroy(pRunner->outTags);




824,211✔





1835












1836



  taosMemoryFree(pRunner->subTblNameExpr);




824,211✔





1837



  taosMemoryFree(pRunner->tagValueExpr);




824,211✔





1838



  taosArrayDestroyEx(pRunner->forceOutCols, tFreeSStreamOutCol);




824,211✔





1839



}










1840












1841



void tFreeSStmTaskDeploy(void* param) {




2,279,387✔





1842



  if (NULL == param) {




2,279,387✔





1843



    return;




434,273✔





1844



  }










1845












1846



  SStmTaskDeploy* pTask = (SStmTaskDeploy*)param;




1,845,114✔





1847



  switch (pTask->task.type)  {




1,845,114✔





1848



    case STREAM_READER_TASK:




781,053✔





1849



      tFreeSStreamReaderDeployMsg(&pTask->msg.reader);




781,053✔





1850



      break;




781,053✔





1851



    case STREAM_TRIGGER_TASK:




239,850✔





1852



      tFreeSStreamTriggerDeployMsg(&pTask->msg.trigger);




239,850✔





1853



      break;




239,850✔





1854



    case STREAM_RUNNER_TASK:




824,211✔





1855



      tFreeSStreamRunnerDeployMsg(&pTask->msg.runner);




824,211✔





1856



      break;




824,211✔





1857



    default:




×







1858



      break;




×







1859



  }










1860



}










1861












1862












1863



void tFreeSStmStreamDeploy(void* param) {




338,777✔





1864



  if (NULL == param) {




338,777✔





1865



    return;




×







1866



  }










1867



  










1868



  SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;




338,777✔





1869



  int32_t readerNum = taosArrayGetSize(pDeploy->readerTasks);




338,777✔





1870



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




1,123,283✔





1871



    SStmTaskDeploy* pReader = taosArrayGet(pDeploy->readerTasks, i);




784,506✔





1872



    if (!pReader->msg.reader.triggerReader && pReader->msg.reader.msg.calc.freeScanPlan) {




784,506✔





1873



      taosMemoryFreeClear(pReader->msg.reader.msg.calc.calcScanPlan);




423,073✔





1874



    }










1875



  }










1876



  taosArrayDestroy(pDeploy->readerTasks);




338,777✔





1877












1878



  if (pDeploy->triggerTask) {




338,777✔





1879



    taosArrayDestroy(pDeploy->triggerTask->msg.trigger.readerList);




243,335✔





1880



    taosArrayDestroy(pDeploy->triggerTask->msg.trigger.runnerList);




243,335✔





1881



    taosMemoryFree(pDeploy->triggerTask);




243,335✔





1882



  }










1883












1884



  int32_t runnerNum = taosArrayGetSize(pDeploy->runnerTasks);




338,777✔





1885



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




1,173,461✔





1886



    SStmTaskDeploy* pRunner = taosArrayGet(pDeploy->runnerTasks, i);




834,684✔





1887



    taosMemoryFree(pRunner->msg.runner.pPlan);




834,684✔





1888



  }










1889



  taosArrayDestroy(pDeploy->runnerTasks);




338,777✔





1890



}










1891












1892



void tDeepFreeSStmStreamDeploy(void* param) {




674,123✔





1893



  if (NULL == param) {




674,123✔





1894



    return;




×







1895



  }










1896



  










1897



  SStmStreamDeploy* pDeploy = (SStmStreamDeploy*)param;




674,123✔





1898



  taosArrayDestroyEx(pDeploy->readerTasks, tFreeSStmTaskDeploy);




674,123✔





1899



  tFreeSStmTaskDeploy(pDeploy->triggerTask);




674,123✔





1900



  taosMemoryFree(pDeploy->triggerTask);




674,123✔





1901



  taosArrayDestroyEx(pDeploy->runnerTasks, tFreeSStmTaskDeploy);




674,123✔





1902



}










1903












1904












1905



void tFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {




38,546,600✔





1906



  if (NULL == pRsp) {




38,546,600✔





1907



    return;




×







1908



  }










1909



  taosArrayDestroyEx(pRsp->deploy.streamList, tFreeSStmStreamDeploy);




38,546,600✔





1910



  taosArrayDestroy(pRsp->start.taskList);




38,546,600✔





1911



  taosArrayDestroy(pRsp->undeploy.taskList);




38,546,600✔





1912



  taosArrayDestroyEx(pRsp->rsps.rspList, tFreeSStreamMgmtRsp);




38,546,600✔





1913



}










1914












1915



void tDeepFreeSMStreamHbRspMsg(SMStreamHbRspMsg* pRsp) {




19,044,995✔





1916



  if (NULL == pRsp) {




19,044,995✔





1917



    return;




×







1918



  }










1919



  taosArrayDestroyEx(pRsp->deploy.streamList, tDeepFreeSStmStreamDeploy);




19,044,995✔





1920



  taosArrayDestroy(pRsp->start.taskList);




19,044,995✔





1921



  taosArrayDestroy(pRsp->undeploy.taskList);




19,044,995✔





1922



  taosArrayDestroyEx(pRsp->rsps.rspList, tFreeSStreamMgmtRsp);




19,044,995✔





1923



}










1924












1925












1926












1927



int32_t tDecodeStreamHbRsp(SDecoder* pDecoder, SMStreamHbRspMsg* pRsp) {




19,044,995✔





1928



  int32_t code = 0;




19,044,995✔





1929



  int32_t lino;










1930












1931



  TAOS_CHECK_EXIT(tStartDecode(pDecoder));




19,044,995✔





1932



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->streamGId));




38,089,990✔





1933



  int32_t deployNum = 0;




19,044,995✔





1934



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &deployNum));




19,044,995✔





1935



  if (deployNum > 0) {




19,044,995✔





1936



    pRsp->deploy.streamList = taosArrayInit_s(sizeof(SStmStreamDeploy), deployNum);




103,772✔





1937



    TSDB_CHECK_NULL(pRsp->deploy.streamList, code, lino, _exit, terrno);




103,772✔





1938



  }










1939



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




19,380,341✔





1940



    SStmStreamDeploy* pStream = taosArrayGet(pRsp->deploy.streamList, i);




335,346✔





1941



    TAOS_CHECK_EXIT(tDecodeSStmStreamDeploy(pDecoder, pStream));




335,346✔





1942



  }










1943












1944



  int32_t startNum = 0;




19,044,995✔





1945



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &startNum));




19,044,995✔





1946



  if (startNum > 0) {




19,044,995✔





1947



    pRsp->start.taskList = taosArrayInit_s(sizeof(SStreamTaskStart), startNum);




128,451✔





1948



    TSDB_CHECK_NULL(pRsp->start.taskList, code, lino, _exit, terrno);




128,451✔





1949



  }










1950



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




19,281,794✔





1951



    SStreamTaskStart* pTask = (SStreamTaskStart*)taosArrayGet(pRsp->start.taskList, i);




236,799✔





1952



    TAOS_CHECK_EXIT(tDecodeSStreamTaskStart(pDecoder, pTask));




236,799✔





1953



  }










1954












1955



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pRsp->undeploy.undeployAll));




38,089,990✔





1956



  if (!pRsp->undeploy.undeployAll) {




19,044,995✔





1957



    int32_t undeployNum = 0;




19,044,995✔





1958



    TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &undeployNum));




19,044,995✔





1959



    if (undeployNum > 0) {




19,044,995✔





1960



      pRsp->undeploy.taskList = taosArrayInit_s(sizeof(SStreamTaskUndeploy), undeployNum);




36,609✔





1961



      TSDB_CHECK_NULL(pRsp->undeploy.taskList, code, lino, _exit, terrno);




36,609✔





1962



    }










1963



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




19,326,808✔





1964



      SStreamTaskUndeploy* pTask = (SStreamTaskUndeploy*)taosArrayGet(pRsp->undeploy.taskList, i);




281,813✔





1965



      TAOS_CHECK_EXIT(tDecodeSStreamTaskUndeploy(pDecoder, pTask));




281,813✔





1966



    }










1967



  }  










1968












1969



  int32_t rspNum = 0;




19,044,995✔





1970



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &rspNum));




19,044,995✔





1971



  if (rspNum > 0) {




19,044,995✔





1972



    pRsp->rsps.rspList = taosArrayInit_s(sizeof(SStreamMgmtRsp), rspNum);




29,319✔





1973



    TSDB_CHECK_NULL(pRsp->rsps.rspList, code, lino, _exit, terrno);




29,319✔





1974



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




104,855✔





1975



      SStreamMgmtRsp* pMgmtRsp = (SStreamMgmtRsp*)taosArrayGet(pRsp->rsps.rspList, i);




75,536✔





1976



      TAOS_CHECK_EXIT(tDecodeSStreamMgmtRsp(pDecoder, pMgmtRsp));




75,536✔





1977



    }










1978



  }










1979












1980



  tEndDecode(pDecoder);




19,044,995✔





1981












1982



_exit:




19,044,995✔





1983



  return code;




19,044,995✔





1984



}










1985












1986



int32_t tEncodeStreamTaskRunReq (SEncoder* pEncoder, const SStreamTaskRunReq* pReq) {




×







1987



  int32_t code = 0;




×







1988



  int32_t lino;










1989












1990



  TAOS_CHECK_EXIT(tStartEncode(pEncoder));




×







1991



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));




×







1992



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->taskId));




×







1993



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->reqType));




×







1994



  tEndEncode(pEncoder);




×







1995












1996



_exit:




×







1997



  return code;




×







1998



}










1999












2000



int32_t tDecodeStreamTaskRunReq(SDecoder* pDecoder, SStreamTaskRunReq* pReq) {




×







2001



  int32_t code = 0;




×







2002



  int32_t lino;










2003












2004



  TAOS_CHECK_EXIT(tStartDecode(pDecoder));




×







2005



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));




×







2006



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->taskId));




×







2007



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->reqType));




×







2008



  tEndDecode(pDecoder);




×







2009












2010



_exit:




×







2011



  return code;




×







2012



}










2013












2014



int32_t tEncodeStreamTaskStopReq(SEncoder* pEncoder, const SStreamTaskStopReq* pReq) {




×







2015



  int32_t code = 0;




×







2016



  int32_t lino;










2017












2018



  TAOS_CHECK_EXIT(tStartEncode(pEncoder));




×







2019



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));




×







2020



  tEndEncode(pEncoder);




×







2021












2022



_exit:




×







2023



  return code;




×







2024



}










2025












2026



int32_t tDecodeStreamTaskStopReq(SDecoder* pDecoder, SStreamTaskStopReq* pReq) {




×







2027



  int32_t code = 0;




×







2028



  int32_t lino;










2029












2030



  TAOS_CHECK_EXIT(tStartDecode(pDecoder));




×







2031



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));




×







2032



  tEndDecode(pDecoder);




×







2033












2034



_exit:




×







2035



  return code;




×







2036












2037



}










2038












2039












2040



int32_t tSerializeSCMCreateStreamReqImpl(SEncoder* pEncoder, const SCMCreateStreamReq *pReq) {




1,721,588✔





2041



  int32_t code = TSDB_CODE_SUCCESS;




1,721,588✔





2042



  int32_t lino = 0;




1,721,588✔





2043












2044



  char*   json = NULL;




1,721,588✔





2045



  int32_t jsonLen = 0;




1,721,588✔





2046



  TAOS_CHECK_EXIT(scmCreateStreamReqToJson(pReq, false, &json, &jsonLen));




1,721,588✔





2047



  TAOS_CHECK_EXIT(tEncodeCStrWithLen(pEncoder, json, jsonLen));




3,443,176✔





2048












2049



_exit:




1,721,588✔





2050



  taosMemoryFreeClear(json);




1,721,588✔





2051



  if (code) {




1,721,588✔





2052



    return code;




×







2053



  }










2054



  










2055



  return 0;




1,721,588✔





2056



}










2057












2058



int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateStreamReq *pReq) {




751,434✔





2059



  SEncoder encoder = {0};




751,434✔





2060



  tEncoderInit(&encoder, buf, bufLen);




751,434✔





2061



  int32_t code = 0;




751,434✔





2062



  int32_t lino;










2063












2064



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




751,434✔





2065












2066



  TAOS_CHECK_EXIT(tSerializeSCMCreateStreamReqImpl(&encoder, pReq));




751,434✔





2067












2068



  tEndEncode(&encoder);




751,434✔





2069












2070



_exit:




751,434✔





2071



  if (code) {




751,434✔





2072



    tEncoderClear(&encoder);




×







2073



    return code;




×







2074



  } else {










2075



    int32_t tlen = encoder.pos;




751,434✔





2076



    tEncoderClear(&encoder);




751,434✔





2077



    return tlen;




751,434✔





2078



  }










2079



  return 0;










2080



}










2081












2082



// Old version deserialization for backward compatibility,










2083



// especially for stream version number 7










2084



int32_t tDeserializeSCMCreateStreamReqImplOld(SDecoder *pDecoder, SCMCreateStreamReq *pReq, int32_t leftBytes) {




×







2085



  int32_t code = 0;




×







2086



  int32_t lino;










2087



  pReq->calcPkSlotId = -1;




×







2088



  pReq->triPkSlotId = -1;




×







2089












2090



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));




×







2091












2092



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->name, NULL));




×







2093



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->sql, NULL));




×







2094



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->outDB, NULL));




×







2095



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->streamDB, NULL));




×







2096



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerDB, NULL));




×







2097



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerTblName, NULL));




×







2098



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->outTblName, NULL));




×







2099












2100



  int32_t calcDbSize = 0;




×







2101



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &calcDbSize));




×







2102



  pReq->calcDB = taosArrayInit(calcDbSize, POINTER_BYTES);




×







2103



  if (pReq->calcDB == NULL) {




×







2104



    TAOS_CHECK_EXIT(terrno);




×







2105



  }










2106



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




×







2107



    char *calcDb = NULL;




×







2108



    TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &calcDb));




×







2109



    calcDb = taosStrndup(calcDb, TSDB_DB_FNAME_LEN);




×







2110



    if (calcDb == NULL) {




×







2111



      TAOS_CHECK_EXIT(terrno);




×







2112



    }










2113



    if (taosArrayPush(pReq->calcDB, &calcDb) == NULL) {




×







2114



      taosMemoryFree(calcDb);




×







2115



      TAOS_CHECK_EXIT(terrno);




×







2116



    }










2117



  }










2118












2119



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->igExists));




×







2120



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->triggerType));




×







2121



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->igDisorder));




×







2122



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->deleteReCalc));




×







2123



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->deleteOutTbl));




×







2124



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->fillHistory));




×







2125



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->fillHistoryFirst));




×







2126



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->calcNotifyOnly));




×







2127



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->lowLatencyCalc));




×







2128



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->igNoDataTrigger));




×







2129












2130



  int32_t addrSize = 0;




×







2131



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &addrSize));




×







2132



  if (addrSize > 0) {




×







2133



    pReq->pNotifyAddrUrls = taosArrayInit(addrSize, POINTER_BYTES);




×







2134



    if (pReq->pNotifyAddrUrls == NULL) {




×







2135



      TAOS_CHECK_EXIT(terrno);




×







2136



    }










2137



  }










2138



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




×







2139



    char *url = NULL;




×







2140



    TAOS_CHECK_EXIT(tDecodeCStr(pDecoder, &url));




×







2141



    url = taosStrndup(url, TSDB_STREAM_NOTIFY_URL_LEN);




×







2142



    if (url == NULL) {




×







2143



      TAOS_CHECK_EXIT(terrno);




×







2144



    }










2145



    if (taosArrayPush(pReq->pNotifyAddrUrls, &url) == NULL) {




×







2146



      taosMemoryFree(url);




×







2147



      TAOS_CHECK_EXIT(terrno);




×







2148



    }










2149



  }










2150



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->notifyEventTypes));




×







2151



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->addOptions));




×







2152



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->notifyHistory));




×







2153












2154



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerFilterCols, NULL));




×







2155



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerCols, NULL));




×







2156



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->partitionCols, NULL));




×







2157












2158



  int32_t outColSize = 0;




×







2159



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outColSize));




×







2160



  if (outColSize > 0) {




×







2161



    pReq->outCols = taosArrayInit_s(sizeof(SFieldWithOptions), outColSize);




×







2162



    if (pReq->outCols == NULL) {




×







2163



      TAOS_CHECK_EXIT(terrno);




×







2164



    }










2165












2166



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




×







2167



      SFieldWithOptions* pField = taosArrayGet(pReq->outCols, i);




×







2168



      TAOS_CHECK_EXIT(tDeserializeSFieldWithOptions(pDecoder, pField));




×







2169



    }










2170



  }










2171












2172



  int32_t outTagSize = 0;




×







2173



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outTagSize));




×







2174



  if (outTagSize > 0) {




×







2175



    pReq->outTags = taosArrayInit(outTagSize, sizeof(SFieldWithOptions));




×







2176



    if (pReq->outTags == NULL) {




×







2177



      TAOS_CHECK_EXIT(terrno);




×







2178



    }










2179












2180



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




×







2181



      SFieldWithOptions field = {0};




×







2182



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &field.type));




×







2183



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &field.flags));




×







2184



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &field.bytes));




×







2185



      TAOS_CHECK_EXIT(tDecodeCStrTo(pDecoder, field.name));




×







2186



      if (taosArrayPush(pReq->outTags, &field) == NULL) {




×







2187



        TAOS_CHECK_EXIT(terrno);




×







2188



      }










2189



    }










2190



  }










2191












2192



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->maxDelay));




×







2193



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->fillHistoryStartTime));




×







2194



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->watermark));




×







2195



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->expiredTime));




×







2196












2197



  switch (pReq->triggerType) {




×







2198



    case WINDOW_TYPE_SESSION: {




×







2199



      // session trigger










2200



      TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->trigger.session.slotId));




×







2201



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.session.sessionVal));




×







2202



      break;




×







2203



    }










2204



      case WINDOW_TYPE_STATE: {




×







2205



        // state trigger










2206



        int16_t slotId = -1;




×







2207



        TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &slotId));




×







2208



        pReq->trigger.stateWin.pSlotIds = taosArrayInit(1, sizeof(int16_t));




×







2209



        TSDB_CHECK_NULL(pReq->trigger.stateWin.pSlotIds, code, lino, _exit, terrno);




×







2210



        TSDB_CHECK_NULL(taosArrayPush(pReq->trigger.stateWin.pSlotIds, &slotId), code, lino, _exit, terrno);




×







2211



        pReq->trigger.stateWin.extend = 0;




×







2212



        pReq->trigger.stateWin.trueForType = 0;




×







2213



        pReq->trigger.stateWin.trueForCount = 0;




×







2214



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.stateWin.trueForDuration));




×







2215



        break;




×







2216



      }










2217



      case WINDOW_TYPE_INTERVAL: {




×







2218



        // slide trigger










2219



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.intervalUnit));




×







2220



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.slidingUnit));




×







2221



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.offsetUnit));




×







2222



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.soffsetUnit));




×







2223



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.precision));




×







2224



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.sliding.interval));




×







2225



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.sliding.offset));




×







2226



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.sliding.sliding));




×







2227



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.sliding.soffset));




×







2228



        break;




×







2229



      }










2230



      case WINDOW_TYPE_EVENT: {




×







2231



        // event trigger










2232



        TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->trigger.event.startCond, NULL));




×







2233



        TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->trigger.event.endCond, NULL));




×







2234



        pReq->trigger.event.trueForType = 0;




×







2235



        pReq->trigger.event.trueForCount = 0;




×







2236



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.event.trueForDuration));




×







2237



        break;




×







2238



      }










2239



      case WINDOW_TYPE_COUNT: {




×







2240



        TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->trigger.count.condCols, NULL));




×







2241












2242



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.count.countVal));




×







2243



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.count.sliding));




×







2244



        break;




×







2245



      }










2246



      case WINDOW_TYPE_PERIOD: {




×







2247



        // period trigger










2248



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.period.precision));




×







2249



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.period.periodUnit));




×







2250



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.period.offsetUnit));




×







2251



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.period.period));




×







2252



        TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->trigger.period.offset));




×







2253



        break;




×







2254



      }










2255



      default:




×







2256



        TAOS_CHECK_EXIT(TSDB_CODE_INVALID_MSG);




×







2257



  }










2258












2259



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->triggerTblType));




×







2260



  TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pReq->triggerTblUid));




×







2261



  TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pReq->triggerTblSuid));




×







2262



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->vtableCalc));




×







2263



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->outTblType));




×







2264



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->outStbExists));




×







2265



  TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pReq->outStbUid));




×







2266



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->outStbSversion));




×







2267



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->eventTypes));




×







2268



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->flags));




×







2269



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->tsmaId));




×







2270



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->placeHolderBitmap));




×







2271



  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->calcTsSlotId));




×







2272



  TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->triTsSlotId));




×







2273












2274



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->triggerTblVgId));




×







2275



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->outTblVgId));




×







2276












2277



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerScanPlan, NULL));




×







2278












2279



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->triggerHasPF));




×







2280



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->triggerPrevFilter, NULL));




×







2281












2282



  int32_t calcScanPlanListSize = 0;




×







2283



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &calcScanPlanListSize));




×







2284



  if (calcScanPlanListSize > 0) {




×







2285



    pReq->calcScanPlanList = taosArrayInit(calcScanPlanListSize, sizeof(SStreamCalcScan));




×







2286



    if (pReq->calcScanPlanList == NULL) {




×







2287



      TAOS_CHECK_EXIT(terrno);




×







2288



    }










2289



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




×







2290



      SStreamCalcScan calcScan = {0};




×







2291



      int32_t         vgListSize = 0;




×







2292



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgListSize));




×







2293



      if (vgListSize > 0) {




×







2294



        calcScan.vgList = taosArrayInit(vgListSize, sizeof(int32_t));




×







2295



        if (calcScan.vgList == NULL) {




×







2296



          TAOS_CHECK_EXIT(terrno);




×







2297



        }










2298



        for (int32_t j = 0; j < vgListSize; ++j) {




×







2299



          int32_t vgId = 0;




×







2300



          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));




×







2301



          if (taosArrayPush(calcScan.vgList, &vgId) == NULL) {




×







2302



            TAOS_CHECK_EXIT(terrno);




×







2303



          }










2304



        }










2305



      }










2306



      TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &calcScan.readFromCache));




×







2307



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&calcScan.scanPlan, NULL));




×







2308



      if (taosArrayPush(pReq->calcScanPlanList, &calcScan) == NULL) {




×







2309



        TAOS_CHECK_EXIT(terrno);




×







2310



      }










2311



    }










2312



  }










2313












2314



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->numOfCalcSubplan));




×







2315



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->calcPlan, NULL));




×







2316



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->subTblNameExpr, NULL));




×







2317



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->tagValueExpr, NULL));




×







2318












2319



  int32_t forceOutColsSize = 0;




×







2320



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &forceOutColsSize));




×







2321



  if (forceOutColsSize > 0) {




×







2322



    pReq->forceOutCols = taosArrayInit(forceOutColsSize, sizeof(SStreamOutCol));




×







2323



    if (pReq->forceOutCols == NULL) {




×







2324



      TAOS_CHECK_EXIT(terrno);




×







2325



    }










2326



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




×







2327



      SStreamOutCol outCol = {0};




×







2328



      int64_t       exprLen = 0;




×







2329



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&outCol.expr, &exprLen));




×







2330



      TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &outCol.type.type));




×







2331



      TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &outCol.type.precision));




×







2332



      TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &outCol.type.scale));




×







2333



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &outCol.type.bytes));




×







2334



      if (taosArrayPush(pReq->forceOutCols, &outCol) == NULL) {




×







2335



        TAOS_CHECK_EXIT(terrno);




×







2336



      }










2337



    }










2338



  }










2339












2340



  // LeftBytes is the size of all fields at the tail of SStreamObj.










2341



  // If there are more data in the buffer, then it means










2342



  // the new fields are added in SStreamObj, need to decode them.










2343



  if (pDecoder->size - pDecoder->pos > leftBytes) {




×







2344



    switch (pReq->triggerType) {




×







2345



      case WINDOW_TYPE_STATE: {




×







2346



        // state trigger










2347



        if (!tDecodeIsEnd(pDecoder)) {




×







2348



          TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pReq->trigger.stateWin.expr, NULL));




×







2349



        }










2350



        if (!tDecodeIsEnd(pDecoder)) {




×







2351



          TAOS_CHECK_EXIT(tDecodeI16(pDecoder, &pReq->trigger.stateWin.extend));




×







2352



        }










2353



        break;




×







2354



      }










2355



      case WINDOW_TYPE_INTERVAL: {




×







2356



        if (!tDecodeIsEnd(pDecoder)) {




×







2357



          TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pReq->trigger.sliding.overlap));




×







2358



        }










2359



        break;




×







2360



      }










2361



      default:




×







2362



        break;




×







2363



    }










2364



  }










2365












2366



  if (pDecoder->size - pDecoder->pos > leftBytes) {




×







2367



    if (!tDecodeIsEnd(pDecoder)) {




×







2368



      TAOS_CHECK_EXIT(tDecodeU8(pDecoder, &pReq->triggerPrec));




×







2369



    }










2370



  }










2371












2372



_exit:




×







2373












2374



  return code;




×







2375



}










2376












2377



// New deserialization using JSON










2378



// start from taosd ver-3.3.8.6, stream version number 8










2379



int32_t tDeserializeSCMCreateStreamReqImpl(SDecoder *pDecoder, SCMCreateStreamReq *pReq) {




545,727✔





2380



  int32_t code = 0;




545,727✔





2381



  int32_t lino;










2382












2383



  char* json = NULL;




545,727✔





2384



  SJson* pJson = NULL;




545,727✔





2385



  TAOS_CHECK_EXIT(tDecodeCStrAlloc(pDecoder, &json));




545,727✔





2386



  pJson = tjsonParse(json);




545,727✔





2387



  if (pJson == NULL) {




545,727✔





2388



    TAOS_CHECK_EXIT(TSDB_CODE_MND_STREAM_INVALID_JSON);




×







2389



  }










2390



  TAOS_CHECK_EXIT(jsonToSCMCreateStreamReq(pJson, pReq));




545,727✔





2391












2392



_exit:




545,727✔





2393



  taosMemoryFreeClear(json);




545,727✔





2394



  if (NULL != pJson) {




545,727✔





2395



    tjsonDelete(pJson);




545,727✔





2396



  }










2397












2398



  return code;




545,727✔





2399



}










2400












2401












2402



int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStreamReq *pReq) {




261,647✔





2403



  SDecoder decoder = {0};




261,647✔





2404



  tDecoderInit(&decoder, buf, bufLen);




261,647✔





2405



  int32_t code = 0;




261,647✔





2406



  int32_t lino;










2407












2408



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




261,647✔





2409



  










2410



  code = tDeserializeSCMCreateStreamReqImpl(&decoder, pReq);




261,647✔





2411



  if (TSDB_CODE_MND_STREAM_INVALID_JSON == code) {




261,647✔





2412



    uError("invalid json for stream create request, try old deserialization");




×







2413



    // try old deserialization for backward compatibility










2414



    tDecoderClear(&decoder);




×







2415



    tDecoderInit(&decoder, buf, bufLen);




×







2416



    TAOS_CHECK_EXIT(tStartDecode(&decoder));




×







2417



    TAOS_CHECK_EXIT(tDeserializeSCMCreateStreamReqImplOld(&decoder, pReq, 0));




×







2418



  }










2419












2420



  tEndDecode(&decoder);




261,647✔





2421












2422



_exit:




261,647✔





2423












2424



  tDecoderClear(&decoder);




261,647✔





2425



  return code;




261,647✔





2426



}










2427












2428












2429



int32_t tSerializeSMDropStreamReq(void *buf, int32_t bufLen, const SMDropStreamReq *pReq) {




58,764✔





2430



  int32_t  code = 0;




58,764✔





2431



  int32_t  lino;










2432



  int32_t  tlen;










2433



  SEncoder encoder = {0};




58,764✔





2434



  tEncoderInit(&encoder, buf, bufLen);




58,764✔





2435












2436



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




58,764✔





2437












2438



  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->count));




117,528✔





2439



  for (int32_t i = 0; i < pReq->count; i++) {




124,608✔





2440



    int32_t nameLen = pReq->name[i] == NULL ? 0 : (int32_t)strlen(pReq->name[i]) + 1;




65,844✔





2441



    TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name[i], nameLen));




131,688✔





2442



  }










2443



  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));




117,528✔





2444












2445



  tEndEncode(&encoder);




58,764✔





2446












2447



_exit:




58,764✔





2448



  if (code) {




58,764✔





2449



    tlen = code;




×







2450



  } else {










2451



    tlen = encoder.pos;




58,764✔





2452



  }










2453



  tEncoderClear(&encoder);




58,764✔





2454



  return tlen;




58,764✔





2455



}










2456












2457



int32_t tDeserializeSMDropStreamReq(void *buf, int32_t bufLen, SMDropStreamReq *pReq) {




22,958✔





2458



  SDecoder decoder = {0};




22,958✔





2459



  int32_t  code = 0;




22,958✔





2460



  int32_t  lino;










2461



  tDecoderInit(&decoder, buf, bufLen);




22,958✔





2462












2463



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




22,958✔





2464



  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->count));




45,916✔





2465



  if (pReq->count > 0) {




22,958✔





2466



    pReq->name = taosMemoryCalloc(pReq->count, sizeof(char*));




22,958✔





2467



    if (pReq->name == NULL) {




22,958✔





2468



      code = terrno;




×







2469



      goto _exit;




×







2470



    }










2471



    for (int32_t i = 0; i < pReq->count; i++) {




49,444✔





2472



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name[i], NULL));




52,972✔





2473



    }










2474



  }










2475



  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));




45,916✔





2476












2477



  tEndDecode(&decoder);




22,958✔





2478












2479



_exit:




22,958✔





2480



  tDecoderClear(&decoder);




22,958✔





2481



  return code;




22,958✔





2482



}










2483












2484



void tFreeMDropStreamReq(SMDropStreamReq *pReq) {




53,228✔





2485



  if (NULL == pReq) {




53,228✔





2486



    return;




×







2487



  }










2488



  if (pReq->name) {




53,228✔





2489



    for (int32_t i = 0; i < pReq->count; i++) {




113,524✔





2490



      taosMemoryFreeClear(pReq->name[i]);




60,296✔





2491



    }










2492



    taosMemoryFreeClear(pReq->name);




53,228✔





2493



  }










2494



}










2495












2496



static FORCE_INLINE void tFreeStreamCalcScan(void* pScan) {




2,452,882✔





2497



  if (pScan == NULL) {




2,452,882✔





2498



    return;




×







2499



  }










2500



  SStreamCalcScan *pCalcScan = (SStreamCalcScan *)pScan;




2,452,882✔





2501



  taosArrayDestroy(pCalcScan->vgList);




2,452,882✔





2502



  taosMemoryFreeClear(pCalcScan->scanPlan);




2,452,882✔





2503



}










2504












2505



void tFreeStreamOutCol(void* pCol) {




84,421✔





2506



  if (pCol == NULL) {




84,421✔





2507



    return;




×







2508



  }










2509



  SStreamOutCol *pOutCol = (SStreamOutCol *)pCol;




84,421✔





2510



  taosMemoryFreeClear(pOutCol->expr);




84,421✔





2511



}










2512












2513












2514












2515



void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {




1,491,368✔





2516



  if (NULL == pReq) {




1,491,368✔





2517



    return;




246,913✔





2518



  }










2519



  taosMemoryFreeClear(pReq->name);




1,244,455✔





2520



  taosMemoryFreeClear(pReq->sql);




1,244,455✔





2521



  taosMemoryFreeClear(pReq->streamDB);




1,244,455✔





2522



  taosMemoryFreeClear(pReq->triggerDB);




1,244,455✔





2523



  taosMemoryFreeClear(pReq->outDB);




1,244,455✔





2524



  taosMemoryFreeClear(pReq->triggerTblName);




1,244,455✔





2525



  taosMemoryFreeClear(pReq->outTblName);




1,244,455✔





2526












2527



  taosArrayDestroyP(pReq->calcDB, NULL);




1,244,455✔





2528



  pReq->calcDB = NULL;




1,244,455✔





2529



  taosArrayDestroyP(pReq->pNotifyAddrUrls, NULL);




1,244,455✔





2530



  pReq->pNotifyAddrUrls = NULL;




1,244,455✔





2531












2532



  taosMemoryFreeClear(pReq->triggerFilterCols);




1,244,455✔





2533



  taosMemoryFreeClear(pReq->triggerCols);




1,244,455✔





2534



  taosMemoryFreeClear(pReq->partitionCols);




1,244,455✔





2535












2536



  taosArrayDestroy(pReq->outTags);




1,244,455✔





2537



  pReq->outTags = NULL;




1,244,455✔





2538



  taosArrayDestroy(pReq->outCols);




1,244,455✔





2539



  pReq->outCols = NULL;




1,244,455✔





2540












2541



  switch (pReq->triggerType) {




1,244,455✔





2542



    case WINDOW_TYPE_STATE:




399,700✔





2543



      taosArrayDestroy(pReq->trigger.stateWin.pSlotIds);




399,700✔





2544



      pReq->trigger.stateWin.pSlotIds = NULL;




399,700✔





2545



      taosMemoryFreeClear(pReq->trigger.stateWin.zeroth);




399,700✔





2546



      taosMemoryFreeClear(pReq->trigger.stateWin.expr);




399,700✔





2547



      break;




399,700✔





2548



    case WINDOW_TYPE_EVENT:




120,087✔





2549



      taosMemoryFreeClear(pReq->trigger.event.startCond);




120,087✔





2550



      taosMemoryFreeClear(pReq->trigger.event.endCond);




120,087✔





2551



      break;




120,087✔





2552



    default:




724,668✔





2553



      break;




724,668✔





2554



  }










2555












2556



  taosMemoryFreeClear(pReq->triggerScanPlan);




1,244,455✔





2557



  taosArrayDestroyEx(pReq->calcScanPlanList, tFreeStreamCalcScan);




1,244,455✔





2558



  pReq->calcScanPlanList = NULL;




1,244,455✔





2559



  taosMemoryFreeClear(pReq->triggerPrevFilter);




1,244,455✔





2560












2561



  taosMemoryFreeClear(pReq->calcPlan);




1,244,455✔





2562



  taosMemoryFreeClear(pReq->subTblNameExpr);




1,244,455✔





2563



  taosMemoryFreeClear(pReq->tagValueExpr);




1,244,455✔





2564



  taosArrayDestroyEx(pReq->forceOutCols, tFreeStreamOutCol);




1,244,455✔





2565



  pReq->forceOutCols = NULL;




1,244,455✔





2566



  taosArrayDestroy(pReq->colCids);




1,244,455✔





2567



  pReq->colCids = NULL;




1,244,455✔





2568



  taosArrayDestroy(pReq->tagCids);




1,244,455✔





2569



  pReq->tagCids = NULL;




1,244,455✔





2570



}










2571












2572



int32_t tCloneStreamCreateDeployPointers(SCMCreateStreamReq *pSrc, SCMCreateStreamReq** ppDst) {




236,160✔





2573



  int32_t code = 0, lino = 0;




236,160✔





2574



  if (NULL == pSrc) {




236,160✔





2575



    return code;




×







2576



  } 










2577












2578



  void* p = NULL;




236,160✔





2579



  int32_t num = 0;




236,160✔





2580



  *ppDst = taosMemoryCalloc(1, sizeof(SCMCreateStreamReq));




236,160✔





2581



  TSDB_CHECK_NULL(*ppDst, code, lino, _exit, terrno);




236,160✔





2582












2583



  SCMCreateStreamReq* pDst = *ppDst;




236,160✔





2584












2585



  if (pSrc->outDB) {




236,160✔





2586



    pDst->outDB = COPY_STR(pSrc->outDB);




232,691✔





2587



    TSDB_CHECK_NULL(pDst->outDB, code, lino, _exit, terrno);




232,691✔





2588



  }










2589



  










2590



  if (pSrc->triggerTblName) {




236,160✔





2591



    pDst->triggerTblName = COPY_STR(pSrc->triggerTblName);




231,545✔





2592



    TSDB_CHECK_NULL(pDst->triggerTblName, code, lino, _exit, terrno);




231,545✔





2593



  }










2594



  










2595



  if (pSrc->outTblName) {




236,160✔





2596



    pDst->outTblName = COPY_STR(pSrc->outTblName);




232,691✔





2597



    TSDB_CHECK_NULL(pDst->outTblName, code, lino, _exit, terrno);




232,691✔





2598



  }










2599



  










2600



  if (pSrc->pNotifyAddrUrls) {




236,160✔





2601



    num = taosArrayGetSize(pSrc->pNotifyAddrUrls);




58,743✔





2602



    if (num > 0) {




58,743✔





2603



      pDst->pNotifyAddrUrls = taosArrayInit(num, POINTER_BYTES);




58,743✔





2604



      TSDB_CHECK_NULL(pDst->pNotifyAddrUrls, code, lino, _exit, terrno);




58,743✔





2605



    }










2606



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




117,486✔





2607



      p = taosStrdup(taosArrayGetP(pSrc->pNotifyAddrUrls, i));




58,743✔





2608



      TSDB_CHECK_NULL(p, code, lino, _exit, terrno);




58,743✔





2609



      TSDB_CHECK_NULL(taosArrayPush(pDst->pNotifyAddrUrls, &p), code, lino, _exit, terrno);




117,486✔





2610



    }










2611



  }










2612



  










2613



  if (pSrc->triggerFilterCols) {




236,160✔





2614



    pDst->triggerFilterCols = COPY_STR(pSrc->triggerFilterCols);




18,720✔





2615



    TSDB_CHECK_NULL(pDst->triggerFilterCols, code, lino, _exit, terrno);




18,720✔





2616



  }










2617



  










2618



  if (pSrc->triggerCols) {




236,160✔





2619



    pDst->triggerCols = COPY_STR(pSrc->triggerCols);




224,998✔





2620



    TSDB_CHECK_NULL(pDst->triggerCols, code, lino, _exit, terrno);




224,998✔





2621



  }










2622



  










2623



  if (pSrc->partitionCols) {




236,160✔





2624



    pDst->partitionCols = COPY_STR(pSrc->partitionCols);




84,022✔





2625



    TSDB_CHECK_NULL(pDst->partitionCols, code, lino, _exit, terrno);




84,022✔





2626



  }










2627



  










2628



  if (pSrc->outCols) {




236,160✔





2629



    pDst->outCols = taosArrayDup(pSrc->outCols, NULL);




232,691✔





2630



    TSDB_CHECK_NULL(pDst->outCols, code, lino, _exit, terrno);




232,691✔





2631



  }










2632



  










2633



  if (pSrc->outTags) {




236,160✔





2634



    pDst->outTags = taosArrayDup(pSrc->outTags, NULL);




84,022✔





2635



    TSDB_CHECK_NULL(pDst->outTags, code, lino, _exit, terrno);




84,022✔





2636



  }










2637












2638



  pDst->triggerType = pSrc->triggerType;




236,160✔





2639



  










2640



  switch (pSrc->triggerType) {




236,160✔





2641



    case WINDOW_TYPE_STATE:




88,333✔





2642



      if (pSrc->trigger.stateWin.pSlotIds) {




88,333✔





2643



        pDst->trigger.stateWin.pSlotIds = taosArrayDup(pSrc->trigger.stateWin.pSlotIds, NULL);




88,333✔





2644



        TSDB_CHECK_NULL(pDst->trigger.stateWin.pSlotIds, code, lino, _exit, terrno);




88,333✔





2645



      }










2646



      pDst->trigger.stateWin.extend = pSrc->trigger.stateWin.extend;




88,333✔





2647



      pDst->trigger.stateWin.trueForType = pSrc->trigger.stateWin.trueForType;




88,333✔





2648



      pDst->trigger.stateWin.trueForCount = pSrc->trigger.stateWin.trueForCount;




88,333✔





2649



      pDst->trigger.stateWin.trueForDuration = pSrc->trigger.stateWin.trueForDuration;




88,333✔





2650



      if (pSrc->trigger.stateWin.zeroth) {




88,333✔





2651



        pDst->trigger.stateWin.zeroth = COPY_STR(pSrc->trigger.stateWin.zeroth);




5,106✔





2652



        TSDB_CHECK_NULL(pDst->trigger.stateWin.zeroth, code, lino, _exit, terrno);




5,106✔





2653



      }










2654



      if (pSrc->trigger.stateWin.expr) {




88,333✔





2655



        pDst->trigger.stateWin.expr = COPY_STR(pSrc->trigger.stateWin.expr);




88,333✔





2656



        TSDB_CHECK_NULL(pDst->trigger.stateWin.expr, code, lino, _exit, terrno);




88,333✔





2657



      }










2658



      break;




88,333✔





2659



    case WINDOW_TYPE_EVENT:




25,625✔





2660



      if (pSrc->trigger.event.startCond) {




25,625✔





2661



        pDst->trigger.event.startCond = COPY_STR(pSrc->trigger.event.startCond);




25,625✔





2662



        TSDB_CHECK_NULL(pDst->trigger.event.startCond, code, lino, _exit, terrno);




25,625✔





2663



      }










2664



      










2665



      if (pSrc->trigger.event.endCond) {




25,625✔





2666



        pDst->trigger.event.endCond = COPY_STR(pSrc->trigger.event.endCond);




23,353✔





2667



        TSDB_CHECK_NULL(pDst->trigger.event.endCond, code, lino, _exit, terrno);




23,353✔





2668



      }










2669



      pDst->trigger.event.trueForType = pSrc->trigger.event.trueForType;




25,625✔





2670



      pDst->trigger.event.trueForCount = pSrc->trigger.event.trueForCount;




25,625✔





2671



      pDst->trigger.event.trueForDuration = pSrc->trigger.event.trueForDuration;




25,625✔





2672



      break;




25,625✔





2673



    case WINDOW_TYPE_COUNT:




24,226✔





2674



      pDst->trigger.count.countVal = pSrc->trigger.count.countVal;




24,226✔





2675



      pDst->trigger.count.sliding = pSrc->trigger.count.sliding;




24,226✔





2676



      if (pSrc->trigger.count.condCols) {




24,226✔





2677



        pDst->trigger.count.condCols = COPY_STR(pSrc->trigger.count.condCols);




×







2678



        TSDB_CHECK_NULL(pDst->trigger.count.condCols, code, lino, _exit, terrno);




×







2679



      }










2680



      break;




24,226✔





2681



    default:




97,976✔





2682



      pDst->trigger = pSrc->trigger;




97,976✔





2683



      break;




97,976✔





2684



  }










2685












2686












2687



  if (pSrc->triggerScanPlan) {




236,160✔





2688



    pDst->triggerScanPlan = COPY_STR(pSrc->triggerScanPlan);




231,545✔





2689



    TSDB_CHECK_NULL(pDst->triggerScanPlan, code, lino, _exit, terrno);




231,545✔





2690



  }










2691



  










2692



  if (pSrc->calcScanPlanList) {




236,160✔





2693



    num = taosArrayGetSize(pSrc->calcScanPlanList);




232,691✔





2694



    if (num > 0) {




232,691✔





2695



      pDst->calcScanPlanList = taosArrayInit(num, sizeof(SStreamCalcScan));




232,691✔





2696



      TSDB_CHECK_NULL(pDst->calcScanPlanList, code, lino, _exit, terrno);




232,691✔





2697



    }










2698



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




745,534✔





2699



      SStreamCalcScan* sscan = taosArrayGet(pSrc->calcScanPlanList, i);




512,843✔





2700



      SStreamCalcScan  dscan = {.readFromCache = sscan->readFromCache};




512,843✔





2701












2702



      dscan.vgList = taosArrayDup(sscan->vgList, NULL);




512,843✔





2703



      TSDB_CHECK_NULL(dscan.vgList, code, lino, _exit, terrno);




512,843✔





2704












2705



      dscan.scanPlan = COPY_STR(sscan->scanPlan);




512,843✔





2706



      TSDB_CHECK_NULL(dscan.scanPlan, code, lino, _exit, terrno);




512,843✔





2707



      










2708



      TSDB_CHECK_NULL(taosArrayPush(pDst->calcScanPlanList, &dscan), code, lino, _exit, terrno);




1,025,686✔





2709



    }










2710



  }










2711



  










2712



  if (pSrc->triggerPrevFilter) {




236,160✔





2713



    pDst->triggerPrevFilter = COPY_STR(pSrc->triggerPrevFilter);




8,020✔





2714



    TSDB_CHECK_NULL(pDst->triggerPrevFilter, code, lino, _exit, terrno);




8,020✔





2715



  }










2716



  










2717



  if (pSrc->calcPlan) {




236,160✔





2718



    pDst->calcPlan = COPY_STR(pSrc->calcPlan);




232,691✔





2719



    TSDB_CHECK_NULL(pDst->calcPlan, code, lino, _exit, terrno);




232,691✔





2720



  }










2721



  










2722



  if (pSrc->subTblNameExpr) {




236,160✔





2723



    pDst->subTblNameExpr = COPY_STR(pSrc->subTblNameExpr);




84,022✔





2724



    TSDB_CHECK_NULL(pDst->subTblNameExpr, code, lino, _exit, terrno);




84,022✔





2725



  }










2726



  










2727



  if (pSrc->tagValueExpr) {




236,160✔





2728



    pDst->tagValueExpr = COPY_STR(pSrc->tagValueExpr);




84,022✔





2729



    TSDB_CHECK_NULL(pDst->tagValueExpr, code, lino, _exit, terrno);




84,022✔





2730



  }










2731



  










2732



  if (pSrc->forceOutCols) {




236,160✔





2733



    num = taosArrayGetSize(pSrc->forceOutCols);




3,665✔





2734



    if (num > 0) {




3,665✔





2735



      pDst->forceOutCols = taosArrayInit(num, sizeof(SStreamOutCol));




3,665✔





2736



      TSDB_CHECK_NULL(pDst->forceOutCols, code, lino, _exit, terrno);




3,665✔





2737



    }










2738



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




24,406✔





2739



      SStreamOutCol* scol = taosArrayGet(pSrc->forceOutCols, i);




20,741✔





2740



      SStreamOutCol  dcol = {.type = scol->type};




20,741✔





2741












2742



      dcol.expr = COPY_STR(scol->expr);




20,741✔





2743



      TSDB_CHECK_NULL(dcol.expr, code, lino, _exit, terrno);




20,741✔





2744



      










2745



      TSDB_CHECK_NULL(taosArrayPush(pDst->forceOutCols, &dcol), code, lino, _exit, terrno);




41,482✔





2746



    }










2747



  }










2748












2749



  if (pSrc->colCids) {




236,160✔





2750



    pDst->colCids = taosArrayDup(pSrc->colCids, NULL);




4,775✔





2751



    TSDB_CHECK_NULL(pDst->colCids, code, lino, _exit, terrno);




4,775✔





2752



  }










2753












2754



  if (pSrc->tagCids) {




236,160✔





2755



    pDst->tagCids = taosArrayDup(pSrc->tagCids, NULL);




3,810✔





2756



    TSDB_CHECK_NULL(pDst->tagCids, code, lino, _exit, terrno);




3,810✔





2757



  }










2758












2759



  pDst->triggerTblUid = pSrc->triggerTblUid;




236,160✔





2760



  pDst->triggerTblSuid = pSrc->triggerTblSuid;




236,160✔





2761



  pDst->triggerTblType = pSrc->triggerTblType;




236,160✔





2762



  pDst->triggerPrec = pSrc->triggerPrec;




236,160✔





2763



  pDst->deleteReCalc = pSrc->deleteReCalc;




236,160✔





2764



  pDst->deleteOutTbl = pSrc->deleteOutTbl;




236,160✔





2765



  pDst->flags = pSrc->flags;




236,160✔





2766



  










2767



_exit:




236,160✔





2768












2769



  if (code) {




236,160✔





2770



    tFreeSCMCreateStreamReq(pDst);




×







2771



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




×







2772



  }










2773












2774



  return code;




236,160✔





2775



}










2776












2777












2778



int32_t tSerializeSMPauseStreamReq(void *buf, int32_t bufLen, const SMPauseStreamReq *pReq) {




6,708✔





2779



  int32_t  code = 0;




6,708✔





2780



  int32_t  lino;










2781



  int32_t  tlen;










2782



  SEncoder encoder = {0};




6,708✔





2783



  tEncoderInit(&encoder, buf, bufLen);




6,708✔





2784



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




6,708✔





2785












2786



  int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;




6,708✔





2787



  TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));




13,416✔





2788



  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));




13,416✔





2789



  tEndEncode(&encoder);




6,708✔





2790












2791



_exit:




6,708✔





2792



  if (code) {




6,708✔





2793



    tlen = code;




×







2794



  } else {










2795



    tlen = encoder.pos;




6,708✔





2796



  }










2797



  tEncoderClear(&encoder);




6,708✔





2798



  return tlen;




6,708✔





2799



}










2800












2801



int32_t tDeserializeSMPauseStreamReq(void *buf, int32_t bufLen, SMPauseStreamReq *pReq) {




3,169✔





2802



  SDecoder decoder = {0};




3,169✔





2803



  int32_t  code = 0;




3,169✔





2804



  int32_t  lino;










2805












2806



  tDecoderInit(&decoder, buf, bufLen);




3,169✔





2807



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




3,169✔





2808



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));




6,338✔





2809



  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));




6,338✔





2810



  tEndDecode(&decoder);




3,169✔





2811












2812



_exit:




3,169✔





2813



  tDecoderClear(&decoder);




3,169✔





2814



  return code;




3,169✔





2815



}










2816












2817



void tFreeMPauseStreamReq(SMPauseStreamReq *pReq) {




3,354✔





2818



  taosMemoryFreeClear(pReq->name);




3,354✔





2819



}




3,354✔





2820












2821



int32_t tSerializeSMResumeStreamReq(void *buf, int32_t bufLen, const SMResumeStreamReq *pReq) {




5,900✔





2822



  SEncoder encoder = {0};




5,900✔





2823



  int32_t  code = 0;




5,900✔





2824



  int32_t  lino;










2825



  int32_t  tlen;










2826



  tEncoderInit(&encoder, buf, bufLen);




5,900✔





2827



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




5,900✔





2828



  int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;




5,900✔





2829



  TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));




11,800✔





2830



  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igNotExists));




11,800✔





2831



  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->igUntreated));




11,800✔





2832



  tEndEncode(&encoder);




5,900✔





2833












2834



_exit:




5,900✔





2835



  if (code) {




5,900✔





2836



    tlen = code;




×







2837



  } else {










2838



    tlen = encoder.pos;




5,900✔





2839



  }










2840



  tEncoderClear(&encoder);




5,900✔





2841



  return tlen;




5,900✔





2842



}










2843












2844



int32_t tDeserializeSMResumeStreamReq(void *buf, int32_t bufLen, SMResumeStreamReq *pReq) {




2,765✔





2845



  SDecoder decoder = {0};




2,765✔





2846



  int32_t  code = 0;




2,765✔





2847



  int32_t  lino;










2848












2849



  tDecoderInit(&decoder, buf, bufLen);




2,765✔





2850



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




2,765✔





2851



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));




5,530✔





2852



  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igNotExists));




5,530✔





2853



  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->igUntreated));




5,530✔





2854



  tEndDecode(&decoder);




2,765✔





2855












2856



_exit:




2,765✔





2857



  tDecoderClear(&decoder);




2,765✔





2858



  return code;




2,765✔





2859



}










2860












2861



void tFreeMResumeStreamReq(SMResumeStreamReq *pReq) {




2,950✔





2862



  taosMemoryFreeClear(pReq->name);




2,950✔





2863



}




2,950✔





2864












2865



int32_t tSerializeSMRecalcStreamReq(void *buf, int32_t bufLen, const SMRecalcStreamReq *pReq) {




26,640✔





2866



  SEncoder encoder = {0};




26,640✔





2867



  int32_t  code = 0;




26,640✔





2868



  int32_t  lino;










2869



  int32_t  tlen;










2870



  tEncoderInit(&encoder, buf, bufLen);




26,640✔





2871



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




26,640✔





2872



  int32_t nameLen = pReq->name == NULL ? 0 : (int32_t)strlen(pReq->name) + 1;




26,640✔





2873



  TAOS_CHECK_EXIT(tEncodeBinary(&encoder, pReq->name, nameLen));




53,280✔





2874



  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->calcAll));




53,280✔





2875



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->timeRange.skey));




53,280✔





2876



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->timeRange.ekey));




53,280✔





2877



  tEndEncode(&encoder);




26,640✔





2878












2879



_exit:




26,640✔





2880



  if (code) {




26,640✔





2881



    tlen = code;




×







2882



  } else {










2883



    tlen = encoder.pos;




26,640✔





2884



  }










2885



  tEncoderClear(&encoder);




26,640✔





2886



  return tlen;




26,640✔





2887



}










2888












2889



int32_t tDeserializeSMRecalcStreamReq(void *buf, int32_t bufLen, SMRecalcStreamReq *pReq) {




13,315✔





2890



  SDecoder decoder = {0};




13,315✔





2891



  int32_t  code = 0;




13,315✔





2892



  int32_t  lino;










2893












2894



  tDecoderInit(&decoder, buf, bufLen);




13,315✔





2895



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




13,315✔





2896












2897



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(&decoder, (void**)&pReq->name, NULL));




26,630✔





2898



  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->calcAll));




26,630✔





2899



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->timeRange.skey));




26,630✔





2900



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->timeRange.ekey));




26,630✔





2901



  tEndDecode(&decoder);




13,315✔





2902












2903



_exit:




13,315✔





2904



  tDecoderClear(&decoder);




13,315✔





2905



  return code;




13,315✔





2906



}










2907












2908



void tFreeMRecalcStreamReq(SMRecalcStreamReq *pReq) {




26,635✔





2909



  taosMemoryFreeClear(pReq->name);




26,635✔





2910



}




26,635✔





2911












2912



static int32_t tEncodeStreamProgressReq(SEncoder *pEncoder, const SStreamProgressReq *pReq) {




13,912✔





2913



  int32_t code = 0;




13,912✔





2914



  int32_t lino;










2915












2916



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->streamId));




27,824✔





2917



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pReq->taskId));




27,824✔





2918



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pReq->fetchIdx));




27,824✔





2919












2920



_exit:




13,912✔





2921



  return code;




13,912✔





2922



}










2923












2924



int32_t tSerializeStreamProgressReq(void *buf, int32_t bufLen, const SStreamProgressReq *pReq) {




13,912✔





2925



  SEncoder encoder = {0};




13,912✔





2926



  int32_t  code = 0;




13,912✔





2927



  int32_t  lino;










2928



  int32_t  tlen;










2929



  tEncoderInit(&encoder, buf, bufLen);




13,912✔





2930












2931



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




13,912✔





2932



  TAOS_CHECK_EXIT(tEncodeStreamProgressReq(&encoder, pReq));




13,912✔





2933












2934



  tEndEncode(&encoder);




13,912✔





2935












2936



_exit:




13,912✔





2937



  if (code) {




13,912✔





2938



    tlen = code;




×







2939



  } else {










2940



    tlen = encoder.pos;




13,912✔





2941



  }










2942



  tEncoderClear(&encoder);




13,912✔





2943



  return tlen;




13,912✔





2944



}










2945












2946



static int32_t tDecodeStreamProgressReq(SDecoder *pDecoder, SStreamProgressReq *pReq) {




11,544✔





2947



  int32_t code = 0;




11,544✔





2948



  int32_t lino;










2949












2950



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->streamId));




23,088✔





2951



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pReq->taskId));




23,088✔





2952



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pReq->fetchIdx));




23,088✔





2953












2954



_exit:




11,544✔





2955



  return code;




11,544✔





2956



}










2957












2958



int32_t tDeserializeStreamProgressReq(void *buf, int32_t bufLen, SStreamProgressReq *pReq) {




11,544✔





2959



  SDecoder decoder = {0};




11,544✔





2960



  int32_t  code = 0;




11,544✔





2961



  int32_t  lino;










2962












2963



  tDecoderInit(&decoder, (char *)buf, bufLen);




11,544✔





2964












2965



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




11,544✔





2966



  TAOS_CHECK_EXIT(tDecodeStreamProgressReq(&decoder, pReq));




11,544✔





2967












2968



  tEndDecode(&decoder);




11,544✔





2969












2970



_exit:




11,544✔





2971



  tDecoderClear(&decoder);




11,544✔





2972



  return code;




11,544✔





2973



}










2974












2975



static int32_t tEncodeStreamProgressRsp(SEncoder *pEncoder, const SStreamProgressRsp *pRsp) {




13,912✔





2976



  int32_t code = 0;




13,912✔





2977



  int32_t lino;










2978












2979



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->streamId));




27,824✔





2980



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pRsp->fillHisFinished));




27,824✔





2981



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pRsp->progressDelay));




27,824✔





2982



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pRsp->fetchIdx));




27,824✔





2983












2984



_exit:




13,912✔





2985



  return code;




13,912✔





2986



}










2987












2988



int32_t tSerializeStreamProgressRsp(void *buf, int32_t bufLen, const SStreamProgressRsp *pRsp) {




13,912✔





2989



  SEncoder encoder = {0};




13,912✔





2990



  int32_t  code = 0;




13,912✔





2991



  int32_t  lino;










2992



  int32_t  tlen;










2993



  tEncoderInit(&encoder, buf, bufLen);




13,912✔





2994












2995



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




13,912✔





2996



  TAOS_CHECK_EXIT(tEncodeStreamProgressRsp(&encoder, pRsp));




13,912✔





2997












2998



  tEndEncode(&encoder);




13,912✔





2999












3000



_exit:




13,912✔





3001



  if (code) {




13,912✔





3002



    tlen = code;




×







3003



  } else {










3004



    tlen = encoder.pos;




13,912✔





3005



  }










3006



  tEncoderClear(&encoder);




13,912✔





3007



  return tlen;




13,912✔





3008



}










3009












3010



static int32_t tDecodeStreamProgressRsp(SDecoder *pDecoder, SStreamProgressRsp *pRsp) {




6,956✔





3011



  int32_t code = 0;




6,956✔





3012



  int32_t lino;










3013












3014



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->streamId));




13,912✔





3015



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, (int8_t *)&pRsp->fillHisFinished));




13,912✔





3016



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pRsp->progressDelay));




13,912✔





3017



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pRsp->fetchIdx));




13,912✔





3018












3019



_exit:




6,956✔





3020



  return code;




6,956✔





3021



}










3022












3023



int32_t tDeserializeSStreamProgressRsp(void *buf, int32_t bufLen, SStreamProgressRsp *pRsp) {




6,956✔





3024



  SDecoder decoder = {0};




6,956✔





3025



  int32_t  code = 0;




6,956✔





3026



  int32_t  lino;










3027












3028



  tDecoderInit(&decoder, buf, bufLen);




6,956✔





3029












3030



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




6,956✔





3031



  TAOS_CHECK_EXIT(tDecodeStreamProgressRsp(&decoder, pRsp));




6,956✔





3032












3033



  tEndDecode(&decoder);




6,956✔





3034












3035



_exit:




6,956✔





3036



  tDecoderClear(&decoder);




6,956✔





3037



  return code;




6,956✔





3038



}










3039












3040



int32_t tSerializeSTriggerOrigTableInfoRsp(void* buf, int32_t bufLen, const SSTriggerOrigTableInfoRsp* pRsp){




284,818✔





3041



  SEncoder encoder = {0};




284,818✔





3042



  int32_t  code = TSDB_CODE_SUCCESS;




284,818✔





3043



  int32_t  lino = 0;




284,818✔





3044



  int32_t  tlen = 0;




284,818✔





3045












3046



  tEncoderInit(&encoder, buf, bufLen);




284,818✔





3047



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




284,818✔





3048












3049



  int32_t size = taosArrayGetSize(pRsp->cols);




284,818✔





3050



  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));




284,818✔





3051



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




1,044,794✔





3052



    OTableInfoRsp* oInfo = taosArrayGet(pRsp->cols, i);




759,976✔





3053



    if (oInfo == NULL) {




759,976✔





3054



      uError("col id is NULL at index %d", i);




×







3055



      code = TSDB_CODE_INVALID_PARA;




×







3056



      goto _exit;




×







3057



    }










3058



    TAOS_CHECK_EXIT(tEncodeI64(&encoder, oInfo->suid));




1,520,188✔





3059



    TAOS_CHECK_EXIT(tEncodeI64(&encoder, oInfo->uid));




1,520,424✔





3060



    TAOS_CHECK_EXIT(tEncodeI16(&encoder, oInfo->cid));




1,520,188✔





3061



  }










3062












3063



  tEndEncode(&encoder);




284,818✔





3064












3065



_exit:




284,818✔





3066



  if (code != TSDB_CODE_SUCCESS) {




284,818✔





3067



    tlen = code;




×







3068



  } else {










3069



    tlen = encoder.pos;




284,818✔





3070



  }










3071



  tEncoderClear(&encoder);




284,818✔





3072



  return tlen;




284,818✔





3073



}










3074












3075



int32_t tDserializeSTriggerOrigTableInfoRsp(void* buf, int32_t bufLen, SSTriggerOrigTableInfoRsp* pRsp){




142,409✔





3076



  SDecoder decoder = {0};




142,409✔





3077



  int32_t  code = TSDB_CODE_SUCCESS;




142,409✔





3078



  int32_t  lino = 0;




142,409✔





3079












3080



  tDecoderInit(&decoder, buf, bufLen);




142,409✔





3081



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




142,409✔





3082












3083



  int32_t size = 0;




142,409✔





3084



  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));




142,409✔





3085



  pRsp->cols = taosArrayInit(size, sizeof(OTableInfoRsp));




142,409✔





3086



  if (pRsp->cols == NULL) {




142,409✔





3087



    code = terrno;




×







3088



    uError("failed to allocate memory for cids, size: %d, errno: %d", size, code);




×







3089



    goto _exit;




×







3090



  }










3091



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




522,515✔





3092



    OTableInfoRsp* oInfo = taosArrayReserve(pRsp->cols, 1);




380,106✔





3093



    if (oInfo == NULL) {




380,106✔





3094



      code = terrno;




×







3095



      uError("failed to reserve memory for OTableInfo, size: %d, errno: %d", size, code);




×







3096



      goto _exit;




×







3097



    }










3098



    TAOS_CHECK_RETURN(tDecodeI64(&decoder, &oInfo->suid));




760,212✔





3099



    TAOS_CHECK_RETURN(tDecodeI64(&decoder, &oInfo->uid));




760,212✔





3100



    TAOS_CHECK_RETURN(tDecodeI16(&decoder, &oInfo->cid));




760,212✔





3101



  }










3102












3103



  tEndDecode(&decoder);




142,409✔





3104












3105



_exit:




142,409✔





3106



  tDecoderClear(&decoder);




142,409✔





3107



  return code;




142,409✔





3108



}










3109












3110



void    tDestroySTriggerOrigTableInfoRsp(SSTriggerOrigTableInfoRsp* pRsp){




43,308,221✔





3111



  taosArrayDestroy(pRsp->cols);




43,308,221✔





3112



}




43,309,525✔





3113












3114



void tDestroySTriggerPullRequest(SSTriggerPullRequestUnion* pReq) {




52,626,889✔





3115



  if (pReq == NULL) return;




52,626,889✔





3116



  if (pReq->base.type == STRIGGER_PULL_WAL_DATA_NEW || pReq->base.type == STRIGGER_PULL_WAL_CALC_DATA_NEW) {




67,886,145✔





3117



    SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;




15,260,425✔





3118



    taosArrayDestroy(pRequest->versions);




15,260,425✔





3119



    tSimpleHashCleanup(pRequest->ranges);




15,259,518✔





3120



  } else if (pReq->base.type == STRIGGER_PULL_TSDB_DATA) {




37,369,214✔





3121



    SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;




436,110✔





3122



    if (pRequest->cids != NULL) {




436,110✔





3123



      taosArrayDestroy(pRequest->cids);




436,110✔





3124



      pRequest->cids = NULL;




436,110✔





3125



    }










3126



  } else if (pReq->base.type == STRIGGER_PULL_VTABLE_INFO) {




36,932,366✔





3127



    SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;




81,511✔





3128



    if (pRequest->cids != NULL) {




81,511✔





3129



      taosArrayDestroy(pRequest->cids);




81,511✔





3130



      pRequest->cids = NULL;




81,511✔





3131



    }










3132



    if (pRequest->uids != NULL) {




81,511✔





3133



      taosArrayDestroy(pRequest->uids);




×







3134



      pRequest->uids = NULL;




×







3135



    }










3136



  } else if (pReq->base.type == STRIGGER_PULL_VTABLE_PSEUDO_COL) {




36,849,816✔





3137



    SSTriggerVirTablePseudoColRequest *pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;




1,091,280✔





3138



    if (pRequest->cids != NULL) {




1,091,280✔





3139



      taosArrayDestroy(pRequest->cids);




1,091,280✔





3140



      pRequest->cids = NULL;




1,091,280✔





3141



    }










3142



  } else if (pReq->base.type == STRIGGER_PULL_OTABLE_INFO) {




35,759,101✔





3143



    SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;




142,409✔





3144



    if (pRequest->cols != NULL) {




142,409✔





3145



      taosArrayDestroy(pRequest->cols);




142,409✔





3146



      pRequest->cols = NULL;




142,409✔





3147



    }










3148



  } else if (pReq->base.type == STRIGGER_PULL_SET_TABLE) {




35,615,643✔





3149



    SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;




142,409✔





3150



    tSimpleHashCleanup(pRequest->uidInfoTrigger);




142,409✔





3151



    tSimpleHashCleanup(pRequest->uidInfoCalc);




142,409✔





3152



  }










3153



}










3154












3155



int32_t encodePlainArray(SEncoder *encoder, SArray *pArr) {




3,387,628✔





3156



  int32_t  code = TSDB_CODE_SUCCESS;




3,387,628✔





3157



  int32_t  lino = 0;




3,387,628✔





3158



  int32_t  nEle = taosArrayGetSize(pArr);




3,387,628✔





3159



  uint8_t* buf = (nEle > 0) ? TARRAY_DATA(pArr) : NULL;




3,387,364✔





3160



  int32_t  len = (nEle > 0) ? (nEle * pArr->elemSize) : 0;




3,387,364✔





3161



  TAOS_CHECK_EXIT(tEncodeBinary(encoder, buf, len));




6,775,256✔





3162












3163



_exit:




3,387,628✔





3164



  return code;




3,387,628✔





3165



}










3166












3167



int32_t decodePlainArray(SDecoder* decoder, SArray** ppArr, uint32_t elemSize) {




1,690,412✔





3168



  int32_t  code = TSDB_CODE_SUCCESS;




1,690,412✔





3169



  int32_t  lino = 0;




1,690,412✔





3170



  void*    buf = NULL;




1,690,412✔





3171



  uint64_t len = 0;




1,690,412✔





3172



  TAOS_CHECK_EXIT(tDecodeBinaryAlloc(decoder, &buf, &len));




1,690,412✔





3173












3174



  if (len > 0) {




1,690,412✔





3175



    *ppArr = taosArrayInit(0, elemSize);




1,608,901✔





3176



    TSDB_CHECK_NULL(*ppArr, code, lino, _exit, terrno);




1,608,901✔





3177



    TSWAP((*ppArr)->pData, buf);




1,608,901✔





3178



    (*ppArr)->size = (*ppArr)->capacity = len / elemSize;




1,608,901✔





3179



  }










3180












3181



_exit:




1,690,412✔





3182



  if (buf != NULL) {




1,690,412✔





3183



    taosMemoryFree(buf);




1,608,901✔





3184



  }










3185



  return code;




1,690,412✔





3186



}










3187












3188



static int32_t encodeSetTableMapInfo(SEncoder* encoder, SSHashObj* pInfo) {




569,636✔





3189



  int32_t  code = TSDB_CODE_SUCCESS;




569,636✔





3190



  int32_t  lino = 0;




569,636✔





3191



  int32_t size = tSimpleHashGetSize(pInfo);




569,636✔





3192



  TAOS_CHECK_EXIT(tEncodeI32(encoder, size));




569,636✔





3193



  int32_t iter = 0;




569,636✔





3194



  void*   px = tSimpleHashIterate(pInfo, NULL, &iter);




569,636✔





3195



  while (px != NULL) {




1,275,520✔





3196



    int64_t* uid = tSimpleHashGetKey(px, NULL);




705,884✔





3197



    TAOS_CHECK_EXIT(tEncodeI64(encoder, *uid));




1,411,768✔





3198



    TAOS_CHECK_EXIT(tEncodeI64(encoder, *(uid + 1)));




1,411,768✔





3199



    SSHashObj* info = *(SSHashObj**)px;




705,884✔





3200



    int32_t len = tSimpleHashGetSize(info);




705,884✔





3201



    TAOS_CHECK_EXIT(tEncodeI32(encoder, len));




705,884✔





3202



    int32_t iter1 = 0;




705,884✔





3203



    void*   px1 = tSimpleHashIterate(info, NULL, &iter1);




705,884✔





3204



    while (px1 != NULL) {




2,655,424✔





3205



      int16_t* slot = tSimpleHashGetKey(px1, NULL);




1,949,540✔





3206



      int16_t* cid = (int16_t*)px1;




1,949,540✔





3207



      TAOS_CHECK_EXIT(tEncodeI16(encoder, *slot));




3,899,080✔





3208



      TAOS_CHECK_EXIT(tEncodeI16(encoder, *cid));




3,899,080✔





3209












3210



      px1 = tSimpleHashIterate(info, px1, &iter1);




1,949,540✔





3211



    }










3212












3213



    px = tSimpleHashIterate(pInfo, px, &iter);




705,884✔





3214



  }










3215



  










3216



_exit:




569,636✔





3217



  return code;




569,636✔





3218



}










3219












3220



int32_t tSerializeSTriggerPullRequest(void* buf, int32_t bufLen, const SSTriggerPullRequest* pReq) {




105,720,720✔





3221



  SEncoder encoder = {0};




105,720,720✔





3222



  int32_t  code = TSDB_CODE_SUCCESS;




105,721,420✔





3223



  int32_t  lino = 0;




105,721,420✔





3224



  int32_t  tlen = 0;




105,721,420✔





3225












3226



  tEncoderInit(&encoder, buf, bufLen);




105,721,420✔





3227



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




105,720,277✔





3228












3229



  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));




211,443,277✔





3230



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));




211,435,501✔





3231



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->readerTaskId));




211,435,960✔





3232



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));




211,436,645✔





3233












3234



  switch (pReq->type) {




105,716,430✔





3235



    case STRIGGER_PULL_SET_TABLE: {




284,818✔





3236



      SSTriggerSetTableRequest* pRequest = (SSTriggerSetTableRequest*)pReq;




284,818✔





3237



      TAOS_CHECK_EXIT(encodeSetTableMapInfo(&encoder, pRequest->uidInfoTrigger));




284,818✔





3238



      TAOS_CHECK_EXIT(encodeSetTableMapInfo(&encoder, pRequest->uidInfoCalc));




284,818✔





3239



      break;




284,818✔





3240



    }










3241



    case STRIGGER_PULL_LAST_TS: {




684,521✔





3242



      break;




684,521✔





3243



    }










3244



    case STRIGGER_PULL_FIRST_TS: {




706,549✔





3245



      SSTriggerFirstTsRequest* pRequest = (SSTriggerFirstTsRequest*)pReq;




706,549✔





3246



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));




1,413,360✔





3247



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));




1,413,360✔





3248



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




1,413,098✔





3249



      break;




706,549✔





3250



    }










3251



    case STRIGGER_PULL_TSDB_META: {




950,604✔





3252



      SSTriggerTsdbMetaRequest* pRequest = (SSTriggerTsdbMetaRequest*)pReq;




950,604✔





3253



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));




1,901,208✔





3254



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->endTime));




1,901,208✔





3255



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));




1,901,208✔





3256



      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));




1,901,208✔





3257



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




1,901,208✔





3258



      break;




950,604✔





3259



    }










3260



    case STRIGGER_PULL_TSDB_META_NEXT: {




×







3261



      break;




×







3262



    }










3263



    case STRIGGER_PULL_TSDB_TS_DATA: {




159,514✔





3264



      SSTriggerTsdbTsDataRequest* pRequest = (SSTriggerTsdbTsDataRequest*)pReq;




159,514✔





3265



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));




319,028✔





3266



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));




319,028✔





3267



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));




319,028✔





3268



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));




319,028✔





3269



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




319,028✔





3270



      break;




159,514✔





3271



    }










3272



    case STRIGGER_PULL_TSDB_TRIGGER_DATA: {




190,036✔





3273



      SSTriggerTsdbTriggerDataRequest* pRequest = (SSTriggerTsdbTriggerDataRequest*)pReq;




190,036✔





3274



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->startTime));




380,072✔





3275



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));




379,810✔





3276



      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));




379,548✔





3277



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




379,286✔





3278



      break;




189,512✔





3279



    }










3280



    case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {




298,610✔





3281



      break;




298,610✔





3282



    }










3283



    case STRIGGER_PULL_TSDB_CALC_DATA: {




14,376,094✔





3284



      SSTriggerTsdbCalcDataRequest* pRequest = (SSTriggerTsdbCalcDataRequest*)pReq;




14,376,094✔





3285



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));




28,752,188✔





3286



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));




28,752,188✔





3287



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));




28,752,188✔





3288



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




28,752,188✔





3289



      break;




14,376,094✔





3290



    }










3291



    case STRIGGER_PULL_TSDB_CALC_DATA_NEXT: {




×







3292



      break;




×







3293



    }










3294



    case STRIGGER_PULL_TSDB_DATA: {




875,164✔





3295



      SSTriggerTsdbDataRequest* pRequest = (SSTriggerTsdbDataRequest*)pReq;




875,164✔





3296



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->suid));




1,750,328✔





3297



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));




1,750,592✔





3298



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->skey));




1,750,856✔





3299



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ekey));




1,750,856✔





3300



      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));




875,428✔





3301



      TAOS_CHECK_EXIT(tEncodeI8(&encoder, pRequest->order));




1,750,328✔





3302



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




1,750,328✔





3303



      break;




875,164✔





3304



    }










3305



    case STRIGGER_PULL_TSDB_DATA_NEXT: {




×







3306



      break;




×







3307



    }










3308



    case STRIGGER_PULL_WAL_META_NEW: {




41,359,927✔





3309



      SSTriggerWalMetaNewRequest* pRequest = (SSTriggerWalMetaNewRequest*)pReq;




41,359,927✔





3310



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));




82,718,571✔





3311



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ctime));




82,718,546✔





3312



      break;




41,359,902✔





3313



    }










3314



    case STRIGGER_PULL_WAL_DATA_NEW:




30,518,163✔





3315



    case STRIGGER_PULL_WAL_CALC_DATA_NEW: {










3316



      SSTriggerWalDataNewRequest* pRequest = (SSTriggerWalDataNewRequest*)pReq;




30,518,163✔





3317



      int32_t                     nVersion = taosArrayGetSize(pRequest->versions);




30,518,163✔





3318



      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nVersion));




30,518,690✔





3319



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




48,774,376✔





3320



        int64_t ver = *(int64_t*)TARRAY_GET_ELEM(pRequest->versions, i);




18,256,476✔





3321



        TAOS_CHECK_EXIT(tEncodeI64(&encoder, ver));




18,255,686✔





3322



      }










3323



      int32_t nRanges = tSimpleHashGetSize(pRequest->ranges);




30,517,900✔





3324



      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nRanges));




30,519,228✔





3325



      int32_t iter = 0;




30,519,228✔





3326



      void*   px = tSimpleHashIterate(pRequest->ranges, NULL, &iter);




30,519,228✔





3327



      while (px != NULL) {




41,074,862✔





3328



        uint64_t* gid = tSimpleHashGetKey(px, NULL);




10,556,436✔





3329



        TAOS_CHECK_EXIT(tEncodeU64(&encoder, *gid));




21,112,872✔





3330



        int64_t* key = (int64_t*)px;




10,556,436✔





3331



        TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[0]));




21,112,872✔





3332



        TAOS_CHECK_EXIT(tEncodeI64(&encoder, key[1]));




21,112,872✔





3333












3334



        px = tSimpleHashIterate(pRequest->ranges, px, &iter);




10,556,436✔





3335



      }










3336



      break;




30,518,426✔





3337



    }










3338



    case STRIGGER_PULL_WAL_META_DATA_NEW: {




12,015,978✔





3339



      SSTriggerWalMetaDataNewRequest* pRequest = (SSTriggerWalMetaDataNewRequest*)pReq;




12,015,978✔





3340



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->lastVer));




24,031,157✔





3341



      break;




12,015,179✔





3342



    }










3343



    case STRIGGER_PULL_GROUP_COL_VALUE: {




666,810✔





3344



      SSTriggerGroupColValueRequest* pRequest = (SSTriggerGroupColValueRequest*)pReq;




666,810✔





3345



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->gid));




1,333,620✔





3346



      break;




666,810✔





3347



    }










3348



    case STRIGGER_PULL_VTABLE_INFO: {




164,018✔





3349



      SSTriggerVirTableInfoRequest* pRequest = (SSTriggerVirTableInfoRequest*)pReq;




164,018✔





3350



      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));




164,018✔





3351



      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->uids));




164,018✔





3352



      TAOS_CHECK_EXIT(tEncodeBool(&encoder, pRequest->fetchAllTable));




164,018✔





3353



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




328,036✔





3354



      break;




164,018✔





3355



    }










3356



    case STRIGGER_PULL_VTABLE_PSEUDO_COL: {




2,184,164✔





3357



      SSTriggerVirTablePseudoColRequest* pRequest = (SSTriggerVirTablePseudoColRequest*)pReq;




2,184,164✔





3358



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->uid));




4,368,328✔





3359



      TAOS_CHECK_EXIT(encodePlainArray(&encoder, pRequest->cids));




2,184,164✔





3360



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




4,368,328✔





3361



      break;




2,184,164✔





3362



    }










3363



    case STRIGGER_PULL_OTABLE_INFO: {




284,818✔





3364



      SSTriggerOrigTableInfoRequest* pRequest = (SSTriggerOrigTableInfoRequest*)pReq;




284,818✔





3365



      int32_t size = taosArrayGetSize(pRequest->cols);




284,818✔





3366



      TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));




284,818✔





3367



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




1,045,030✔





3368



        OTableInfo* oInfo = taosArrayGet(pRequest->cols, i);




760,212✔





3369



        if (oInfo == NULL) {




760,212✔





3370



          uError("col id is NULL at index %d", i);




×







3371



          code = TSDB_CODE_INVALID_PARA;




×







3372



          goto _exit;




×







3373



        }










3374



        TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refTableName));




1,520,424✔





3375



        TAOS_CHECK_EXIT(tEncodeCStr(&encoder, oInfo->refColName));




1,520,424✔





3376



      }










3377



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRequest->ver));




569,636✔





3378



      break; 




284,818✔





3379



    }











UNCOV

3380



    default: {




×








UNCOV

3381



      uError("unknown pull type %d", pReq->type);




×







3382



      code = TSDB_CODE_INVALID_PARA;




×







3383



      break;




×







3384



    }










3385



  }










3386












3387



  tEndEncode(&encoder);




105,718,703✔





3388












3389



_exit:




105,706,062✔





3390



  if (code != TSDB_CODE_SUCCESS) {




105,713,807✔





3391



    tlen = code;




×







3392



  } else {










3393



    tlen = encoder.pos;




105,713,807✔





3394



  }










3395



  tEncoderClear(&encoder);




105,713,807✔





3396



  return tlen;




105,712,623✔





3397



}










3398












3399



static void destroyHash(void* data){




352,942✔





3400



  if (data){




352,942✔





3401



    SSHashObj* tmp = *(SSHashObj**)data;




352,942✔





3402



    tSimpleHashCleanup(tmp);




352,942✔





3403



  }










3404



}




352,942✔





3405












3406



static int32_t decodeSetTableMapInfo(SDecoder* decoder, SSHashObj** ppInfo) {




284,818✔





3407



  int32_t  code = TSDB_CODE_SUCCESS;




284,818✔





3408



  int32_t  lino = 0;




284,818✔





3409



  int32_t size = 0;




284,818✔





3410



  TAOS_CHECK_EXIT(tDecodeI32(decoder, &size));




284,818✔





3411



  *ppInfo = tSimpleHashInit(size, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY));




284,818✔





3412



  if (*ppInfo == NULL) {




284,818✔





3413



    TAOS_CHECK_EXIT(terrno);




×







3414



  }










3415



  tSimpleHashSetFreeFp(*ppInfo, destroyHash);




284,818✔





3416



  










3417



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




637,760✔





3418



    int64_t id[2] = {0};




352,942✔





3419



    TAOS_CHECK_EXIT(tDecodeI64(decoder, id));




352,942✔





3420



    TAOS_CHECK_EXIT(tDecodeI64(decoder, id+1));




705,884✔





3421



    int32_t len = 0;




352,942✔





3422



    TAOS_CHECK_EXIT(tDecodeI32(decoder, &len));




352,942✔





3423



    SSHashObj* tmp = tSimpleHashInit(len, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT));




352,942✔





3424



    if (tmp == NULL) {




352,942✔





3425



      TAOS_CHECK_EXIT(terrno);




×







3426



    }










3427



    TAOS_CHECK_EXIT(tSimpleHashPut(*ppInfo, id, sizeof(id), &tmp, POINTER_BYTES));




352,942✔





3428












3429



    for (int32_t j = 0; j < len; ++j) {




1,327,712✔





3430



      int16_t slotId = 0;




974,770✔





3431



      int16_t cid = 0;




974,770✔





3432



      TAOS_CHECK_EXIT(tDecodeI16(decoder, &slotId));




974,770✔





3433



      TAOS_CHECK_EXIT(tDecodeI16(decoder, &cid));




974,770✔





3434



      TAOS_CHECK_EXIT(tSimpleHashPut(tmp, &slotId, sizeof(slotId), &cid, sizeof(cid)));




974,770✔





3435



    }










3436



  }










3437



_exit:




284,818✔





3438



  if (code != TSDB_CODE_SUCCESS) {




284,818✔





3439



    tSimpleHashCleanup(*ppInfo);




×







3440



    *ppInfo = NULL;




×







3441



  }










3442



  return code;




284,818✔





3443



}










3444












3445



int32_t tDeserializeSTriggerPullRequest(void* buf, int32_t bufLen, SSTriggerPullRequestUnion* pReq) {




52,629,064✔





3446



  SDecoder decoder = {0};




52,629,064✔





3447



  int32_t  code = TSDB_CODE_SUCCESS;




52,629,064✔





3448



  int32_t  lino = 0;




52,629,064✔





3449












3450



  tDecoderInit(&decoder, buf, bufLen);




52,629,064✔





3451



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




52,629,868✔





3452












3453



  int32_t type = 0;




52,631,417✔





3454



  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));




52,629,820✔





3455



  SSTriggerPullRequest* pBase = &(pReq->base);




52,629,820✔





3456



  pBase->type = type;




52,629,320✔





3457



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->streamId));




105,260,189✔





3458



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->readerTaskId));




105,262,543✔





3459



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pBase->sessionId));




105,263,635✔





3460












3461



  switch (type) {




52,631,961✔





3462



    case STRIGGER_PULL_SET_TABLE: {




142,409✔





3463



      SSTriggerSetTableRequest* pRequest = &(pReq->setTableReq);




142,409✔





3464



      TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoTrigger));




142,409✔





3465



      TAOS_CHECK_EXIT(decodeSetTableMapInfo(&decoder, &pRequest->uidInfoCalc));




142,409✔





3466



      break;




142,409✔





3467



    }










3468



    case STRIGGER_PULL_LAST_TS: {




342,314✔





3469



      break;




342,314✔





3470



    }










3471



    case STRIGGER_PULL_FIRST_TS: {




350,407✔





3472



      SSTriggerFirstTsRequest* pRequest = &(pReq->firstTsReq);




350,407✔





3473



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));




700,814✔





3474



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));




700,814✔





3475



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




700,814✔





3476



      break;




350,407✔





3477



    }










3478



    case STRIGGER_PULL_TSDB_META: {




475,226✔





3479



      SSTriggerTsdbMetaRequest* pRequest = &(pReq->tsdbMetaReq);




475,226✔





3480



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));




950,452✔





3481



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->endTime));




950,452✔





3482



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));




950,452✔





3483



      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));




950,452✔





3484



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




950,452✔





3485



      break;




475,226✔





3486



    }










3487



    case STRIGGER_PULL_TSDB_META_NEXT: {




×







3488



      break;




×







3489



    }










3490



    case STRIGGER_PULL_TSDB_TS_DATA: {




79,757✔





3491



      SSTriggerTsdbTsDataRequest* pRequest = &(pReq->tsdbTsDataReq);




79,757✔





3492



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));




159,514✔





3493



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));




159,514✔





3494



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));




159,514✔





3495



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));




159,514✔





3496



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




159,514✔





3497



      break;




79,757✔





3498



    }










3499



    case STRIGGER_PULL_TSDB_TRIGGER_DATA: {




95,018✔





3500



      SSTriggerTsdbTriggerDataRequest* pRequest = &(pReq->tsdbTriggerDataReq);




95,018✔





3501



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->startTime));




190,036✔





3502



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));




190,036✔





3503



      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));




190,036✔





3504



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




190,036✔





3505



      break;




95,018✔





3506



    }










3507



    case STRIGGER_PULL_TSDB_TRIGGER_DATA_NEXT: {




149,305✔





3508



      break;




149,305✔





3509



    }










3510



    case STRIGGER_PULL_TSDB_CALC_DATA: {




7,186,433✔





3511



      SSTriggerTsdbCalcDataRequest* pRequest = &(pReq->tsdbCalcDataReq);




7,186,433✔





3512



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));




14,373,340✔





3513



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));




14,373,577✔





3514



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));




14,373,340✔





3515



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




14,373,577✔





3516



      break;




7,186,907✔





3517



    }










3518



    case STRIGGER_PULL_TSDB_CALC_DATA_NEXT: {




×







3519



      break;




×







3520



    }










3521



    case STRIGGER_PULL_TSDB_DATA: {




436,110✔





3522



      SSTriggerTsdbDataRequest* pRequest = &(pReq->tsdbDataReq);




436,110✔





3523



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->suid));




872,220✔





3524



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));




872,220✔





3525



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->skey));




872,220✔





3526



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ekey));




872,220✔





3527



      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));




436,110✔





3528



      TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pRequest->order));




872,220✔





3529



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




872,220✔





3530



      break;




436,110✔





3531



    }










3532



    case STRIGGER_PULL_TSDB_DATA_NEXT: {




×







3533



      break;




×







3534



    }










3535



    case STRIGGER_PULL_WAL_META_NEW: {




20,562,156✔





3536



      SSTriggerWalMetaNewRequest* pRequest = &(pReq->walMetaNewReq);




20,562,156✔





3537



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));




41,123,456✔





3538



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ctime));




41,124,020✔





3539



      break;




20,561,891✔





3540



    }










3541



    case STRIGGER_PULL_WAL_DATA_NEW:




15,259,518✔





3542



    case STRIGGER_PULL_WAL_CALC_DATA_NEW: {










3543



      SSTriggerWalDataNewRequest* pRequest = &(pReq->walDataNewReq);




15,259,518✔





3544



      int32_t                     nVersion = 0;




15,259,518✔





3545



      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nVersion));




15,258,716✔





3546



      pRequest->versions = taosArrayInit_s(sizeof(int64_t), nVersion);




15,258,716✔





3547



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




24,388,783✔





3548



        int64_t* pVer = TARRAY_GET_ELEM(pRequest->versions, i);




9,131,105✔





3549



        TAOS_CHECK_EXIT(tDecodeI64(&decoder, pVer));




9,131,105✔





3550



      }










3551



      int32_t nRanges = 0;




15,257,678✔





3552



      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nRanges));




15,259,518✔





3553



      pRequest->ranges = tSimpleHashInit(nRanges, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT));




15,259,518✔





3554



      if (pRequest->ranges == NULL) {




15,257,112✔





3555



        TAOS_CHECK_EXIT(terrno);




×







3556



      }










3557



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




20,533,498✔





3558



        uint64_t gid = 0;




5,276,386✔





3559



        int64_t pRange[2] = {0};




5,276,386✔





3560



        TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));




5,277,990✔





3561



        TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[0]));




5,277,188✔





3562



        TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRange[1]));




5,274,782✔





3563



        TAOS_CHECK_EXIT(tSimpleHashPut(pRequest->ranges, &gid, sizeof(gid), pRange, sizeof(pRange)));




5,274,782✔





3564



      }










3565



      break;




15,257,112✔





3566



    }










3567



    case STRIGGER_PULL_WAL_META_DATA_NEW: {




5,903,111✔





3568



      SSTriggerWalMetaDataNewRequest* pRequest = &(pReq->walMetaDataNewReq);




5,903,111✔





3569



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->lastVer));




11,808,134✔





3570



      break;




5,904,188✔





3571



    }










3572



    case STRIGGER_PULL_GROUP_COL_VALUE: {




333,183✔





3573



      SSTriggerGroupColValueRequest* pRequest = &(pReq->groupColValueReq);




333,183✔





3574



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->gid));




666,366✔





3575



      break;




333,183✔





3576



    }










3577



    case STRIGGER_PULL_VTABLE_INFO: {




81,511✔





3578



      SSTriggerVirTableInfoRequest* pRequest = &(pReq->virTableInfoReq);




81,511✔





3579



      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));




81,511✔





3580



      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->uids, sizeof(int64_t)));




81,511✔





3581



      TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pRequest->fetchAllTable));




81,511✔





3582



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




163,022✔





3583



      break;




81,511✔





3584



    }










3585



    case STRIGGER_PULL_VTABLE_PSEUDO_COL: {




1,091,280✔





3586



      SSTriggerVirTablePseudoColRequest* pRequest = &(pReq->virTablePseudoColReq);




1,091,280✔





3587



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->uid));




2,182,560✔





3588



      TAOS_CHECK_EXIT(decodePlainArray(&decoder, &pRequest->cids, sizeof(col_id_t)));




1,091,280✔





3589



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




2,182,560✔





3590



      break;




1,091,280✔





3591



    }










3592



    case STRIGGER_PULL_OTABLE_INFO: {




142,409✔





3593



      SSTriggerOrigTableInfoRequest* pRequest = &(pReq->origTableInfoReq);




142,409✔





3594



      int32_t size = 0;




142,409✔





3595



      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));




142,409✔





3596



      pRequest->cols = taosArrayInit(size, sizeof(OTableInfo));




142,409✔





3597



      if (pRequest->cols == NULL) {




142,409✔





3598



        code = terrno;




×







3599



        uError("failed to allocate memory for cids, size: %d, errno: %d", size, code);




×







3600



        goto _exit;




×







3601



      }










3602



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




522,515✔





3603



        OTableInfo* oInfo = taosArrayReserve(pRequest->cols, 1);




380,106✔





3604



        if (oInfo == NULL) {




380,106✔





3605



          code = terrno;




×







3606



          uError("failed to reserve memory for OTableInfo, size: %d, errno: %d", size, code);




×







3607



          goto _exit;




×







3608



        }










3609



        TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refTableName));




380,106✔





3610



        TAOS_CHECK_RETURN(tDecodeCStrTo(&decoder, oInfo->refColName));




380,106✔





3611



      }










3612



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRequest->ver));




284,818✔





3613












3614



      break;




142,409✔





3615



    }










3616



    default: {




1,833✔





3617



      uError("unknown pull type %d", type);




1,833✔





3618



      code = TSDB_CODE_INVALID_PARA;




×







3619



      break;




×







3620



    }










3621



  }










3622












3623



  tEndDecode(&decoder);




52,630,631✔





3624












3625



_exit:




52,625,607✔





3626



  tDecoderClear(&decoder);




52,627,980✔





3627



  return code;




52,622,952✔





3628



}










3629












3630



static int32_t tSerializeSTriggerCalcParam(SEncoder* pEncoder, SArray* pParams, bool ignoreNotificationInfo, bool full) {




35,198,211✔





3631



  int32_t size = full ? taosArrayGetSize(pParams) : 0;




35,198,211✔





3632



  int32_t code = 0;




35,198,590✔





3633



  int32_t lino = 0;




35,198,590✔





3634



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));




35,200,111✔





3635



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




2,147,483,647✔





3636



    SSTriggerCalcParam* param = taosArrayGet(pParams, i);




2,147,483,647✔





3637



    if (param == NULL) {




2,147,483,647✔





3638



      TAOS_CHECK_EXIT(terrno);




×







3639



    }










3640



    int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);




2,147,483,647✔





3641



    if (pEncoder->data) {




2,147,483,647✔





3642



      TAOS_MEMCPY(pEncoder->data + pEncoder->pos, param, plainFieldSize);




2,147,483,647✔





3643



    }










3644



    pEncoder->pos += plainFieldSize;




2,147,483,647✔





3645












3646



    if (!ignoreNotificationInfo) {




2,147,483,647✔





3647



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, param->notifyType));




1,072,229,800✔





3648



      uint64_t len = (param->extraNotifyContent != NULL) ? strlen(param->extraNotifyContent) + 1 : 0;




536,114,769✔





3649



      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, (uint8_t*)param->extraNotifyContent, len));




1,073,308,134✔





3650



    }










3651



  }










3652



_exit:




8,368,957✔





3653



  return code;




8,368,957✔





3654



}










3655












3656



void tDestroySSTriggerCalcParam(void* ptr) {




2,147,483,647✔





3657



  SSTriggerCalcParam* pParam = ptr;




2,147,483,647✔





3658



  if (pParam && pParam->extraNotifyContent != NULL) {




2,147,483,647✔





3659



    taosMemoryFreeClear(pParam->extraNotifyContent);




297,409✔





3660



  }










3661



  if (pParam && pParam->resultNotifyContent != NULL) {




2,147,483,647✔





3662



    taosMemoryFreeClear(pParam->resultNotifyContent);




×







3663



  }










3664



  if (pParam && pParam->pExternalWindowData != NULL) {




2,147,483,647✔





3665



    taosArrayDestroyEx(pParam->pExternalWindowData, tDestroySStreamGroupValue);




59,416,370✔





3666



    pParam->pExternalWindowData = NULL;




59,378,011✔





3667



  }










3668



}




2,147,483,647✔





3669












3670



void tDestroySSTriggerGroupCalcInfo(void* ptr) {




160,763✔





3671



  SSTriggerGroupCalcInfo* pCalcInfo = ptr;




160,763✔





3672



  if (pCalcInfo && pCalcInfo->pParams != NULL) {




160,763✔





3673



    taosArrayDestroyEx(pCalcInfo->pParams, tDestroySSTriggerCalcParam);




160,763✔





3674



    pCalcInfo->pParams = NULL;




160,763✔





3675



  }










3676



  if (pCalcInfo && pCalcInfo->pGroupColVals != NULL) {




160,763✔





3677



    taosArrayDestroyEx(pCalcInfo->pGroupColVals, tDestroySStreamGroupValue);




×







3678



    pCalcInfo->pGroupColVals = NULL;




×







3679



  }










3680



}




160,763✔





3681












3682



void tDestroySSTriggerGroupReadInfo(void* ptr) {




×







3683



  SSTriggerGroupReadInfo* pReadInfo = ptr;




×







3684



  if (pReadInfo && pReadInfo->pTables) {




×







3685



    taosArrayDestroy(pReadInfo->pTables);




×







3686



    pReadInfo->pTables = NULL;




×







3687



  }










3688



}




×







3689












3690



void tDestroySSTriggerGroupReadInfoArray(void* ptr) {




×







3691



  if (ptr != NULL && *(SArray**)ptr != NULL) {




×







3692



    SArray* pArray = *(SArray**)ptr;




×







3693



    taosArrayDestroyEx(pArray, tDestroySSTriggerGroupReadInfo);




×







3694



    *(SArray**)ptr = NULL;




×







3695



  }










3696



}




×







3697












3698



void tDestroySStreamGroupValue(void* ptr) {




79,932,437✔





3699



  SStreamGroupValue* pValue = ptr;




79,932,437✔





3700



  if ((pValue != NULL) && (IS_VAR_DATA_TYPE(pValue->data.type) || pValue->data.type == TSDB_DATA_TYPE_DECIMAL)) {




79,932,437✔





3701



    taosMemoryFreeClear(pValue->data.pData);




14,942,633✔





3702



    pValue->data.nData = 0;




15,627,056✔





3703



  }










3704



}




79,741,898✔





3705












3706



static int32_t tDeserializeSTriggerCalcParam(SDecoder* pDecoder, SArray**ppParams, bool ignoreNotificationInfo) {




17,605,431✔





3707



  int32_t size = 0, code = 0, lino = 0;




17,605,431✔





3708



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));




17,606,290✔





3709



  if (size <= 0) {




17,606,290✔





3710



    return code;




5,096,515✔





3711



  }










3712



  










3713



  *ppParams = taosArrayInit(size, sizeof(SSTriggerCalcParam));




12,509,775✔





3714



  if (*ppParams == NULL) {




12,509,522✔





3715



    TAOS_CHECK_EXIT(terrno);




×







3716



  }










3717



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




2,147,483,647✔





3718



    SSTriggerCalcParam* param = taosArrayReserve(*ppParams, 1);




2,147,483,647✔





3719



    if (param == NULL) {




2,147,483,647✔





3720



      TAOS_CHECK_EXIT(terrno);




×







3721



    }










3722



    int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);




2,147,483,647✔





3723



    TAOS_MEMCPY(param, pDecoder->data + pDecoder->pos, plainFieldSize);




2,147,483,647✔





3724



    pDecoder->pos += plainFieldSize;




2,147,483,647✔





3725












3726



    if (!ignoreNotificationInfo) {




2,147,483,647✔





3727



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &param->notifyType));




535,954,621✔





3728



      uint64_t len = 0;




267,977,437✔





3729



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&param->extraNotifyContent, &len));




535,954,874✔





3730



    }










3731



  }










3732












3733



_exit:




20,565,685✔





3734



  return code;




12,509,522✔





3735



}










3736












3737



static int32_t tSerializeStriggerGroupColVals(SEncoder* pEncoder, SArray* pGroupColVals, int32_t vgId) {




35,865,963✔





3738



  int32_t code = TSDB_CODE_SUCCESS;




35,865,963✔





3739



  int32_t lino = 0;




35,865,963✔





3740












3741



  int32_t size = taosArrayGetSize(pGroupColVals);




35,865,963✔





3742



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, size));




35,866,691✔





3743



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




76,685,574✔





3744



    SStreamGroupValue* pValue = taosArrayGet(pGroupColVals, i);




40,820,772✔





3745



    if (pValue == NULL) {




40,820,373✔





3746



      TAOS_CHECK_EXIT(terrno);




×







3747



    }










3748



    TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isNull));




40,820,373✔





3749



    if (pValue->isNull) {




40,820,188✔





3750



      continue;




18,180✔





3751



    }










3752



    TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pValue->isTbname));




40,801,744✔





3753



    if (pValue->isTbname) {




40,802,389✔





3754



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->uid));




36,909,728✔





3755



      if (vgId != -1) { pValue->vgId = vgId; }




18,454,978✔





3756



      TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pValue->vgId));




36,908,412✔





3757



    }










3758



    TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pValue->data.type));




81,602,814✔





3759



    if (IS_VAR_DATA_TYPE(pValue->data.type)) {




40,801,741✔





3760



      TAOS_CHECK_EXIT(tEncodeBinary(pEncoder, pValue->data.pData, pValue->data.nData));




58,496,633✔





3761



    } else {










3762



      TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pValue->data.val));




23,106,659✔





3763



    }










3764



  }










3765












3766



_exit:




35,864,802✔





3767



  return code;




35,864,802✔





3768



}










3769












3770



static int32_t tDeserializeStriggerGroupColVals(SDecoder* pDecoder, SArray** ppGroupColVals) {




17,939,235✔





3771



  int32_t code = TSDB_CODE_SUCCESS;




17,939,235✔





3772



  int32_t lino = 0;




17,939,235✔





3773



  int32_t size = 0;




17,939,235✔





3774












3775



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &size));




17,939,431✔





3776



  taosArrayClearEx(*ppGroupColVals, tDestroySStreamGroupValue);




17,939,431✔





3777



  if (size > 0) {




17,938,982✔





3778



    if (*ppGroupColVals == NULL) {




10,480,083✔





3779



      *ppGroupColVals = taosArrayInit(size, sizeof(SStreamGroupValue));




10,479,976✔





3780



      if (*ppGroupColVals == NULL) {




10,480,083✔





3781



        TAOS_CHECK_EXIT(terrno);




×







3782



      }










3783



    } else {










3784



      TAOS_CHECK_EXIT(taosArrayEnsureCap(*ppGroupColVals, size));




107✔





3785



    }










3786



  }










3787



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




38,349,950✔





3788



    SStreamGroupValue* pValue = taosArrayReserve(*ppGroupColVals, 1);




20,410,715✔





3789



    if (pValue == NULL) {




20,410,970✔





3790



      TAOS_CHECK_EXIT(terrno);




×







3791



    }










3792



    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isNull));




20,410,970✔





3793



    if (pValue->isNull) {




20,410,970✔





3794



      continue;




9,090✔





3795



    }










3796



    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pValue->isTbname));




20,401,880✔





3797



    if (pValue->isTbname) {




20,401,880✔





3798



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->uid));




18,455,250✔





3799



      TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pValue->vgId));




18,455,250✔





3800



    }










3801



    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pValue->data.type));




40,803,653✔





3802



    if (IS_VAR_DATA_TYPE(pValue->data.type)) {




35,026,183✔





3803



      uint64_t len = 0;




14,624,558✔





3804



      TAOS_CHECK_EXIT(tDecodeBinaryAlloc(pDecoder, (void**)&pValue->data.pData, &len));




29,248,932✔





3805



      pValue->data.nData = len;




14,624,267✔





3806



    } else {










3807



      TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pValue->data.val));




11,554,430✔





3808



    }










3809



  }










3810



_exit:




17,939,235✔





3811



  return code;




17,939,235✔





3812



}










3813












3814



int32_t tSerializeSStreamGroupInfo(void* buf, int32_t bufLen, const SStreamGroupInfo* gInfo, int32_t vgId) {




666,115✔





3815



  SEncoder encoder = {0};




666,115✔





3816



  int32_t  code = TSDB_CODE_SUCCESS;




666,366✔





3817



  int32_t  lino = 0;




666,366✔





3818



  int32_t  tlen = 0;




666,366✔





3819












3820



  tEncoderInit(&encoder, buf, bufLen);




666,366✔





3821



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




666,366✔





3822












3823



  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, gInfo->gInfo, vgId));




666,366✔





3824












3825



  tEndEncode(&encoder);




665,853✔





3826












3827



_exit:




666,104✔





3828



  if (code != TSDB_CODE_SUCCESS) {




666,104✔





3829



    tlen = code;




×







3830



  } else {










3831



    tlen = encoder.pos;




666,104✔





3832



  }










3833



  tEncoderClear(&encoder);




666,104✔





3834



  return tlen;




666,104✔





3835



}










3836












3837



int32_t tDeserializeSStreamGroupInfo(void* buf, int32_t bufLen, SStreamGroupInfo* gInfo) {




333,405✔





3838



  SDecoder decoder = {0};




333,405✔





3839



  int32_t  code = TSDB_CODE_SUCCESS;




333,405✔





3840



  int32_t  lino = 0;




333,405✔





3841



  int32_t  size = 0;




333,405✔





3842












3843



  tDecoderInit(&decoder, buf, bufLen);




333,405✔





3844



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




333,405✔





3845












3846



  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &gInfo->gInfo));




333,405✔





3847












3848



  tEndDecode(&decoder);




333,405✔





3849












3850



_exit:




333,405✔





3851



  tDecoderClear(&decoder);




333,405✔





3852



  return code;




333,405✔





3853



}










3854












3855



static int32_t tSerializeSSTriggerGroupCalcInfo(SEncoder* pEncoder, SSTriggerGroupCalcInfo* pInfo) {




24,136✔





3856



  int32_t code = 0;




24,136✔





3857



  int32_t lino = 0;




24,136✔





3858












3859



  TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(pEncoder, pInfo->pParams, false, true));




24,136✔





3860



  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(pEncoder, pInfo->pGroupColVals, -1));




24,136✔





3861



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->createTable));




48,272✔





3862












3863



_exit:




24,136✔





3864



  return code;




24,136✔





3865



}










3866












3867



static int32_t tSerializeSSTriggerGroupReadInfo(SEncoder* pEncoder, SSTriggerGroupReadInfo* pInfo) {




×







3868



  int32_t code = 0;




×







3869



  int32_t lino = 0;




×







3870












3871



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->gid));




×







3872



  int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);




×







3873



  if (pEncoder->data) {




×







3874



    TAOS_MEMCPY(pEncoder->data + pEncoder->pos, &pInfo->firstParam, plainFieldSize);




×







3875



  }










3876



  pEncoder->pos += plainFieldSize;




×







3877



  if (pEncoder->data) {




×







3878



    TAOS_MEMCPY(pEncoder->data + pEncoder->pos, &pInfo->lastParam, plainFieldSize);




×







3879



  }










3880



  pEncoder->pos += plainFieldSize;




×







3881












3882



  int32_t nTables = taosArrayGetSize(pInfo->pTables);




×







3883



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nTables));




×







3884



  if (pEncoder->data && nTables > 0) {




×







3885



    TAOS_MEMCPY(pEncoder->data + pEncoder->pos, pInfo->pTables->pData, nTables * sizeof(int64_t));




×







3886



  }










3887



  pEncoder->pos += nTables * sizeof(int64_t);




×







3888












3889



_exit:




×







3890



  return code;




×







3891



}










3892












3893



int32_t tSerializeSTriggerCalcRequest(void* buf, int32_t bufLen, const SSTriggerCalcRequest* pReq) {




6,672,092✔





3894



  SEncoder encoder = {0};




6,672,092✔





3895



  int32_t  code = TSDB_CODE_SUCCESS;




6,672,092✔





3896



  int32_t  lino = 0;




6,672,092✔





3897



  int32_t  tlen = 0;




6,672,092✔





3898












3899



  tEncoderInit(&encoder, buf, bufLen);




6,672,092✔





3900



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




6,672,092✔





3901












3902



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));




13,343,678✔





3903



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->runnerTaskId));




13,343,678✔





3904



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));




13,343,931✔





3905



  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->triggerType));




13,343,678✔





3906



  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->isMultiGroupCalc));




13,343,163✔





3907



  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->stbPartByTbname));




13,343,669✔





3908












3909



  if (!pReq->isMultiGroupCalc) {




6,672,092✔





3910



    TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->gid));




13,343,931✔





3911



    TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(&encoder, pReq->params, false, true));




6,671,839✔





3912



    TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, pReq->groupColVals, -1));




6,671,586✔





3913



    TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->createTable));




13,342,919✔





3914



  } else {










3915



    int32_t nGroups = tSimpleHashGetSize(pReq->pGroupCalcInfos);




×







3916



    TAOS_CHECK_EXIT(tEncodeI32(&encoder, nGroups));




×







3917



    int32_t                 iter1 = 0;




×







3918



    SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashIterate(pReq->pGroupCalcInfos, NULL, &iter1);




×







3919



    while (pCalcInfo != NULL) {




×







3920



      int64_t* gid = tSimpleHashGetKey(pCalcInfo, NULL);




×







3921



      TAOS_CHECK_EXIT(tEncodeI64(&encoder, *gid));




×







3922



      TAOS_CHECK_EXIT(tSerializeSSTriggerGroupCalcInfo(&encoder, pCalcInfo));




×







3923



      pCalcInfo = tSimpleHashIterate(pReq->pGroupCalcInfos, pCalcInfo, &iter1);




×







3924



    }










3925












3926



    int32_t nVnodes = tSimpleHashGetSize(pReq->pGroupReadInfos);




×







3927



    TAOS_CHECK_EXIT(tEncodeI32(&encoder, nVnodes));




×







3928



    int32_t iter2 = 0;




×







3929



    void*   px = tSimpleHashIterate(pReq->pGroupReadInfos, NULL, &iter2);




×







3930



    while (px != NULL) {




×







3931



      int32_t* vgId = tSimpleHashGetKey(px, NULL);




×







3932



      TAOS_CHECK_EXIT(tEncodeI32(&encoder, *vgId));




×







3933



      SArray* pInfos = *(SArray**)px;




×







3934



      int32_t nGroups = taosArrayGetSize(pInfos);




×







3935



      TAOS_CHECK_EXIT(tEncodeI32(&encoder, nGroups));




×







3936



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




×







3937



        SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfos, i);




×







3938



        TAOS_CHECK_EXIT(tSerializeSSTriggerGroupReadInfo(&encoder, pReadInfo));




×







3939



      }










3940



      px = tSimpleHashIterate(pReq->pGroupReadInfos, px, &iter2);




×







3941



    }










3942



  }










3943












3944



  TAOS_CHECK_EXIT(tEncodeBool(&encoder, pReq->isWindowTrigger));




6,671,839✔





3945



  TAOS_CHECK_EXIT(tEncodeI8(&encoder, pReq->precision));




13,343,172✔





3946












3947



  tEndEncode(&encoder);




6,671,839✔





3948












3949



_exit:




6,672,092✔





3950



  if (code != TSDB_CODE_SUCCESS) {




6,672,092✔





3951



    tlen = code;




×







3952



  } else {










3953



    tlen = encoder.pos;




6,672,092✔





3954



  }










3955



  tEncoderClear(&encoder);




6,672,092✔





3956



  return tlen;




6,671,586✔





3957



}










3958












3959



static int32_t tDeserializeSSTriggerGroupCalcInfo(SDecoder* pDecoder, SSTriggerGroupCalcInfo* pInfo) {




12,068✔





3960



  int32_t code = 0;




12,068✔





3961



  int32_t lino = 0;




12,068✔





3962












3963



  TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(pDecoder, &pInfo->pParams, false));




12,068✔





3964



  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(pDecoder, &pInfo->pGroupColVals));




12,068✔





3965



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->createTable));




24,136✔





3966












3967



_exit:




12,068✔





3968



  return code;




12,068✔





3969



}










3970












3971



static int32_t tDeserializeSSTriggerGroupReadInfo(SDecoder* pDecoder, SSTriggerGroupReadInfo* pInfo) {




×







3972



  int32_t code = 0;




×







3973



  int32_t lino = 0;




×







3974












3975



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->gid));




×







3976



  int64_t plainFieldSize = offsetof(SSTriggerCalcParam, notifyType);




×







3977



  TAOS_MEMCPY(&pInfo->firstParam, pDecoder->data + pDecoder->pos, plainFieldSize);




×







3978



  pDecoder->pos += plainFieldSize;




×







3979



  TAOS_MEMCPY(&pInfo->lastParam, pDecoder->data + pDecoder->pos, plainFieldSize);




×







3980



  pDecoder->pos += plainFieldSize;




×







3981












3982



  int32_t nTables = 0;




×







3983



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nTables));




×







3984



  if (nTables > 0) {




×







3985



    pInfo->pTables = taosArrayInit_s(sizeof(int64_t), nTables);




×







3986



    QUERY_CHECK_NULL(pInfo->pTables, code, lino, _exit, terrno);




×







3987



    TAOS_MEMCPY(pInfo->pTables->pData, pDecoder->data + pDecoder->pos, nTables * sizeof(int64_t));




×







3988



  }










3989



  pDecoder->pos += nTables * sizeof(int64_t);




×







3990












3991



_exit:




×







3992



  return code;




×







3993



}










3994












3995



int32_t tDeserializeSTriggerCalcRequest(void* buf, int32_t bufLen, SSTriggerCalcRequest* pReq) {




3,334,951✔





3996



  SDecoder decoder = {0};




3,334,951✔





3997



  int32_t  code = TSDB_CODE_SUCCESS;




3,334,951✔





3998



  int32_t  lino = 0;




3,334,951✔





3999












4000



  tDecoderInit(&decoder, buf, bufLen);




3,334,951✔





4001



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




3,334,951✔





4002












4003



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));




6,669,649✔





4004



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->runnerTaskId));




6,669,649✔





4005



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));




6,669,902✔





4006



  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pReq->triggerType));




6,669,902✔





4007



  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->isMultiGroupCalc));




6,669,902✔





4008



  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->stbPartByTbname));




6,669,902✔





4009












4010



  if (!pReq->isMultiGroupCalc) {




3,334,951✔





4011



    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->gid));




6,669,902✔





4012



    TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(&decoder, &pReq->params, false));




3,334,951✔





4013



    TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &pReq->groupColVals));




3,334,951✔





4014



    TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->createTable));




6,669,649✔





4015



  } else {










4016



    pReq->pGroupCalcInfos = tSimpleHashInit(256, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));




×







4017



    QUERY_CHECK_NULL(pReq->pGroupCalcInfos, code, lino, _exit, terrno);




×







4018



    tSimpleHashSetFreeFp(pReq->pGroupCalcInfos, tDestroySSTriggerGroupCalcInfo);




×







4019



    int32_t nGroups = 0;




×







4020



    TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nGroups));




×







4021



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




×







4022



      int64_t gid = 0;




×







4023



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &gid));




×







4024



      SSTriggerGroupCalcInfo info = {0};




×







4025



      TAOS_CHECK_EXIT(tSimpleHashPut(pReq->pGroupCalcInfos, &gid, sizeof(int64_t), &info, sizeof(info)));




×







4026



      SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashGet(pReq->pGroupCalcInfos, &gid, sizeof(int64_t));




×







4027



      QUERY_CHECK_NULL(pCalcInfo, code, lino, _exit, TSDB_CODE_INTERNAL_ERROR);




×







4028



      TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupCalcInfo(&decoder, pCalcInfo));




×







4029



    }










4030












4031



    int32_t nVnodes = 0;




×







4032



    TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nVnodes));




×







4033



    pReq->pGroupReadInfos = tSimpleHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT));




×







4034



    QUERY_CHECK_NULL(pReq->pGroupReadInfos, code, lino, _exit, terrno);




×







4035



    tSimpleHashSetFreeFp(pReq->pGroupReadInfos, tDestroySSTriggerGroupReadInfoArray);




×







4036



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




×







4037



      int32_t vgId = 0;




×







4038



      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &vgId));




×







4039



      int32_t nGroups = 0;




×







4040



      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nGroups));




×







4041



      SArray* pInfos = taosArrayInit_s(sizeof(SSTriggerGroupReadInfo), nGroups);




×







4042



      QUERY_CHECK_NULL(pInfos, code, lino, _exit, terrno);




×







4043



      code = tSimpleHashPut(pReq->pGroupReadInfos, &vgId, sizeof(int32_t), &pInfos, POINTER_BYTES);




×







4044



      if (code != TSDB_CODE_SUCCESS) {




×







4045



        taosArrayDestroy(pInfos);




×







4046



        TAOS_CHECK_EXIT(code);




×







4047



      }










4048



      for (int32_t j = 0; j < nGroups; ++j) {




×







4049



        SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfos, j);




×







4050



        TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupReadInfo(&decoder, pReadInfo));




×







4051



      }










4052



    }










4053



  }










4054












4055



  if (!tDecodeIsEnd(&decoder)) {




3,334,951✔





4056



    TAOS_CHECK_EXIT(tDecodeBool(&decoder, &pReq->isWindowTrigger));




3,334,951✔





4057



    TAOS_CHECK_EXIT(tDecodeI8(&decoder, &pReq->precision));




6,669,902✔





4058



  }










4059












4060



  tEndDecode(&decoder);




3,334,951✔





4061












4062



_exit:




3,334,698✔





4063



  tDecoderClear(&decoder);




3,334,698✔





4064



  return code;




3,334,445✔





4065



}










4066












4067



void tDestroySTriggerCalcRequest(SSTriggerCalcRequest* pReq) {




8,272,709✔





4068



  if (pReq != NULL) {




8,272,709✔





4069



    if (pReq->params != NULL) {




8,272,709✔





4070



      taosArrayDestroyEx(pReq->params, tDestroySSTriggerCalcParam);




4,800,984✔





4071



      pReq->params = NULL;




4,800,731✔





4072



    }










4073



    if (pReq->groupColVals != NULL) {




8,272,456✔





4074



      taosArrayDestroyEx(pReq->groupColVals, tDestroySStreamGroupValue);




1,952,847✔





4075



      pReq->groupColVals = NULL;




1,952,847✔





4076



    }










4077



    if (pReq->pGroupCalcInfos != NULL) {




8,272,456✔





4078



      tSimpleHashCleanup(pReq->pGroupCalcInfos);




×







4079



      pReq->pGroupCalcInfos = NULL;




×







4080



    }










4081



    if (pReq->pGroupReadInfos != NULL) {




8,272,709✔





4082



      tSimpleHashCleanup(pReq->pGroupReadInfos);




×







4083



      pReq->pGroupReadInfos = NULL;




×







4084



    }










4085



    blockDataDestroy(pReq->pOutBlock);




8,272,709✔





4086



    pReq->pOutBlock = NULL;




8,272,709✔





4087



  }










4088



}




8,272,709✔





4089












4090



int32_t tSerializeSTriggerDropTableRequest(void* buf, int32_t bufLen, const SSTriggerDropRequest* pReq) {




×







4091



  SEncoder encoder = {0};




×







4092



  int32_t  code = TSDB_CODE_SUCCESS;




×







4093



  int32_t  lino = 0;




×







4094



  int32_t  tlen = 0;




×







4095












4096



  tEncoderInit(&encoder, buf, bufLen);




×







4097



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




×







4098












4099



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));




×







4100



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->runnerTaskId));




×







4101



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));




×







4102



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->gid));




×







4103












4104



  TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(&encoder, pReq->groupColVals, -1));




×







4105












4106



  tEndEncode(&encoder);




×







4107












4108



_exit:




×







4109



  if (code != TSDB_CODE_SUCCESS) {




×







4110



    tlen = code;




×







4111



  } else {










4112



    tlen = encoder.pos;




×







4113



  }










4114



  tEncoderClear(&encoder);




×







4115



  return tlen;




×







4116



}










4117












4118



int32_t tDeserializeSTriggerDropTableRequest(void* buf, int32_t bufLen, SSTriggerDropRequest* pReq) {




×







4119



  SDecoder decoder = {0};




×







4120



  int32_t  code = TSDB_CODE_SUCCESS;




×







4121



  int32_t  lino = 0;




×







4122












4123



  tDecoderInit(&decoder, buf, bufLen);




×







4124



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




×







4125












4126



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));




×







4127



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->runnerTaskId));




×







4128



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));




×







4129



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->gid));




×







4130












4131



  TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(&decoder, &pReq->groupColVals));




×







4132












4133



  tEndDecode(&decoder);




×







4134












4135



_exit:




×







4136



  tDecoderClear(&decoder);




×







4137



  return code;




×







4138



}










4139












4140



void tDestroySSTriggerDropRequest(SSTriggerDropRequest* pReq) {




×







4141



  if (pReq != NULL) {




×







4142



    if (pReq->groupColVals != NULL) {




×







4143



      taosArrayDestroyEx(pReq->groupColVals, tDestroySStreamGroupValue);




×







4144



      pReq->groupColVals = NULL;




×







4145



    }










4146



  }










4147



}




×







4148












4149



int32_t tSerializeSTriggerCtrlRequest(void* buf, int32_t bufLen, const SSTriggerCtrlRequest* pReq) {




64,096,134✔





4150



  SEncoder encoder = {0};




64,096,134✔





4151



  int32_t  code = TSDB_CODE_SUCCESS;




64,096,134✔





4152



  int32_t  lino = 0;




64,096,134✔





4153



  int32_t  tlen = 0;




64,096,134✔





4154












4155



  tEncoderInit(&encoder, buf, bufLen);




64,096,134✔





4156



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




64,096,134✔





4157












4158



  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pReq->type));




128,192,268✔





4159



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->streamId));




128,192,268✔





4160



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->taskId));




128,192,268✔





4161



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pReq->sessionId));




128,192,268✔





4162












4163



  tEndEncode(&encoder);




64,096,134✔





4164












4165



_exit:




64,096,134✔





4166



  if (code != TSDB_CODE_SUCCESS) {




64,096,134✔





4167



    tlen = code;




×







4168



  } else {










4169



    tlen = encoder.pos;




64,096,134✔





4170



  }










4171



  tEncoderClear(&encoder);




64,096,134✔





4172



  return tlen;




64,096,134✔





4173



}










4174












4175



int32_t tDeserializeSTriggerCtrlRequest(void* buf, int32_t bufLen, SSTriggerCtrlRequest* pReq) {




96,114,811✔





4176



  SDecoder decoder = {0};




96,114,811✔





4177



  int32_t  code = TSDB_CODE_SUCCESS;




96,117,737✔





4178



  int32_t  lino = 0;




96,117,737✔





4179












4180



  tDecoderInit(&decoder, buf, bufLen);




96,117,737✔





4181



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




96,110,009✔





4182












4183



  int32_t type = 0;




96,127,853✔





4184



  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &type));




96,121,191✔





4185



  pReq->type = type;




96,121,191✔





4186



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->streamId));




192,220,978✔





4187



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->taskId));




192,255,348✔





4188



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pReq->sessionId));




192,251,320✔





4189












4190



  tEndDecode(&decoder);




96,124,050✔





4191












4192



_exit:




96,118,122✔





4193



  tDecoderClear(&decoder);




96,119,116✔





4194



  return code;




96,115,798✔





4195



}










4196












4197



int32_t tSerializeStRtFuncInfo(SEncoder* pEncoder, const SStreamRuntimeFuncInfo* pInfo, bool needStreamRtInfo, bool needStreamGrpInfo) {




28,516,223✔





4198



  int32_t code = 0, lino = 0;




28,516,223✔





4199



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->isMultiGroupCalc));




57,033,201✔





4200



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->stbPartByTbname));




57,032,813✔





4201



  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, needStreamRtInfo));




28,515,835✔





4202



  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, needStreamGrpInfo));




28,517,175✔





4203



  if (pInfo->isMultiGroupCalc) {




28,517,862✔





4204



    if (needStreamRtInfo) {




13,792✔





4205



      if (needStreamGrpInfo) {




13,792✔





4206



        int32_t nGroups = taosArrayGetSize(pInfo->curGrpRead);




13,792✔





4207



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nGroups));




13,792✔





4208



        int8_t withGrpCalcInfo = 1;




13,792✔





4209



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




13,792✔





4210



          SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfo->curGrpRead, i);




×







4211



          TAOS_CHECK_EXIT(tSerializeSSTriggerGroupReadInfo(pEncoder, pReadInfo));




×







4212



          if (0 == i) {




×







4213



            withGrpCalcInfo = (taosArrayGetSize(pReadInfo->pTables) <= 0);




×







4214



          }










4215



        }










4216



        










4217



        TAOS_CHECK_EXIT(tEncodeI8(pEncoder, withGrpCalcInfo));




27,584✔





4218



        if (withGrpCalcInfo) {




13,792✔





4219



          int32_t nGroups = tSimpleHashGetSize(pInfo->pGroupCalcInfos);




13,792✔





4220



          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nGroups));




13,792✔





4221



          int32_t                 iter1 = 0;




13,792✔





4222



          SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashIterate(pInfo->pGroupCalcInfos, NULL, &iter1);




13,792✔





4223



          while (pCalcInfo != NULL) {




37,928✔





4224



            int64_t* gid = tSimpleHashGetKey(pCalcInfo, NULL);




24,136✔





4225



            TAOS_CHECK_EXIT(tEncodeI64(pEncoder, *gid));




48,272✔





4226



            TAOS_CHECK_EXIT(tSerializeSSTriggerGroupCalcInfo(pEncoder, pCalcInfo));




24,136✔





4227



            pCalcInfo = tSimpleHashIterate(pInfo->pGroupCalcInfos, pCalcInfo, &iter1);




24,136✔





4228



          }










4229



        }










4230



      } else {










4231



        int32_t nGroups = tSimpleHashGetSize(pInfo->pGroupCalcInfos);




×







4232



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nGroups));




×







4233



        int32_t                 iter1 = 0;




×







4234



        SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashIterate(pInfo->pGroupCalcInfos, NULL, &iter1);




×







4235



        while (pCalcInfo != NULL) {




×







4236



          int64_t* gid = tSimpleHashGetKey(pCalcInfo, NULL);




×







4237



          TAOS_CHECK_EXIT(tEncodeI64(pEncoder, *gid));




×







4238



          TAOS_CHECK_EXIT(tSerializeSSTriggerGroupCalcInfo(pEncoder, pCalcInfo));




×







4239



          pCalcInfo = tSimpleHashIterate(pInfo->pGroupCalcInfos, pCalcInfo, &iter1);




×







4240



        }










4241












4242



        int32_t nVnodes = tSimpleHashGetSize(pInfo->pGroupReadInfos);




×







4243



        TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nVnodes));




×







4244



        int32_t iter2 = 0;




×







4245



        void*   px = tSimpleHashIterate(pInfo->pGroupReadInfos, NULL, &iter2);




×







4246



        while (px != NULL) {




×







4247



          int32_t* vgId = tSimpleHashGetKey(px, NULL);




×







4248



          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, *vgId));




×







4249



          SArray* pInfos = *(SArray**)px;




×







4250



          int32_t nGroups = taosArrayGetSize(pInfos);




×







4251



          TAOS_CHECK_EXIT(tEncodeI32(pEncoder, nGroups));




×







4252



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




×







4253



            SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfos, i);




×







4254



            TAOS_CHECK_EXIT(tSerializeSSTriggerGroupReadInfo(pEncoder, pReadInfo));




×







4255



          }










4256



          px = tSimpleHashIterate(pInfo->pGroupReadInfos, px, &iter2);




×







4257



        }










4258



      }










4259



    }










4260



  } else {










4261



    TAOS_CHECK_EXIT(tSerializeSTriggerCalcParam(pEncoder, pInfo->pStreamPesudoFuncVals, true, needStreamRtInfo));




28,503,779✔





4262



    TAOS_CHECK_EXIT(tSerializeStriggerGroupColVals(pEncoder, pInfo->pStreamPartColVals, -1));




28,503,895✔





4263



    TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->groupId));




57,005,996✔





4264



  }










4265



  










4266



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.skey));




57,032,511✔





4267



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->curWindow.ekey));




57,034,549✔





4268



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->curIdx));




57,034,572✔





4269



  TAOS_CHECK_EXIT(tEncodeI64(pEncoder, pInfo->sessionId));




57,034,486✔





4270



  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->withExternalWindow));




28,517,750✔





4271



  TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->triggerType));




57,035,868✔





4272



  TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->isWindowTrigger));




28,517,893✔





4273



  TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->precision));




57,033,745✔





4274



_exit:




28,517,048✔





4275



  return code;




28,517,255✔





4276



}










4277












4278



int32_t tDeserializeStRtFuncInfo(SDecoder* pDecoder, SStreamRuntimeFuncInfo* pInfo) {




14,265,757✔





4279



  int32_t code = 0, lino = 0;




14,265,757✔





4280



  int32_t size = 0;




14,265,757✔





4281



  bool needStreamRtInfo = false;




14,265,757✔





4282



  bool needStreamGrpInfo = false;




14,265,864✔





4283



  










4284



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->isMultiGroupCalc));




28,531,229✔





4285



  TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->stbPartByTbname));




28,531,532✔





4286



  TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &needStreamRtInfo));




14,266,167✔





4287



  TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &needStreamGrpInfo));




14,265,365✔





4288



  










4289



  if (pInfo->isMultiGroupCalc) {




14,266,167✔





4290



    if (needStreamRtInfo) {




6,896✔





4291



      if (needStreamGrpInfo) {




6,896✔





4292



        int32_t nGroups = 0;




6,896✔





4293



        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nGroups));




6,896✔





4294



        if (nGroups > 0) {




6,896✔





4295



          pInfo->curGrpRead = taosArrayInit_s(sizeof(SSTriggerGroupReadInfo), nGroups);




×







4296



          QUERY_CHECK_NULL(pInfo->curGrpRead, code, lino, _exit, terrno);




×







4297



        }










4298



        for (int32_t j = 0; j < nGroups; ++j) {




6,896✔





4299



          SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfo->curGrpRead, j);




×







4300



          TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupReadInfo(pDecoder, pReadInfo));




×







4301



        }










4302



        int8_t withGrpCalcInfo = 0;




6,896✔





4303



        TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &withGrpCalcInfo));




6,896✔





4304



        if (withGrpCalcInfo) {




6,896✔





4305



          int32_t nGroups = 0;




6,896✔





4306



          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nGroups));




6,896✔





4307



          pInfo->pGroupCalcInfos = tSimpleHashInit(nGroups, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));




6,896✔





4308



          QUERY_CHECK_NULL(pInfo->pGroupCalcInfos, code, lino, _exit, terrno);




6,896✔





4309



          tSimpleHashSetFreeFp(pInfo->pGroupCalcInfos, tDestroySSTriggerGroupCalcInfo);




6,896✔





4310












4311



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




18,964✔





4312



            int64_t gid = 0;




12,068✔





4313



            TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &gid));




12,068✔





4314



            SSTriggerGroupCalcInfo info = {0};




12,068✔





4315



            TAOS_CHECK_EXIT(tSimpleHashPut(pInfo->pGroupCalcInfos, &gid, sizeof(int64_t), &info, sizeof(info)));




12,068✔





4316



            SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashGet(pInfo->pGroupCalcInfos, &gid, sizeof(int64_t));




12,068✔





4317



            QUERY_CHECK_NULL(pCalcInfo, code, lino, _exit, TSDB_CODE_INTERNAL_ERROR);




12,068✔





4318



            TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupCalcInfo(pDecoder, pCalcInfo));




12,068✔





4319



          }










4320



        }










4321



      } else {










4322



        int32_t nGroups = 0;




×







4323



        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nGroups));




×







4324



        pInfo->pGroupCalcInfos = tSimpleHashInit(nGroups, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT));




×







4325



        QUERY_CHECK_NULL(pInfo->pGroupCalcInfos, code, lino, _exit, terrno);




×







4326



        tSimpleHashSetFreeFp(pInfo->pGroupCalcInfos, tDestroySSTriggerGroupCalcInfo);




×







4327












4328



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




×







4329



          int64_t gid = 0;




×







4330



          TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &gid));




×







4331



          SSTriggerGroupCalcInfo info = {0};




×







4332



          TAOS_CHECK_EXIT(tSimpleHashPut(pInfo->pGroupCalcInfos, &gid, sizeof(int64_t), &info, sizeof(info)));




×







4333



          SSTriggerGroupCalcInfo* pCalcInfo = tSimpleHashGet(pInfo->pGroupCalcInfos, &gid, sizeof(int64_t));




×







4334



          QUERY_CHECK_NULL(pCalcInfo, code, lino, _exit, TSDB_CODE_INTERNAL_ERROR);




×







4335



          TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupCalcInfo(pDecoder, pCalcInfo));




×







4336



        }










4337












4338



        int32_t nVnodes = 0;




×







4339



        TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nVnodes));




×







4340



        pInfo->pGroupReadInfos = tSimpleHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT));




×







4341



        QUERY_CHECK_NULL(pInfo->pGroupReadInfos, code, lino, _exit, terrno);




×







4342



        tSimpleHashSetFreeFp(pInfo->pGroupReadInfos, tDestroySSTriggerGroupReadInfoArray);




×







4343



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




×







4344



          int32_t vgId = 0;




×







4345



          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &vgId));




×







4346



          int32_t nGroups = 0;




×







4347



          TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &nGroups));




×







4348



          SArray* pInfos = taosArrayInit_s(sizeof(SSTriggerGroupReadInfo), nGroups);




×







4349



          QUERY_CHECK_NULL(pInfos, code, lino, _exit, terrno);




×







4350



          code = tSimpleHashPut(pInfo->pGroupReadInfos, &vgId, sizeof(int32_t), &pInfos, POINTER_BYTES);




×







4351



          if (code != TSDB_CODE_SUCCESS) {




×







4352



            taosArrayDestroy(pInfos);




×







4353



            TAOS_CHECK_EXIT(code);




×







4354



          }










4355



          for (int32_t j = 0; j < nGroups; ++j) {




×







4356



            SSTriggerGroupReadInfo* pReadInfo = TARRAY_GET_ELEM(pInfos, j);




×







4357



            TAOS_CHECK_EXIT(tDeserializeSSTriggerGroupReadInfo(pDecoder, pReadInfo));




×







4358



          }










4359



        }










4360



      }










4361



    }










4362



  } else {










4363



    TAOS_CHECK_EXIT(tDeserializeSTriggerCalcParam(pDecoder, &pInfo->pStreamPesudoFuncVals, true));




14,259,271✔





4364



    TAOS_CHECK_EXIT(tDeserializeStriggerGroupColVals(pDecoder, &pInfo->pStreamPartColVals));




14,259,271✔





4365



    TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->groupId));




28,517,829✔





4366



  }










4367



  










4368



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.skey));




28,531,650✔





4369



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->curWindow.ekey));




28,531,472✔





4370



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->curIdx));




28,531,903✔





4371



  TAOS_CHECK_EXIT(tDecodeI64(pDecoder, &pInfo->sessionId));




28,531,903✔





4372



  TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->withExternalWindow));




14,265,736✔





4373



  TAOS_CHECK_EXIT(tDecodeI32(pDecoder, &pInfo->triggerType));




28,531,903✔





4374



  if (!tDecodeIsEnd(pDecoder)) {




14,266,167✔





4375



    TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->isWindowTrigger));




14,266,167✔





4376



    TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->precision));




28,532,334✔





4377



  }










4378



_exit:




14,266,167✔





4379



  return code;




14,266,167✔





4380



}










4381












4382



void tDestroyStRtFuncInfo(SStreamRuntimeFuncInfo* pInfo){




562,023,519✔





4383



  if (pInfo == NULL) return;




562,023,519✔





4384



  if (pInfo->pStreamPesudoFuncVals != NULL) {




25,204,318✔





4385



    taosArrayDestroyEx(pInfo->pStreamPesudoFuncVals, tDestroySSTriggerCalcParam);




8,749,531✔





4386



    pInfo->pStreamPesudoFuncVals = NULL;




8,749,100✔





4387



  }










4388



  if (pInfo->pStreamPartColVals != NULL) {




25,225,234✔





4389



    taosArrayDestroyEx(pInfo->pStreamPartColVals, tDestroySStreamGroupValue);




8,775,393✔





4390



    pInfo->pStreamPartColVals = NULL;




8,775,427✔





4391



  }










4392



  if (pInfo->pGroupCalcInfos != NULL) {




25,225,532✔





4393



    tSimpleHashCleanup(pInfo->pGroupCalcInfos);




81,890✔





4394



    pInfo->pGroupCalcInfos = NULL;




81,890✔





4395



  }










4396



  if (pInfo->pGroupReadInfos != NULL) {




25,225,374✔





4397



    tSimpleHashCleanup(pInfo->pGroupReadInfos);




×







4398



    pInfo->pGroupReadInfos = NULL;




×







4399



  }  










4400



  if (pInfo->outNormalTable != NULL) {




25,224,422✔





4401



    taosMemoryFreeClear(pInfo->outNormalTable);




×







4402



  }










4403



}










4404












4405



int32_t tSerializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, const SStreamMsgVTableInfo* pRsp){




163,022✔





4406



  SEncoder encoder = {0};




163,022✔





4407



  int32_t  code = TSDB_CODE_SUCCESS;




163,022✔





4408



  int32_t  lino = 0;




163,022✔





4409



  int32_t  tlen = 0;




163,022✔





4410












4411



  tEncoderInit(&encoder, buf, bufLen);




163,022✔





4412



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




163,022✔





4413












4414



  int32_t size = taosArrayGetSize(pRsp->infos);




163,022✔





4415



  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));




163,022✔





4416



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




559,002✔





4417



    VTableInfo* info = taosArrayGet(pRsp->infos, i);




395,980✔





4418



    if (info == NULL) {




395,980✔





4419



      TAOS_CHECK_EXIT(terrno);




×







4420



    }










4421



    TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->gId));




791,960✔





4422



    TAOS_CHECK_EXIT(tEncodeI64(&encoder, info->uid));




791,960✔





4423



    TAOS_CHECK_EXIT(tEncodeSColRefWrapper(&encoder, &info->cols));




395,980✔





4424



  }










4425












4426



  tEndEncode(&encoder);




163,022✔





4427












4428



_exit:




163,022✔





4429



  if (code != TSDB_CODE_SUCCESS) {




163,022✔





4430



    tlen = code;




×







4431



  } else {










4432



    tlen = encoder.pos;




163,022✔





4433



  }










4434



  tEncoderClear(&encoder);




163,022✔





4435



  return tlen;




163,022✔





4436



}










4437












4438



int32_t tDeserializeSStreamMsgVTableInfo(void* buf, int32_t bufLen, SStreamMsgVTableInfo *vTableInfo){




81,511✔





4439



  SDecoder decoder = {0};




81,511✔





4440



  int32_t  code = TSDB_CODE_SUCCESS;




81,511✔





4441



  int32_t  lino = 0;




81,511✔





4442



  int32_t  size = 0;




81,511✔





4443












4444



  tDecoderInit(&decoder, buf, bufLen);




81,511✔





4445



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




81,511✔





4446












4447



  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &size));




81,511✔





4448



  vTableInfo->infos = taosArrayInit(size, sizeof(VTableInfo));




81,511✔





4449



  if (vTableInfo->infos == NULL) {




81,511✔





4450



    TAOS_CHECK_EXIT(terrno);




×







4451



  }










4452



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




279,501✔





4453



    VTableInfo* info = taosArrayReserve(vTableInfo->infos, 1);




197,990✔





4454



    if (info == NULL) {




197,990✔





4455



      TAOS_CHECK_EXIT(terrno);




×







4456



    }










4457



    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->gId));




395,980✔





4458



    TAOS_CHECK_EXIT(tDecodeI64(&decoder, &info->uid));




395,980✔





4459



    TAOS_CHECK_EXIT(tDecodeSColRefWrapperEx(&decoder, &info->cols, false));




197,990✔





4460



  }










4461












4462



  tEndDecode(&decoder);




81,511✔





4463












4464



_exit:




81,511✔





4465



  tDecoderClear(&decoder);




81,511✔





4466



  return code;




81,511✔





4467



}










4468












4469












4470



void tDestroyVTableInfo(void *ptr) {




395,980✔





4471



  if (NULL == ptr) {




395,980✔





4472



    return;




×







4473



  }










4474



  VTableInfo* pTable = (VTableInfo*)ptr;




395,980✔





4475



  taosMemoryFree(pTable->cols.pColRef);




395,980✔





4476



}










4477












4478



void tDestroySStreamMsgVTableInfo(SStreamMsgVTableInfo *ptr) {




43,248,627✔





4479



  if (ptr == NULL) return;




43,248,627✔





4480



  taosArrayDestroyEx(ptr->infos, tDestroyVTableInfo);




43,248,627✔





4481



  ptr->infos = NULL;




43,248,126✔





4482



}










4483












4484



int32_t tSerializeSStreamTsResponse(void* buf, int32_t bufLen, const SStreamTsResponse* pRsp) {




1,385,180✔





4485



  SEncoder encoder = {0};




1,385,180✔





4486



  int32_t  code = TSDB_CODE_SUCCESS;




1,385,180✔





4487



  int32_t  lino = 0;




1,385,180✔





4488



  int32_t  tlen = 0;




1,385,180✔





4489












4490



  tEncoderInit(&encoder, buf, bufLen);




1,385,180✔





4491



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




1,385,180✔





4492












4493



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, pRsp->ver));




2,769,574✔





4494



  int32_t size = taosArrayGetSize(pRsp->tsInfo);




1,384,656✔





4495



  TAOS_CHECK_EXIT(tEncodeI32(&encoder, size));




1,384,634✔





4496



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




3,192,961✔





4497



    STsInfo* tsInfo = taosArrayGet(pRsp->tsInfo, i);




1,807,512✔





4498



    TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->gId));




3,616,669✔





4499



    TAOS_CHECK_EXIT(tEncodeI64(&encoder, tsInfo->ts));




3,617,162✔





4500



  }










4501












4502



  tEndEncode(&encoder);




1,385,449✔





4503












4504



_exit:




1,385,180✔





4505



  if (code != TSDB_CODE_SUCCESS) {




1,385,180✔





4506



    tlen = code;




×







4507



  } else {










4508



    tlen = encoder.pos;




1,385,180✔





4509



  }










4510



  tEncoderClear(&encoder);




1,385,180✔





4511



  return tlen;




1,384,918✔





4512



}










4513












4514



int32_t tDeserializeSStreamTsResponse(void* buf, int32_t bufLen, void *pBlock) {




692,821✔





4515



  SDecoder decoder = {0};




692,821✔





4516



  int32_t  code = TSDB_CODE_SUCCESS;




692,821✔





4517



  int32_t  lino = 0;




692,821✔





4518



  SSDataBlock *pResBlock = pBlock;




692,821✔





4519












4520



  tDecoderInit(&decoder, buf, bufLen);




692,821✔





4521



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




692,821✔





4522












4523



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, (int64_t*)&pResBlock->info.id.groupId));




1,385,642✔





4524



  int32_t numOfCols = 2;




692,821✔





4525



  if (pResBlock->pDataBlock == NULL) {




692,821✔





4526



    pResBlock->pDataBlock = taosArrayInit_s(sizeof(SColumnInfoData), numOfCols);




692,821✔





4527



    if (pResBlock->pDataBlock == NULL) {




692,821✔





4528



      TAOS_CHECK_EXIT(terrno);




×







4529



    }










4530



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




2,078,463✔





4531



      SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, i);




1,385,642✔





4532



      if (pColInfoData == NULL) {




1,385,642✔





4533



        TAOS_CHECK_EXIT(terrno);




×







4534



      }










4535



      pColInfoData->info.type = TSDB_DATA_TYPE_BIGINT;




1,385,642✔





4536



      pColInfoData->info.bytes = sizeof(int64_t);




1,385,642✔





4537



    }










4538



  }










4539



  int32_t numOfRows = 0;




692,821✔





4540



  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numOfRows));




692,821✔





4541



  TAOS_CHECK_EXIT(blockDataEnsureCapacity(pResBlock, numOfRows));




692,821✔





4542



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




1,597,532✔





4543



    for (int32_t j = 0; j < numOfCols; ++j) {




2,714,133✔





4544



      SColumnInfoData *pColInfoData = taosArrayGet(pResBlock->pDataBlock, j);




1,809,422✔





4545



      if (pColInfoData == NULL) {




1,809,422✔





4546



        TAOS_CHECK_EXIT(terrno);




×







4547



      }










4548



      int64_t value = 0;




1,809,422✔





4549



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &value));




1,809,422✔





4550



      colDataSetInt64(pColInfoData, i, &value);




1,809,422✔





4551



    }










4552



  }










4553












4554



  pResBlock->info.dataLoad = 1;




692,821✔





4555



  pResBlock->info.rows = numOfRows;




692,821✔





4556












4557



  tEndDecode(&decoder);




692,821✔





4558












4559



_exit:




692,821✔





4560



  tDecoderClear(&decoder);




692,821✔





4561



  return code;




692,821✔





4562



}










4563












4564



static int32_t encodeData(SEncoder* encoder, void* pBlock, SSHashObj* indexHash) {




3,302,107✔





4565



  int32_t code = TSDB_CODE_SUCCESS;




3,302,107✔





4566



  int32_t lino = 0;




3,302,107✔





4567



  int32_t len = 0;




3,302,107✔





4568



  if (encoder->data == NULL){




3,302,107✔





4569



    len = blockGetEncodeSize(pBlock);




1,650,926✔





4570



  } else {










4571



    len = blockEncode(pBlock, (char*)(encoder->data + encoder->pos), encoder->size - encoder->pos, blockDataGetNumOfCols(pBlock));




1,651,443✔





4572



    if (len < 0) {




1,651,442✔





4573



      TAOS_CHECK_EXIT(terrno);




×







4574



    }










4575



  }










4576



  encoder->pos += len;




3,302,884✔





4577












4578



  if (indexHash == NULL) {




3,302,884✔





4579



    goto _exit;




1,585,624✔





4580



  } 










4581



  










4582



  uint32_t pos = encoder->pos;




1,717,260✔





4583



  encoder->pos += sizeof(uint32_t); // reserve space for tables




1,717,260✔





4584



  int32_t tables = 0;




1,716,744✔





4585



  










4586



  void*   pe = NULL;




1,716,744✔





4587



  int32_t iter = 0;




1,716,744✔





4588



  while ((pe = tSimpleHashIterate(indexHash, pe, &iter)) != NULL) {




3,683,131✔





4589



    SStreamWalDataSlice* pInfo = (SStreamWalDataSlice*)pe;




1,967,706✔





4590



    if (pInfo->gId == -1){




1,967,706✔





4591



      continue;




×







4592



    }










4593



    int64_t uid = *(int64_t*)(tSimpleHashGetKey(pe, NULL));




1,967,706✔





4594



    TAOS_CHECK_EXIT(tEncodeI64(encoder, uid));




1,967,443✔





4595



    TAOS_CHECK_EXIT(tEncodeU64(encoder, pInfo->gId));




3,934,354✔





4596



    TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->startRowIdx));




3,933,560✔





4597



    TAOS_CHECK_EXIT(tEncodeI32(encoder, pInfo->numRows));




3,933,036✔





4598



    tables++;




1,966,387✔





4599



  }










4600



  uint32_t tmpPos = encoder->pos;




1,716,202✔





4601



  encoder->pos = pos;




1,716,202✔





4602



  TAOS_CHECK_EXIT(tEncodeI32(encoder, tables));




1,716,219✔





4603



  encoder->pos = tmpPos;




1,716,219✔





4604



_exit:




3,302,621✔





4605



  return code;




3,302,621✔





4606



}










4607



 










4608



static int32_t encodeBlock(SEncoder* encoder, void* block, SSHashObj* indexHash) {




11,851,995✔





4609



  int32_t  code = TSDB_CODE_SUCCESS;




11,851,995✔





4610



  int32_t  lino = 0;




11,851,995✔





4611



  if (block != NULL && ((SSDataBlock*)block)->info.rows > 0) {




11,851,995✔





4612



    TAOS_CHECK_EXIT(tEncodeI8(encoder, 1));




3,302,097✔





4613



    TAOS_CHECK_EXIT(encodeData(encoder, block, indexHash));




3,302,097✔





4614



  } else {










4615



    TAOS_CHECK_EXIT(tEncodeI8(encoder, 0));




8,550,946✔





4616



  }










4617












4618



_exit:




8,550,946✔





4619



  return code;




11,853,830✔





4620



}










4621












4622



int32_t tSerializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* rsp) {




2,962,680✔





4623



  SEncoder encoder = {0};




2,962,680✔





4624



  int32_t  code = TSDB_CODE_SUCCESS;




2,962,933✔





4625



  int32_t  lino = 0;




2,962,933✔





4626



  int32_t  tlen = 0;




2,962,933✔





4627












4628



  tEncoderInit(&encoder, buf, bufLen);




2,962,933✔





4629



  TAOS_CHECK_EXIT(tStartEncode(&encoder));




2,963,195✔





4630












4631



  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->dataBlock, rsp->indexHash));




2,963,457✔





4632



  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->metaBlock, NULL));




2,963,467✔





4633



  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->deleteBlock, NULL));




2,963,720✔





4634



  TAOS_CHECK_EXIT(encodeBlock(&encoder, rsp->tableBlock, NULL));




2,963,720✔





4635












4636



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->ver));




5,925,603✔





4637



  TAOS_CHECK_EXIT(tEncodeI64(&encoder, rsp->verTime));




5,925,596✔





4638



  tEndEncode(&encoder);




2,963,188✔





4639












4640



_exit:




2,962,417✔





4641



  if (code != TSDB_CODE_SUCCESS) {




2,962,417✔





4642



    tlen = code;




×







4643



  } else {










4644



    tlen = encoder.pos;




2,962,417✔





4645



  }










4646



  tEncoderClear(&encoder);




2,962,417✔





4647



  return tlen;




2,962,942✔





4648



}










4649












4650



static int32_t decodeBlock(SDecoder* decoder, void* pBlock) {




4,446,378✔





4651



  int32_t  code = TSDB_CODE_SUCCESS;




4,446,378✔





4652



  int32_t  lino = 0;




4,446,378✔





4653



  










4654



  int8_t hasData = false;




4,446,378✔





4655



  TAOS_CHECK_EXIT(tDecodeI8(decoder, &hasData));




4,446,378✔





4656



  if (hasData) {




4,446,378✔





4657



    TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);




792,964✔





4658



    const char* pEndPos = NULL;




792,964✔





4659



    TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder->data + decoder->pos, &pEndPos));




792,527✔





4660



    decoder->pos = (uint8_t*)pEndPos - decoder->data;




792,964✔





4661



  } else if (pBlock != NULL) {




3,653,414✔





4662



    blockDataEmpty(pBlock);




1,583,750✔





4663



  }










4664












4665



_exit:




4,443,555✔





4666



  return code;




4,446,378✔





4667



}










4668












4669



int32_t tDeserializeSStreamWalDataResponse(void* buf, int32_t bufLen, SSTriggerWalNewRsp* pRsp, SArray* pSlices){




1,482,126✔





4670



  SDecoder     decoder = {0};




1,482,126✔





4671



  int32_t      code = TSDB_CODE_SUCCESS;




1,482,126✔





4672



  int32_t      lino = 0;




1,482,126✔





4673



  SSDataBlock* pBlock = NULL;




1,482,126✔





4674












4675



  tDecoderInit(&decoder, buf, bufLen);




1,482,126✔





4676



  TAOS_CHECK_EXIT(tStartDecode(&decoder));




1,482,126✔





4677












4678



  // decode data block










4679



  int8_t hasData = false;




1,482,126✔





4680



  TAOS_CHECK_EXIT(tDecodeI8(&decoder, &hasData));




1,482,126✔





4681



  pBlock = pRsp->dataBlock;




1,482,126✔





4682



  if (hasData) {




1,482,126✔





4683



    TAOS_CHECK_EXIT(pBlock != NULL ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_PARA);




858,744✔





4684



    const char* pEndPos = NULL;




858,744✔





4685



    TAOS_CHECK_EXIT(blockDecode(pBlock, (char*)decoder.data + decoder.pos, &pEndPos));




858,744✔





4686



    decoder.pos = (uint8_t*)pEndPos - decoder.data;




858,744✔





4687












4688



    int32_t nSlices = 0;




858,744✔





4689



    TAOS_CHECK_EXIT(tDecodeI32(&decoder, &nSlices));




858,744✔





4690



    TAOS_CHECK_EXIT(taosArrayEnsureCap(pSlices, nSlices));




858,744✔





4691



    taosArrayClear(pSlices);




858,744✔





4692



    int64_t  uid = 0;




858,744✔





4693



    uint64_t gid = 0;




858,744✔





4694



    int32_t  startIdx = 0;




858,744✔





4695



    int32_t  numRows = 0;




858,744✔





4696



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




1,842,749✔





4697



      TAOS_CHECK_EXIT(tDecodeI64(&decoder, &uid));




984,005✔





4698



      TAOS_CHECK_EXIT(tDecodeU64(&decoder, &gid));




984,005✔





4699



      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &startIdx));




984,005✔





4700



      TAOS_CHECK_EXIT(tDecodeI32(&decoder, &numRows));




984,005✔





4701



      int32_t endIdx = startIdx + numRows;




984,005✔





4702



      int64_t value[3] = {gid, uid, (int64_t)startIdx << 32 | endIdx};




984,005✔





4703



      void*   px = taosArrayPush(pSlices, value);




984,005✔





4704



      if (px == NULL) {




984,005✔





4705



        code = terrno;




×







4706



        goto _exit;




×







4707



      }










4708



    }










4709



  } else if (pBlock != NULL) {




623,382✔





4710



    blockDataEmpty(pBlock);




6,087✔





4711



    taosArrayClear(pSlices);




6,087✔





4712



  }










4713












4714



  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->metaBlock));




1,481,689✔





4715



  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->deleteBlock));




1,482,126✔





4716



  TAOS_CHECK_EXIT(decodeBlock(&decoder, pRsp->tableBlock));




1,482,126✔





4717



  










4718



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->ver));




2,964,252✔





4719



  TAOS_CHECK_EXIT(tDecodeI64(&decoder, &pRsp->verTime));




2,964,252✔





4720












4721



  tEndDecode(&decoder);




1,482,126✔





4722












4723



_exit:




1,482,126✔





4724



  if (code != TSDB_CODE_SUCCESS) {




1,482,126✔





4725



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




×







4726



  }










4727



  tDecoderClear(&decoder);




1,482,126✔





4728



  return code;




1,482,126✔





4729



}
























    

  • 

    •