taosdata / TDengine / #5034

coverage: 73.058%. Remained the same
#5034

push

travis-ci

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

merge: from main to 3.0 branch[manual-only]

1336 of 1975 new or added lines in 48 files covered. (67.65%)

14149 existing lines in 164 files now uncovered.

275896 of 377640 relevant lines covered (73.06%)

132944440.29 hits per line

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

88.39
/source/libs/nodes/src/nodesUtilFuncs.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 "cmdnodes.h"










17



#include "functionMgt.h"










18



#include "nodes.h"










19



#include "nodesUtil.h"










20



#include "osMemory.h"










21



#include "plannodes.h"










22



#include "querynodes.h"










23



#include "taos.h"










24



#include "taoserror.h"










25



#include "tdatablock.h"










26



#include "thash.h"










27



#include "tmsg.h"










28



#include "tref.h"










29












30



typedef struct SNodeMemChunk {










31



  int32_t               availableSize;










32



  int32_t               usedSize;










33



  char*                 pBuf;










34



  struct SNodeMemChunk* pNext;










35



} SNodeMemChunk;










36












37



struct SNodeAllocator {










38



  int64_t        self;










39



  int64_t        queryId;










40



  int32_t        chunkSize;










41



  int32_t        chunkNum;










42



  SNodeMemChunk* pCurrChunk;










43



  SNodeMemChunk* pChunks;










44



  TdThreadMutex  mutex;










45



};










46












47



static threadlocal SNodeAllocator* g_pNodeAllocator;










48



static int32_t                     g_allocatorReqRefPool = -1;










49












50



char* getJoinTypeString(EJoinType type) {




×







51



  static char* joinType[] = {"", "INNER", "LEFT", "RIGHT", "FULL"};










52



  return joinType[type];




×







53



}










54












55



char* getJoinSTypeString(EJoinSubType type) {




×







56



  static char* joinSType[] = {"", "", "OUTER", "SEMI", "ANTI", "ANY", "ASOF", "WINDOW"};










57



  return joinSType[type];




×







58



}










59












60



char* getFullJoinTypeString(EJoinType type, EJoinSubType stype) {




×







61



  static char* joinFullType[][8] = {










62



      {"INNER", "INNER", "INNER", "INNER", "INNER", "INNER ANY", "INNER", "INNER"},










63



      {"LEFT", "LEFT", "LEFT OUTER", "LEFT SEMI", "LEFT ANTI", "LEFT ANY", "LEFT ASOF", "LEFT WINDOW"},










64



      {"RIGHT", "RIGHT", "RIGHT OUTER", "RIGHT SEMI", "RIGHT ANTI", "RIGHT ANY", "RIGHT ASOF", "RIGHT WINDOW"},










65



      {"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"}};










66



  return joinFullType[type][stype];




×







67



}










68












69



int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) {




7,337,935✔





70



  if (NULL == *ppSrc) {




7,337,935✔





71



    return TSDB_CODE_SUCCESS;




7,245,548✔





72



  }










73



  if (NULL == *ppDst) {




92,387✔





74



    *ppDst = *ppSrc;




81,344✔





75



    *ppSrc = NULL;




81,344✔





76



    return TSDB_CODE_SUCCESS;




81,344✔





77



  }










78



  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) &&




11,043✔





79



      ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {




2,045✔





80



    TSWAP(*ppDst, *ppSrc);




×







81



  }










82



  int32_t code = 0;




11,043✔





83



  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppDst)) {




11,043✔





84



    SLogicConditionNode* pDst = (SLogicConditionNode*)*ppDst;




1,636✔





85



    if (pDst->condType == LOGIC_COND_TYPE_AND) {




1,636✔





86



      if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) &&




×







87



          ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) {




×







88



        code = nodesListStrictAppendList(pDst->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList);




×







89



        ((SLogicConditionNode*)(*ppSrc))->pParameterList = NULL;




×







90



      } else {










91



        code = nodesListStrictAppend(pDst->pParameterList, *ppSrc);




×







92



        *ppSrc = NULL;




×







93



      }










94



      nodesDestroyNode(*ppSrc);




×







95



      *ppSrc = NULL;




×







96












97



      return code;




×







98



    }










99



  }










100












101



  SLogicConditionNode* pLogicCond = NULL;




11,043✔





102



  code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);




11,043✔





103



  if (TSDB_CODE_SUCCESS != code) {




11,043✔





104



    return code;




×







105



  }










106



  pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;




11,043✔





107



  pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;




11,043✔





108



  pLogicCond->condType = LOGIC_COND_TYPE_AND;




11,043✔





109



  pLogicCond->pParameterList = NULL;




11,043✔





110



  code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, *ppSrc);




11,043✔





111



  if (TSDB_CODE_SUCCESS == code) {




11,043✔





112



    *ppSrc = NULL;




11,043✔





113



    code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, *ppDst);




11,043✔





114



  }










115



  if (TSDB_CODE_SUCCESS == code) {




11,043✔





116



    *ppDst = (SNode*)pLogicCond;




11,043✔





117



  }










118



  return code;




11,043✔





119



}










120












121



static int32_t callocNodeChunk(SNodeAllocator* pAllocator, SNodeMemChunk** pOutChunk) {




1,942,567,185✔





122



  SNodeMemChunk* pNewChunk = taosMemoryCalloc(1, sizeof(SNodeMemChunk) + pAllocator->chunkSize);




1,942,567,185✔





123



  if (NULL == pNewChunk) {




1,942,573,026✔





124



    if (pOutChunk) *pOutChunk = NULL;




×







125



    return terrno;




×







126



  }










127



  pNewChunk->pBuf = (char*)(pNewChunk + 1);




1,942,573,026✔





128



  pNewChunk->availableSize = pAllocator->chunkSize;




1,942,573,975✔





129



  pNewChunk->usedSize = 0;




1,942,574,187✔





130



  pNewChunk->pNext = NULL;




1,942,576,256✔





131



  if (NULL != pAllocator->pCurrChunk) {




1,942,575,793✔





132



    pAllocator->pCurrChunk->pNext = pNewChunk;




1,454,198,367✔





133



  }










134



  pAllocator->pCurrChunk = pNewChunk;




1,942,577,457✔





135



  if (NULL == pAllocator->pChunks) {




1,942,578,544✔





136



    pAllocator->pChunks = pNewChunk;




488,432,217✔





137



  }










138



  ++(pAllocator->chunkNum);




1,942,581,156✔





139



  if (pOutChunk) *pOutChunk = pNewChunk;




1,942,574,927✔





140



  return TSDB_CODE_SUCCESS;




1,942,574,927✔





141



}










142












143



static int32_t nodesCallocImpl(int32_t size, void** pOut) {




2,147,483,647✔





144



  if (NULL == g_pNodeAllocator) {




2,147,483,647✔





145



    *pOut = taosMemoryCalloc(1, size);




2,147,483,647✔





146



    if (!*pOut) return terrno;




2,147,483,647✔





147



    return TSDB_CODE_SUCCESS;




2,147,483,647✔





148



  }










149












150



  int32_t alignedSize = size;




2,147,483,647✔





151



#ifdef NO_UNALIGNED_ACCESS










152



  alignedSize = (size + 3) & (~3);










153



#endif










154



  if (g_pNodeAllocator->pCurrChunk->usedSize + alignedSize > g_pNodeAllocator->pCurrChunk->availableSize) {




2,147,483,647✔





155



    int32_t code = callocNodeChunk(g_pNodeAllocator, NULL);




1,454,199,443✔





156



    if (TSDB_CODE_SUCCESS != code) {




1,454,197,807✔





157



      taosMemFreeClear(*pOut);




×







158



      return code;




×







159



    }










160



  }










161



  void* p = g_pNodeAllocator->pCurrChunk->pBuf + g_pNodeAllocator->pCurrChunk->usedSize;




2,147,483,647✔





162



  g_pNodeAllocator->pCurrChunk->usedSize += alignedSize;




2,147,483,647✔





163



  *pOut = p;




2,147,483,647✔





164



  return TSDB_CODE_SUCCESS;




2,147,483,647✔





165



  ;










166



}










167












168



#ifdef NO_UNALIGNED_ACCESS










169



#define NODE_ALLOCATOR_HEAD_LEN 4










170



#else










171



#define NODE_ALLOCATOR_HEAD_LEN 1










172



#endif










173












174



static int32_t nodesCalloc(int32_t num, int32_t size, void** pOut) {




2,147,483,647✔





175



  void*   p = NULL;




2,147,483,647✔





176



  int32_t code = nodesCallocImpl(num * size + NODE_ALLOCATOR_HEAD_LEN, &p);




2,147,483,647✔





177



  if (TSDB_CODE_SUCCESS != code) {




2,147,483,647✔





178



    return code;




×







179



  }










180



  *(char*)p = (NULL != g_pNodeAllocator) ? 1 : 0;




2,147,483,647✔





181



  *pOut = (char*)p + NODE_ALLOCATOR_HEAD_LEN;




2,147,483,647✔





182



  return TSDB_CODE_SUCCESS;




2,147,483,647✔





183



}










184












185



void nodesFree(void* p) {




2,147,483,647✔





186



  char* ptr = (char*)p - NODE_ALLOCATOR_HEAD_LEN;




2,147,483,647✔





187



  if (0 == *ptr) {




2,147,483,647✔





188



    taosMemoryFree(ptr);




2,147,483,647✔





189



  }










190



  return;




2,147,483,647✔





191



}










192












193



static int32_t createNodeAllocator(int32_t chunkSize, SNodeAllocator** pAllocator) {




488,418,813✔





194



  *pAllocator = taosMemoryCalloc(1, sizeof(SNodeAllocator));




488,418,813✔





195



  if (NULL == *pAllocator) {




488,423,923✔





196



    return terrno;




×







197



  }










198



  (*pAllocator)->chunkSize = chunkSize;




488,425,247✔





199



  int32_t code = callocNodeChunk(*pAllocator, NULL);




488,428,999✔





200



  if (TSDB_CODE_SUCCESS != code) {




488,427,547✔





201



    taosMemoryFreeClear(*pAllocator);




×







202



    return code;




×







203



  }










204



  if (0 != taosThreadMutexInit(&(*pAllocator)->mutex, NULL)) {




488,427,547✔





205



    return TAOS_SYSTEM_ERROR(ERRNO);




×







206



  }










207



  return TSDB_CODE_SUCCESS;




488,420,429✔





208



}










209












210



static void destroyNodeAllocator(void* p) {




488,428,091✔





211



  if (NULL == p) {




488,428,091✔





212



    return;




×







213



  }










214












215



  SNodeAllocator* pAllocator = p;




488,428,091✔





216












217



  nodesDebug("QID:0x%" PRIx64 ", destroy allocatorId:0x%" PRIx64 ", chunkNum:%d, chunkTotakSize:%d",




488,428,091✔





218



             pAllocator->queryId, pAllocator->self, pAllocator->chunkNum, pAllocator->chunkNum * pAllocator->chunkSize);










219












220



  SNodeMemChunk* pChunk = pAllocator->pChunks;




488,432,366✔





221



  while (NULL != pChunk) {




2,147,483,647✔





222



    SNodeMemChunk* pTemp = pChunk->pNext;




1,942,662,575✔





223



    taosMemoryFree(pChunk);




1,942,663,451✔





224



    pChunk = pTemp;




1,942,670,863✔





225



  }










226



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




488,444,353✔





227



  taosMemoryFree(pAllocator);




488,431,089✔





228



}










229












230



int32_t nodesInitAllocatorSet() {




1,564,707✔





231



  if (g_allocatorReqRefPool >= 0) {




1,564,707✔





232



    nodesWarn("nodes already initialized");




×







233



    return TSDB_CODE_SUCCESS;




×







234



  }










235












236



  g_allocatorReqRefPool = taosOpenRef(1024, destroyNodeAllocator);




1,564,707✔





237



  if (g_allocatorReqRefPool < 0) {




1,564,707✔





238



    nodesError("init nodes failed");




×







239



    return TSDB_CODE_OUT_OF_MEMORY;




×







240



  }










241












242



  return TSDB_CODE_SUCCESS;




1,564,707✔





243



}










244












245



void nodesDestroyAllocatorSet() {




1,564,752✔





246



  if (g_allocatorReqRefPool >= 0) {




1,564,752✔





247



    SNodeAllocator* pAllocator = taosIterateRef(g_allocatorReqRefPool, 0);




1,564,707✔





248



    int64_t         refId = 0;




1,564,707✔





249



    while (NULL != pAllocator) {




1,604,939✔





250



      refId = pAllocator->self;




40,232✔





251



      int32_t code = taosRemoveRef(g_allocatorReqRefPool, refId);




40,232✔





252



      if (TSDB_CODE_SUCCESS != code) {




40,232✔





253



        nodesError("failed to remove ref at %s:%d, rsetId:%d, refId:%" PRId64, __func__, __LINE__,




×







254



                   g_allocatorReqRefPool, refId);










255



      }










256



      pAllocator = taosIterateRef(g_allocatorReqRefPool, refId);




40,232✔





257



    }










258



    taosCloseRef(g_allocatorReqRefPool);




1,564,707✔





259



  }










260



}




1,564,752✔





261












262



int32_t nodesCreateAllocator(int64_t queryId, int32_t chunkSize, int64_t* pAllocatorId) {




488,418,759✔





263



  SNodeAllocator* pAllocator = NULL;




488,418,759✔





264



  int32_t         code = createNodeAllocator(chunkSize, &pAllocator);




488,421,539✔





265



  if (TSDB_CODE_SUCCESS == code) {




488,425,202✔





266



    pAllocator->self = taosAddRef(g_allocatorReqRefPool, pAllocator);




488,427,180✔





267



    if (pAllocator->self <= 0) {




488,436,971✔





268



      return terrno;




×







269



    }










270



    pAllocator->queryId = queryId;




488,432,225✔





271



    *pAllocatorId = pAllocator->self;




488,433,275✔





272



  }










273



  return code;




488,435,297✔





274



}










275












276



int32_t nodesSimAcquireAllocator(int64_t allocatorId) {




1,201,018,573✔





277



  if (allocatorId <= 0) {




1,201,018,573✔





278



    return TSDB_CODE_SUCCESS;




712,684,168✔





279



  }










280












281



  SNodeAllocator* pAllocator = taosAcquireRef(g_allocatorReqRefPool, allocatorId);




488,334,405✔





282



  if (NULL == pAllocator) {




488,397,259✔





283



    return terrno;




1,437✔





284



  }










285



  return TSDB_CODE_SUCCESS;




488,395,822✔





286



}










287












288



int32_t nodesSimReleaseAllocator(int64_t allocatorId) {




1,201,023,248✔





289



  if (allocatorId <= 0) {




1,201,023,248✔





290



    return TSDB_CODE_SUCCESS;




712,671,983✔





291



  }










292












293



  return taosReleaseRef(g_allocatorReqRefPool, allocatorId);




488,351,265✔





294



}










295












296



int32_t nodesAcquireAllocator(int64_t allocatorId) {




2,147,483,647✔





297



  if (allocatorId <= 0) {




2,147,483,647✔





298



    return TSDB_CODE_SUCCESS;




1,224,972,975✔





299



  }










300












301



  SNodeAllocator* pAllocator = taosAcquireRef(g_allocatorReqRefPool, allocatorId);




1,409,114,045✔





302



  if (NULL == pAllocator) {




1,409,300,642✔





303



    return terrno;




×







304



  }










305



  (void)taosThreadMutexLock(&pAllocator->mutex);




1,409,300,642✔





306



  g_pNodeAllocator = pAllocator;




1,409,281,927✔





307



  return TSDB_CODE_SUCCESS;




1,409,281,927✔





308



}










309












310



int32_t nodesReleaseAllocator(int64_t allocatorId) {




2,147,483,647✔





311



  if (allocatorId <= 0) {




2,147,483,647✔





312



    return TSDB_CODE_SUCCESS;




1,224,994,954✔





313



  }










314












315



  if (NULL == g_pNodeAllocator) {




1,408,986,211✔





316



    nodesError("allocatorId:0x%" PRIx64




×







317



               ", release failed, The nodesReleaseAllocator function needs to be called after the "










318



               "nodesAcquireAllocator function is called!",










319



               allocatorId);










320



    return TSDB_CODE_FAILED;




×







321



  }










322



  SNodeAllocator* pAllocator = g_pNodeAllocator;




1,408,986,211✔





323



  g_pNodeAllocator = NULL;




1,408,986,211✔





324



  (void)taosThreadMutexUnlock(&pAllocator->mutex);




1,408,986,211✔





325



  return taosReleaseRef(g_allocatorReqRefPool, allocatorId);




1,409,195,657✔





326



}










327












328



int64_t nodesMakeAllocatorWeakRef(int64_t allocatorId) {




271,563,419✔





329



  if (allocatorId <= 0) {




271,563,419✔





330



    return 0;




×







331



  }










332












333



  SNodeAllocator* pAllocator = taosAcquireRef(g_allocatorReqRefPool, allocatorId);




271,563,419✔





334



  if (NULL == pAllocator) {




271,593,610✔





335



    nodesError("allocatorId:0x%" PRIx64 ", weak reference failed", allocatorId);




349✔





336



    return -1;




×







337



  }










338



  return pAllocator->self;




271,593,261✔





339



}










340












341



int64_t nodesReleaseAllocatorWeakRef(int64_t allocatorId) { return taosReleaseRef(g_allocatorReqRefPool, allocatorId); }




887,158,363✔





342












343



void nodesDestroyAllocator(int64_t allocatorId) {




1,201,066,067✔





344



  if (allocatorId <= 0) {




1,201,066,067✔





345



    return;




712,726,575✔





346



  }










347












348



  int32_t code = taosRemoveRef(g_allocatorReqRefPool, allocatorId);




488,339,492✔





349



  if (TSDB_CODE_SUCCESS != code) {




488,394,459✔





350



    nodesError("failed to remove ref at %s:%d, rsetId:%d, refId:%" PRId64, __func__, __LINE__, g_allocatorReqRefPool,




×







351



               allocatorId);










352



  }










353



}










354












355



static int32_t makeNode(ENodeType type, int32_t size, SNode** ppNode) {




2,147,483,647✔





356



  SNode*  p = NULL;




2,147,483,647✔





357



  int32_t code = nodesCalloc(1, size, (void**)&p);




2,147,483,647✔





358



  if (TSDB_CODE_SUCCESS == code) {




2,147,483,647✔





359



    setNodeType(p, type);




2,147,483,647✔





360



    *ppNode = p;




2,147,483,647✔





361



  }










362



  return code;




2,147,483,647✔





363



}










364












365



int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut) {




2,147,483,647✔





366



  SNode*  pNode = NULL;




2,147,483,647✔





367



  int32_t code = 0;




2,147,483,647✔





368



  switch (type) {




2,147,483,647✔





369



    case QUERY_NODE_COLUMN:




2,147,483,647✔





370



      code = makeNode(type, sizeof(SColumnNode), &pNode);




2,147,483,647✔





371



      break;




2,147,483,647✔





372



    case QUERY_NODE_VALUE:




2,147,483,647✔





373



      code = makeNode(type, sizeof(SValueNode), &pNode);




2,147,483,647✔





374



      break;




2,147,483,647✔





375



    case QUERY_NODE_OPERATOR:




2,147,483,647✔





376



      code = makeNode(type, sizeof(SOperatorNode), &pNode);




2,147,483,647✔





377



      break;




2,147,483,647✔





378



    case QUERY_NODE_LOGIC_CONDITION:




612,009,053✔





379



      code = makeNode(type, sizeof(SLogicConditionNode), &pNode);




612,009,053✔





380



      break;




612,017,475✔





381



    case QUERY_NODE_FUNCTION:




2,147,483,647✔





382



      code = makeNode(type, sizeof(SFunctionNode), &pNode);




2,147,483,647✔





383



      break;




2,147,483,647✔





384



    case QUERY_NODE_REAL_TABLE:




968,151,036✔





385



      code = makeNode(type, sizeof(SRealTableNode), &pNode);




968,151,036✔





386



      break;




968,177,232✔





387



    case QUERY_NODE_VIRTUAL_TABLE:




7,493,353✔





388



      code = makeNode(type, sizeof(SVirtualTableNode), &pNode);




7,493,353✔





389



      break;




7,493,353✔





390



    case QUERY_NODE_TEMP_TABLE:




63,339,724✔





391



      code = makeNode(type, sizeof(STempTableNode), &pNode);




63,339,724✔





392



      break;




63,340,000✔





393



    case QUERY_NODE_PLACE_HOLDER_TABLE:




181,625✔





394



      code = makeNode(type, sizeof(SPlaceHolderTableNode), &pNode);




181,625✔





395



      break;




181,625✔





396



    case QUERY_NODE_TIME_RANGE:




4,796,530✔





397



      code = makeNode(type, sizeof(STimeRangeNode), &pNode);




4,796,530✔





398



      break;




4,796,680✔





399



    case QUERY_NODE_STREAM:




599,051✔





400



      code = makeNode(type, sizeof(SStreamNode), &pNode);




599,051✔





401



      break;




599,051✔





402



    case QUERY_NODE_STREAM_OUT_TABLE:




528,095✔





403



      code = makeNode(type, sizeof(SStreamOutTableNode), &pNode);




528,095✔





404



      break;




528,095✔





405



    case QUERY_NODE_JOIN_TABLE:




47,756,601✔





406



      code = makeNode(type, sizeof(SJoinTableNode), &pNode);




47,756,601✔





407



      break;




47,758,566✔





408



    case QUERY_NODE_GROUPING_SET:




230,847,832✔





409



      code = makeNode(type, sizeof(SGroupingSetNode), &pNode);




230,847,832✔





410



      break;




230,856,404✔





411



    case QUERY_NODE_ORDER_BY_EXPR:




840,514,266✔





412



      code = makeNode(type, sizeof(SOrderByExprNode), &pNode);




840,514,266✔





413



      break;




840,556,450✔





414



    case QUERY_NODE_LIMIT:




146,231,770✔





415



      code = makeNode(type, sizeof(SLimitNode), &pNode);




146,231,770✔





416



      break;




146,231,186✔





417



    case QUERY_NODE_STATE_WINDOW:




6,052,078✔





418



      code = makeNode(type, sizeof(SStateWindowNode), &pNode);




6,052,078✔





419



      break;




6,052,152✔





420



    case QUERY_NODE_SESSION_WINDOW:




15,365,814✔





421



      code = makeNode(type, sizeof(SSessionWindowNode), &pNode);




15,365,814✔





422



      break;




15,367,278✔





423



    case QUERY_NODE_INTERVAL_WINDOW:




45,870,845✔





424



      code = makeNode(type, sizeof(SIntervalWindowNode), &pNode);




45,870,845✔





425



      break;




45,872,976✔





426



    case QUERY_NODE_SLIDING_WINDOW:




236,521✔





427



      code = makeNode(type, sizeof(SSlidingWindowNode), &pNode);




236,521✔





428



      break;




236,521✔





429



    case QUERY_NODE_PERIOD_WINDOW:




65,358✔





430



      code = makeNode(type, sizeof(SPeriodWindowNode), &pNode);




65,358✔





431



      break;




65,358✔





432



    case QUERY_NODE_STREAM_TRIGGER:




695,244✔





433



      code = makeNode(type, sizeof(SStreamTriggerNode), &pNode);




695,244✔





434



      break;




695,244✔





435



    case QUERY_NODE_STREAM_CALC_RANGE:




12,626✔





436



      code = makeNode(type, sizeof(SStreamCalcRangeNode), &pNode);




12,626✔





437



      break;




12,626✔





438



    case QUERY_NODE_STREAM_TAG_DEF:




311,922✔





439



      code = makeNode(type, sizeof(SStreamTagDefNode), &pNode);




311,922✔





440



      break;




311,922✔





441



    case QUERY_NODE_NODE_LIST:




1,280,469,103✔





442



      code = makeNode(type, sizeof(SNodeListNode), &pNode);




1,280,469,103✔





443



      break;




1,280,649,302✔





444



    case QUERY_NODE_SURROUND:




86,890✔





445



      code = makeNode(type, sizeof(SSurroundNode), &pNode);




86,890✔





446



      break;




86,890✔





447



    case QUERY_NODE_FILL:




4,694,902✔





448



      code = makeNode(type, sizeof(SFillNode), &pNode);




4,694,902✔





449



      break;




4,698,542✔





450



    case QUERY_NODE_RAW_EXPR:




2,147,483,647✔





451



      code = makeNode(type, sizeof(SRawExprNode), &pNode);




2,147,483,647✔





452



      break;




2,147,483,647✔





453



    case QUERY_NODE_TARGET:




2,147,483,647✔





454



      code = makeNode(type, sizeof(STargetNode), &pNode);




2,147,483,647✔





455



      break;




2,147,483,647✔





456



    case QUERY_NODE_DATABLOCK_DESC:




2,147,483,647✔





457



      code = makeNode(type, sizeof(SDataBlockDescNode), &pNode);




2,147,483,647✔





458



      break;




2,147,483,647✔





459



    case QUERY_NODE_SLOT_DESC:




2,147,483,647✔





460



      code = makeNode(type, sizeof(SSlotDescNode), &pNode);




2,147,483,647✔





461



      break;




2,147,483,647✔





462



    case QUERY_NODE_COLUMN_DEF:




457,806,283✔





463



      code = makeNode(type, sizeof(SColumnDefNode), &pNode);




457,806,283✔





464



      break;




457,806,283✔





465



    case QUERY_NODE_DOWNSTREAM_SOURCE:




691,685,084✔





466



      code = makeNode(type, sizeof(SDownstreamSourceNode), &pNode);




691,685,084✔





467



      break;




691,723,594✔





468



    case QUERY_NODE_DATABASE_OPTIONS:




2,034,724✔





469



      code = makeNode(type, sizeof(SDatabaseOptions), &pNode);




2,034,724✔





470



      break;




2,034,724✔





471



    case QUERY_NODE_TABLE_OPTIONS:




54,822,367✔





472



      code = makeNode(type, sizeof(STableOptions), &pNode);




54,822,367✔





473



      break;




54,828,859✔





474



    case QUERY_NODE_COLUMN_OPTIONS:




459,992,294✔





475



      code = makeNode(type, sizeof(SColumnOptions), &pNode);




459,992,294✔





476



      break;




459,992,294✔





477



    case QUERY_NODE_INDEX_OPTIONS:




×







478



      code = makeNode(type, sizeof(SIndexOptions), &pNode);




×







479



      break;




×







480



    case QUERY_NODE_EXPLAIN_OPTIONS:




107,477,783✔





481



      code = makeNode(type, sizeof(SExplainOptions), &pNode);




107,477,783✔





482



      break;




107,480,765✔





483



    case QUERY_NODE_STREAM_TRIGGER_OPTIONS:




252,911✔





484



      code = makeNode(type, sizeof(SStreamTriggerOptions), &pNode);




252,911✔





485



      break;




252,911✔





486



    case QUERY_NODE_LEFT_VALUE:




32,608,100✔





487



      code = makeNode(type, sizeof(SLeftValueNode), &pNode);




32,608,100✔





488



      break;




32,607,540✔





489



    case QUERY_NODE_COLUMN_REF:




220,648,195✔





490



      code = makeNode(type, sizeof(SColumnRefNode), &pNode);




220,648,195✔





491



      break;




220,648,195✔





492



    case QUERY_NODE_WHEN_THEN:




103,787,326✔





493



      code = makeNode(type, sizeof(SWhenThenNode), &pNode);




103,787,326✔





494



      break;




103,793,739✔





495



    case QUERY_NODE_CASE_WHEN:




102,243,092✔





496



      code = makeNode(type, sizeof(SCaseWhenNode), &pNode);




102,243,092✔





497



      break;




102,255,387✔





498



    case QUERY_NODE_EVENT_WINDOW:




5,497,592✔





499



      code = makeNode(type, sizeof(SEventWindowNode), &pNode);




5,497,592✔





500



      break;




5,497,910✔





501



    case QUERY_NODE_COUNT_WINDOW:




5,170,694✔





502



      code = makeNode(type, sizeof(SCountWindowNode), &pNode);




5,170,694✔





503



      break;




5,171,382✔





504



    case QUERY_NODE_COUNT_WINDOW_ARGS:




5,166,384✔





505



      code = makeNode(type, sizeof(SCountWindowArgs), &pNode);




5,166,384✔





506



      break;




5,166,894✔





507



    case QUERY_NODE_ANOMALY_WINDOW:




×







508



      code = makeNode(type, sizeof(SAnomalyWindowNode), &pNode);




×







509



      break;




×







510



    case QUERY_NODE_EXTERNAL_WINDOW:




299,581✔





511



      code = makeNode(type, sizeof(SExternalWindowNode), &pNode);




299,581✔





512



      break;




299,581✔





513



    case QUERY_NODE_HINT:




17,766,718✔





514



      code = makeNode(type, sizeof(SHintNode), &pNode);




17,766,718✔





515



      break;




17,766,718✔





516



    case QUERY_NODE_VIEW:




401,481✔





517



      code = makeNode(type, sizeof(SViewNode), &pNode);




401,481✔





518



      break;




401,481✔





519



    case QUERY_NODE_WINDOW_OFFSET:




2,057,988✔





520



      code = makeNode(type, sizeof(SWindowOffsetNode), &pNode);




2,057,988✔





521



      break;




2,057,988✔





522



    case QUERY_NODE_RANGE_AROUND:




1,637,796✔





523



      code = makeNode(type, sizeof(SRangeAroundNode), &pNode);




1,637,796✔





524



      break;




1,637,796✔





525



    case QUERY_NODE_STREAM_NOTIFY_OPTIONS:




129,851✔





526



      code = makeNode(type, sizeof(SStreamNotifyOptions), &pNode);




129,851✔





527



      break;




129,851✔





528



    case QUERY_NODE_REMOTE_VALUE:




765,646,220✔





529



      code = makeNode(type, sizeof(SRemoteValueNode), &pNode);




765,646,220✔





530



      break;




765,720,457✔





531



    case QUERY_NODE_REMOTE_VALUE_LIST:




144,952,680✔





532



      code = makeNode(type, sizeof(SRemoteValueListNode), &pNode);




144,952,680✔





533



      break;




144,956,102✔





534



    case QUERY_NODE_REMOTE_ROW:




154,333,173✔





535



      code = makeNode(type, sizeof(SRemoteRowNode), &pNode);




154,333,173✔





536



      break;




154,335,174✔





537



    case QUERY_NODE_REMOTE_ZERO_ROWS:




12,423,453✔





538



      code = makeNode(type, sizeof(SRemoteZeroRowsNode), &pNode);




12,423,453✔





539



      break;




12,423,818✔





540



    case QUERY_NODE_REMOTE_TABLE:




1,232,379✔





541



      code = makeNode(type, sizeof(SRemoteTableNode), &pNode);




1,232,379✔





542



      break;




1,232,379✔





543



    case QUERY_NODE_UPDATE_TAG_VALUE:




9,045,551✔





544



      code = makeNode(type, sizeof(SUpdateTagValueNode), &pNode);




9,045,551✔





545



      break;




9,045,551✔





546



    case QUERY_NODE_ALTER_TABLE_UPDATE_TAG_VAL_CLAUSE:




8,925,274✔





547



      code = makeNode(type, sizeof(SAlterTableUpdateTagValClause), &pNode);




8,925,274✔





548



      break;




8,925,274✔





549



    case QUERY_NODE_TRUE_FOR:




55,496✔





550



      code = makeNode(type, sizeof(STrueForNode), &pNode);




55,496✔





551



      break;




55,496✔





552



    case QUERY_NODE_SET_OPERATOR:




46,431,132✔





553



      code = makeNode(type, sizeof(SSetOperator), &pNode);




46,431,132✔





554



      break;




46,432,628✔





555



    case QUERY_NODE_SELECT_STMT:




804,059,918✔





556



      code = makeNode(type, sizeof(SSelectStmt), &pNode);




804,059,918✔





557



      break;




804,084,229✔





558



    case QUERY_NODE_VNODE_MODIFY_STMT:




681,471,179✔





559



      code = makeNode(type, sizeof(SVnodeModifyOpStmt), &pNode);




681,471,179✔





560



      break;




681,525,024✔





561



    case QUERY_NODE_CREATE_DATABASE_STMT:




1,681,292✔





562



      code = makeNode(type, sizeof(SCreateDatabaseStmt), &pNode);




1,681,292✔





563



      break;




1,681,292✔





564



    case QUERY_NODE_DROP_DATABASE_STMT:




1,417,767✔





565



      code = makeNode(type, sizeof(SDropDatabaseStmt), &pNode);




1,417,767✔





566



      break;




1,417,767✔





567



    case QUERY_NODE_ALTER_DATABASE_STMT:




309,088✔





568



      code = makeNode(type, sizeof(SAlterDatabaseStmt), &pNode);




309,088✔





569



      break;




309,088✔





570



    case QUERY_NODE_FLUSH_DATABASE_STMT:




1,973,626✔





571



      code = makeNode(type, sizeof(SFlushDatabaseStmt), &pNode);




1,973,626✔





572



      break;




1,973,626✔





573



    case QUERY_NODE_TRIM_DATABASE_STMT:




14,529✔





574



      code = makeNode(type, sizeof(STrimDatabaseStmt), &pNode);




14,529✔





575



      break;




14,529✔





576



    case QUERY_NODE_SSMIGRATE_DATABASE_STMT:




3,137✔





577



      code = makeNode(type, sizeof(SSsMigrateDatabaseStmt), &pNode);




3,137✔





578



      break;




3,137✔





579



    case QUERY_NODE_CREATE_TABLE_STMT:




9,701,955✔





580



      code = makeNode(type, sizeof(SCreateTableStmt), &pNode);




9,701,955✔





581



      break;




9,701,955✔





582



    case QUERY_NODE_CREATE_SUBTABLE_CLAUSE:




45,080,947✔





583



      code = makeNode(type, sizeof(SCreateSubTableClause), &pNode);




45,080,947✔





584



      break;




45,082,380✔





585



    case QUERY_NODE_CREATE_VIRTUAL_TABLE_STMT:




232,699✔





586



      code = makeNode(type, sizeof(SCreateVTableStmt), &pNode);




232,699✔





587



      break;




232,699✔





588



    case QUERY_NODE_CREATE_VIRTUAL_SUBTABLE_STMT:




422,101✔





589



      code = makeNode(type, sizeof(SCreateVSubTableStmt), &pNode);




422,101✔





590



      break;




422,101✔





591



    case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE:




1,452✔





592



      code = makeNode(type, sizeof(SCreateSubTableFromFileClause), &pNode);




1,452✔





593



      break;




1,452✔





594



    case QUERY_NODE_CREATE_MULTI_TABLES_STMT:




37,732,883✔





595



      code = makeNode(type, sizeof(SCreateMultiTablesStmt), &pNode);




37,732,883✔





596



      break;




37,743,633✔





597



    case QUERY_NODE_DROP_TABLE_CLAUSE:




2,842,029✔





598



      code = makeNode(type, sizeof(SDropTableClause), &pNode);




2,842,029✔





599



      break;




2,842,029✔





600



    case QUERY_NODE_DROP_TABLE_STMT:




2,723,476✔





601



      code = makeNode(type, sizeof(SDropTableStmt), &pNode);




2,723,476✔





602



      break;




2,723,476✔





603



    case QUERY_NODE_DROP_SUPER_TABLE_STMT:




102,615✔





604



      code = makeNode(type, sizeof(SDropSuperTableStmt), &pNode);




102,615✔





605



      break;




102,615✔





606



    case QUERY_NODE_DROP_VIRTUAL_TABLE_STMT:




78,360✔





607



      code = makeNode(type, sizeof(SDropVirtualTableStmt), &pNode);




78,360✔





608



      break;




78,360✔





609



    case QUERY_NODE_ALTER_TABLE_STMT:




24,009,274✔





610



    case QUERY_NODE_ALTER_SUPER_TABLE_STMT:










611



    case QUERY_NODE_ALTER_VIRTUAL_TABLE_STMT:










612



      code = makeNode(type, sizeof(SAlterTableStmt), &pNode);




24,009,274✔





613



      break;




24,009,274✔





614



    case QUERY_NODE_CREATE_MOUNT_STMT:




1,749✔





615



      code = makeNode(type, sizeof(SCreateMountStmt), &pNode);




1,749✔





616



      break;




1,749✔





617



    case QUERY_NODE_DROP_MOUNT_STMT:




580✔





618



      code = makeNode(type, sizeof(SDropMountStmt), &pNode);




580✔





619



      break;




580✔





620



    case QUERY_NODE_CREATE_RSMA_STMT:




119,582✔





621



      code = makeNode(type, sizeof(SCreateRsmaStmt), &pNode);




119,582✔





622



      break;




119,582✔





623



    case QUERY_NODE_DROP_RSMA_STMT:




10,873✔





624



      code = makeNode(type, sizeof(SDropRsmaStmt), &pNode);




10,873✔





625



      break;




10,873✔





626



    case QUERY_NODE_ALTER_RSMA_STMT:




22,227✔





627



      code = makeNode(type, sizeof(SAlterRsmaStmt), &pNode);




22,227✔





628



      break;




22,227✔





629



    case QUERY_NODE_CREATE_USER_STMT:




118,421✔





630



      code = makeNode(type, sizeof(SCreateUserStmt), &pNode);




118,421✔





631



      break;




118,421✔





632



    case QUERY_NODE_CREATE_ENCRYPT_ALGORITHMS_STMT:




×







633



      code = makeNode(type, sizeof(SCreateEncryptAlgrStmt), &pNode);




×







634



      break;




×







635



    case QUERY_NODE_DROP_ENCRYPT_ALGR_STMT:




×







636



      code = makeNode(type, sizeof(SDropEncryptAlgrStmt), &pNode);




×







637



      break;




×







638



    case QUERY_NODE_ALTER_USER_STMT:




60,061✔





639



      code = makeNode(type, sizeof(SAlterUserStmt), &pNode);




60,061✔





640



      break;




60,061✔





641



    case QUERY_NODE_DROP_USER_STMT:




59,939✔





642



      code = makeNode(type, sizeof(SDropUserStmt), &pNode);




59,939✔





643



      break;




59,939✔





644



    case QUERY_NODE_CREATE_ROLE_STMT:




4,733✔





645



      code = makeNode(type, sizeof(SCreateRoleStmt), &pNode);




4,733✔





646



      break;




4,733✔





647



    case QUERY_NODE_DROP_ROLE_STMT:




1,694✔





648



      code = makeNode(type, sizeof(SDropRoleStmt), &pNode);




1,694✔





649



      break;




1,694✔





650



    case QUERY_NODE_ALTER_ROLE_STMT:




462✔





651



      code = makeNode(type, sizeof(SAlterRoleStmt), &pNode);




462✔





652



      break;




462✔





653



    case QUERY_NODE_USE_DATABASE_STMT:




96,999,533✔





654



      code = makeNode(type, sizeof(SUseDatabaseStmt), &pNode);




96,999,533✔





655



      break;




97,000,256✔





656



    case QUERY_NODE_CREATE_DNODE_STMT:




185,600✔





657



      code = makeNode(type, sizeof(SCreateDnodeStmt), &pNode);




185,600✔





658



      break;




185,600✔





659



    case QUERY_NODE_DROP_DNODE_STMT:




34,461✔





660



      code = makeNode(type, sizeof(SDropDnodeStmt), &pNode);




34,461✔





661



      break;




34,461✔





662



    case QUERY_NODE_ALTER_DNODE_STMT:




135,166✔





663



      code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode);




135,166✔





664



      break;




135,166✔





665



    case QUERY_NODE_CREATE_ANODE_STMT:




×







666



      code = makeNode(type, sizeof(SCreateAnodeStmt), &pNode);




×







667



      break;




×







668



    case QUERY_NODE_DROP_ANODE_STMT:




×







669



      code = makeNode(type, sizeof(SDropAnodeStmt), &pNode);




×







670



      break;




×







671



    case QUERY_NODE_UPDATE_ANODE_STMT:




×







672



      code = makeNode(type, sizeof(SUpdateAnodeStmt), &pNode);




×







673



      break;




×







674



    case QUERY_NODE_CREATE_BNODE_STMT:




26,676✔





675



      code = makeNode(type, sizeof(SCreateBnodeStmt), &pNode);




26,676✔





676



      break;




26,676✔





677



    case QUERY_NODE_DROP_BNODE_STMT:




31,600✔





678



      code = makeNode(type, sizeof(SDropBnodeStmt), &pNode);




31,600✔





679



      break;




31,600✔





680



    case QUERY_NODE_BNODE_OPTIONS:




26,676✔





681



      code = makeNode(type, sizeof(SBnodeOptions), &pNode);




26,676✔





682



      break;




26,676✔





683



    case QUERY_NODE_DATE_TIME_RANGE:




5,406✔





684



      code = makeNode(type, sizeof(SDateTimeRangeNode), &pNode);




5,406✔





685



      break;




5,406✔





686



    case QUERY_NODE_IP_RANGE:




6,381✔





687



      code = makeNode(type, sizeof(SIpRangeNode), &pNode);




6,381✔





688



      break;




6,381✔





689



    case QUERY_NODE_USER_OPTIONS:




205,425✔





690



      code = makeNode(type, sizeof(SUserOptions), &pNode);




205,425✔





691



      break;




205,425✔





692



    case QUERY_NODE_TOKEN_OPTIONS:




29,038✔





693



      code = makeNode(type, sizeof(STokenOptions), &pNode);




29,038✔





694



      break;




29,038✔





695



    case QUERY_NODE_CREATE_INDEX_STMT:




23,074✔





696



      code = makeNode(type, sizeof(SCreateIndexStmt), &pNode);




23,074✔





697



      break;




23,074✔





698



    case QUERY_NODE_DROP_INDEX_STMT:




15,502✔





699



      code = makeNode(type, sizeof(SDropIndexStmt), &pNode);




15,502✔





700



      break;




15,502✔





701



    case QUERY_NODE_CREATE_QNODE_STMT:




123,626✔





702



    case QUERY_NODE_CREATE_BACKUP_NODE_STMT:










703



    case QUERY_NODE_CREATE_SNODE_STMT:










704



    case QUERY_NODE_CREATE_MNODE_STMT:










705



      code = makeNode(type, sizeof(SCreateComponentNodeStmt), &pNode);




123,626✔





706



      break;




123,626✔





707



    case QUERY_NODE_DROP_QNODE_STMT:




60,545✔





708



    case QUERY_NODE_DROP_BACKUP_NODE_STMT:










709



    case QUERY_NODE_DROP_SNODE_STMT:










710



    case QUERY_NODE_DROP_MNODE_STMT:










711



      code = makeNode(type, sizeof(SDropComponentNodeStmt), &pNode);




60,545✔





712



      break;




60,545✔





713



    case QUERY_NODE_CREATE_TOPIC_STMT:




222,068✔





714



      code = makeNode(type, sizeof(SCreateTopicStmt), &pNode);




222,068✔





715



      break;




222,068✔





716



    case QUERY_NODE_DROP_TOPIC_STMT:




129,584✔





717



      code = makeNode(type, sizeof(SDropTopicStmt), &pNode);




129,584✔





718



      break;




129,584✔





719



    case QUERY_NODE_DROP_CGROUP_STMT:




6,001✔





720



      code = makeNode(type, sizeof(SDropCGroupStmt), &pNode);




6,001✔





721



      break;




6,001✔





722



    case QUERY_NODE_ALTER_LOCAL_STMT:




561,726✔





723



      code = makeNode(type, sizeof(SAlterLocalStmt), &pNode);




561,726✔





724



      break;




561,726✔





725



    case QUERY_NODE_EXPLAIN_STMT:




99,017,662✔





726



      code = makeNode(type, sizeof(SExplainStmt), &pNode);




99,017,662✔





727



      break;




99,022,475✔





728



    case QUERY_NODE_DESCRIBE_STMT:




576,062✔





729



      code = makeNode(type, sizeof(SDescribeStmt), &pNode);




576,062✔





730



      break;




576,062✔





731



    case QUERY_NODE_RESET_QUERY_CACHE_STMT:




2,237,443✔





732



      code = makeNode(type, sizeof(SNode), &pNode);




2,237,443✔





733



      break;




2,237,443✔





734



    case QUERY_NODE_COMPACT_DATABASE_STMT:




42,497✔





735



      code = makeNode(type, sizeof(SCompactDatabaseStmt), &pNode);




42,497✔





736



      break;




42,497✔





737



    case QUERY_NODE_ROLLUP_DATABASE_STMT:




10,565✔





738



      code = makeNode(type, sizeof(SRollupDatabaseStmt), &pNode);




10,565✔





739



      break;




10,565✔





740



    case QUERY_NODE_SCAN_DATABASE_STMT:




1,032✔





741



      code = makeNode(type, sizeof(SScanDatabaseStmt), &pNode);




1,032✔





742



      break;




1,032✔





743



    case QUERY_NODE_COMPACT_VGROUPS_STMT:




4,075✔





744



      code = makeNode(type, sizeof(SCompactVgroupsStmt), &pNode);




4,075✔





745



      break;




4,075✔





746



    case QUERY_NODE_ROLLUP_VGROUPS_STMT:




4,734✔





747



      code = makeNode(type, sizeof(SRollupVgroupsStmt), &pNode);




4,734✔





748



      break;




4,734✔





749



    case QUERY_NODE_SCAN_VGROUPS_STMT:




270✔





750



      code = makeNode(type, sizeof(SScanVgroupsStmt), &pNode);




270✔





751



      break;




270✔





752



    case QUERY_NODE_CREATE_FUNCTION_STMT:




20,087✔





753



      code = makeNode(type, sizeof(SCreateFunctionStmt), &pNode);




20,087✔





754



      break;




20,087✔





755



    case QUERY_NODE_DROP_FUNCTION_STMT:




9,115✔





756



      code = makeNode(type, sizeof(SDropFunctionStmt), &pNode);




9,115✔





757



      break;




9,115✔





758



    case QUERY_NODE_CREATE_STREAM_STMT:




685,823✔





759



      code = makeNode(type, sizeof(SCreateStreamStmt), &pNode);




685,823✔





760



      break;




685,823✔





761



    case QUERY_NODE_DROP_STREAM_STMT:




20,983✔





762



      code = makeNode(type, sizeof(SDropStreamStmt), &pNode);




20,983✔





763



      break;




20,983✔





764



    case QUERY_NODE_PAUSE_STREAM_STMT:




3,200✔





765



      code = makeNode(type, sizeof(SPauseStreamStmt), &pNode);




3,200✔





766



      break;




3,200✔





767



    case QUERY_NODE_RESUME_STREAM_STMT:




2,824✔





768



      code = makeNode(type, sizeof(SResumeStreamStmt), &pNode);




2,824✔





769



      break;




2,824✔





770



    case QUERY_NODE_RECALCULATE_STREAM_STMT:




12,626✔





771



      code = makeNode(type, sizeof(SRecalcStreamStmt), &pNode);




12,626✔





772



      break;




12,626✔





773












774



    case QUERY_NODE_BALANCE_VGROUP_STMT:




14,968✔





775



      code = makeNode(type, sizeof(SBalanceVgroupStmt), &pNode);




14,968✔





776



      break;




14,968✔





777



    case QUERY_NODE_ASSIGN_LEADER_STMT:




19✔





778



      code = makeNode(type, sizeof(SAssignLeaderStmt), &pNode);




19✔





779



      break;




19✔





780



    case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT:




6,847✔





781



      code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode);




6,847✔





782



      break;




6,847✔





783



    case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT:




113✔





784



      code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode);




113✔





785



      break;




113✔





786



    case QUERY_NODE_SET_VGROUP_KEEP_VERSION_STMT:




1,198✔





787



      code = makeNode(type, sizeof(SSetVgroupKeepVersionStmt), &pNode);




1,198✔





788



      break;




1,198✔





789



    case QUERY_NODE_TRIM_DATABASE_WAL_STMT:




1,198✔





790



      code = makeNode(type, sizeof(STrimDbWalStmt), &pNode);




1,198✔





791



      break;




1,198✔





792



    case QUERY_NODE_CREATE_TOKEN_STMT:




23,524✔





793



      code = makeNode(type, sizeof(SCreateTokenStmt), &pNode);




23,524✔





794



      break;




23,524✔





795



    case QUERY_NODE_ALTER_TOKEN_STMT:




2,824✔





796



      code = makeNode(type, sizeof(SAlterTokenStmt), &pNode);




2,824✔





797



      break;




2,824✔





798



    case QUERY_NODE_DROP_TOKEN_STMT:




2,664✔





799



      code = makeNode(type, sizeof(SDropTokenStmt), &pNode);




2,664✔





800



      break;




2,664✔





801



    case QUERY_NODE_CREATE_TOTP_SECRET_STMT:




19,117✔





802



      code = makeNode(type, sizeof(SCreateTotpSecretStmt), &pNode);




19,117✔





803



      break;




19,117✔





804



    case QUERY_NODE_DROP_TOTP_SECRET_STMT:




7,350✔





805



      code = makeNode(type, sizeof(SDropTotpSecretStmt), &pNode);




7,350✔





806



      break;




7,350✔





807



    case QUERY_NODE_MERGE_VGROUP_STMT:




×







808



      code = makeNode(type, sizeof(SMergeVgroupStmt), &pNode);




×







809



      break;




×







810



    case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:




48,923✔





811



      code = makeNode(type, sizeof(SRedistributeVgroupStmt), &pNode);




48,923✔





812



      break;




48,923✔





813



    case QUERY_NODE_SPLIT_VGROUP_STMT:




21,008✔





814



      code = makeNode(type, sizeof(SSplitVgroupStmt), &pNode);




21,008✔





815



      break;




21,008✔





816



    case QUERY_NODE_SYNCDB_STMT:




×







817



      break;




×







818



    case QUERY_NODE_GRANT_STMT:




957,759✔





819



      code = makeNode(type, sizeof(SGrantStmt), &pNode);




957,759✔





820



      break;




957,759✔





821



    case QUERY_NODE_REVOKE_STMT:




508,608✔





822



      code = makeNode(type, sizeof(SRevokeStmt), &pNode);




508,608✔





823



      break;




508,608✔





824



    case QUERY_NODE_ALTER_CLUSTER_STMT:




4,454✔





825



      code = makeNode(type, sizeof(SAlterClusterStmt), &pNode);




4,454✔





826



      break;




4,454✔





827



    case QUERY_NODE_SHOW_DNODES_STMT:




3,337,752✔





828



    case QUERY_NODE_SHOW_MNODES_STMT:










829



    case QUERY_NODE_SHOW_MODULES_STMT:










830



    case QUERY_NODE_SHOW_QNODES_STMT:










831



    case QUERY_NODE_SHOW_ANODES_STMT:










832



    case QUERY_NODE_SHOW_ANODES_FULL_STMT:










833



    case QUERY_NODE_SHOW_BNODES_STMT:










834



    case QUERY_NODE_SHOW_XNODES_STMT:










835



    case QUERY_NODE_SHOW_XNODE_TASKS_STMT:










836



    case QUERY_NODE_SHOW_XNODE_AGENTS_STMT:










837



    case QUERY_NODE_SHOW_XNODE_JOBS_STMT:










838



    case QUERY_NODE_SHOW_SNODES_STMT:










839



    case QUERY_NODE_SHOW_BACKUP_NODES_STMT:










840



    case QUERY_NODE_SHOW_ARBGROUPS_STMT:










841



    case QUERY_NODE_SHOW_CLUSTER_STMT:










842



    case QUERY_NODE_SHOW_SECURITY_POLICIES_STMT:










843



    case QUERY_NODE_SHOW_DATABASES_STMT:










844



    case QUERY_NODE_SHOW_FUNCTIONS_STMT:










845



    case QUERY_NODE_SHOW_INDEXES_STMT:










846



    case QUERY_NODE_SHOW_STABLES_STMT:










847



    case QUERY_NODE_SHOW_STREAMS_STMT:










848



    case QUERY_NODE_SHOW_TABLES_STMT:










849



    case QUERY_NODE_SHOW_VTABLES_STMT:










850



    case QUERY_NODE_SHOW_USERS_STMT:










851



    case QUERY_NODE_SHOW_USERS_FULL_STMT:










852



    case QUERY_NODE_SHOW_ROLES_STMT:










853



    case QUERY_NODE_SHOW_LICENCES_STMT:










854



    case QUERY_NODE_SHOW_VGROUPS_STMT:










855



    case QUERY_NODE_SHOW_TOPICS_STMT:










856



    case QUERY_NODE_SHOW_CONSUMERS_STMT:










857



    case QUERY_NODE_SHOW_CONNECTIONS_STMT:










858



    case QUERY_NODE_SHOW_QUERIES_STMT:










859



    case QUERY_NODE_SHOW_VNODES_STMT:










860



    case QUERY_NODE_SHOW_APPS_STMT:










861



    case QUERY_NODE_SHOW_VARIABLES_STMT:










862



    case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:










863



    case QUERY_NODE_SHOW_TRANSACTIONS_STMT:










864



    case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:










865



    case QUERY_NODE_SHOW_TAGS_STMT:










866



    case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT:










867



    case QUERY_NODE_SHOW_ROLE_PRIVILEGES_STMT:










868



    case QUERY_NODE_SHOW_ROLE_COL_PRIVILEGES_STMT:










869



    case QUERY_NODE_SHOW_VIEWS_STMT:










870



    case QUERY_NODE_SHOW_GRANTS_FULL_STMT:










871



    case QUERY_NODE_SHOW_GRANTS_LOGS_STMT:










872



    case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT:










873



    case QUERY_NODE_SHOW_ENCRYPTIONS_STMT:










874



    case QUERY_NODE_SHOW_TSMAS_STMT:










875



    case QUERY_NODE_SHOW_USAGE_STMT:










876



    case QUERY_NODE_SHOW_MOUNTS_STMT:










877



    case QUERY_NODE_SHOW_RSMAS_STMT:










878



    case QUERY_NODE_SHOW_RETENTIONS_STMT:










879



    case QUERY_NODE_SHOW_INSTANCES_STMT:










880



    case QUERY_NODE_SHOW_ENCRYPT_ALGORITHMS_STMT:










881



    case QUERY_NODE_SHOW_ENCRYPT_STATUS_STMT:










882



      code = makeNode(type, sizeof(SShowStmt), &pNode);




3,337,752✔





883



      break;




3,337,752✔





884



    case QUERY_NODE_SHOW_TABLE_TAGS_STMT:




9,929✔





885



      code = makeNode(type, sizeof(SShowTableTagsStmt), &pNode);




9,929✔





886



      break;




9,929✔





887



    case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:




40,589✔





888



      code = makeNode(type, sizeof(SShowDnodeVariablesStmt), &pNode);




40,589✔





889



      break;




40,589✔





890



    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:




76,082✔





891



      code = makeNode(type, sizeof(SShowCreateDatabaseStmt), &pNode);




76,082✔





892



      break;




76,082✔





893



    case QUERY_NODE_SHOW_DB_ALIVE_STMT:




5,137✔





894



    case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT:










895



      code = makeNode(type, sizeof(SShowAliveStmt), &pNode);




5,137✔





896



      break;




5,137✔





897



    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:




107,094✔





898



    case QUERY_NODE_SHOW_CREATE_VTABLE_STMT:










899



    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:










900



      code = makeNode(type, sizeof(SShowCreateTableStmt), &pNode);




107,094✔





901



      break;




107,094✔





902



    case QUERY_NODE_SHOW_CREATE_VIEW_STMT:




8,716✔





903



      code = makeNode(type, sizeof(SShowCreateViewStmt), &pNode);




8,716✔





904



      break;




8,716✔





905



    case QUERY_NODE_SHOW_CREATE_RSMA_STMT:




3,445✔





906



      code = makeNode(type, sizeof(SShowCreateRsmaStmt), &pNode);




3,445✔





907



      break;




3,445✔





908



    case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:




5,147✔





909



      code = makeNode(type, sizeof(SShowTableDistributedStmt), &pNode);




5,147✔





910



      break;




5,147✔





911



    case QUERY_NODE_SHOW_COMPACTS_STMT:




746,396✔





912



      code = makeNode(type, sizeof(SShowCompactsStmt), &pNode);




746,396✔





913



      break;




746,396✔





914



    case QUERY_NODE_SHOW_SCANS_STMT:




2,376✔





915



      code = makeNode(type, sizeof(SShowScansStmt), &pNode);




2,376✔





916



      break;




2,376✔





917



    case QUERY_NODE_SHOW_COMPACT_DETAILS_STMT:




34,423✔





918



      code = makeNode(type, sizeof(SShowCompactDetailsStmt), &pNode);




34,423✔





919



      break;




34,423✔





920



    case QUERY_NODE_SHOW_RETENTION_DETAILS_STMT:




2,367✔





921



      code = makeNode(type, sizeof(SShowRetentionDetailsStmt), &pNode);




2,367✔





922



      break;




2,367✔





923



    case QUERY_NODE_SHOW_SCAN_DETAILS_STMT:




1,836✔





924



      code = makeNode(type, sizeof(SShowScanDetailsStmt), &pNode);




1,836✔





925



      break;




1,836✔





926



    case QUERY_NODE_SHOW_TRANSACTION_DETAILS_STMT:




310✔





927



      code = makeNode(type, sizeof(SShowTransactionDetailsStmt), &pNode);




310✔





928



      break;




310✔





929



    case QUERY_NODE_SHOW_SSMIGRATES_STMT:




92,313✔





930



      code = makeNode(type, sizeof(SShowSsMigratesStmt), &pNode);




92,313✔





931



      break;




92,313✔





932



    case QUERY_NODE_SHOW_TOKENS_STMT:




1,907✔





933



      code = makeNode(type, sizeof(SShowTokensStmt), &pNode);




1,907✔





934



      break;




1,907✔





935



    case QUERY_NODE_KILL_QUERY_STMT:




1,523✔





936



      code = makeNode(type, sizeof(SKillQueryStmt), &pNode);




1,523✔





937



      break;




1,523✔





938



    case QUERY_NODE_KILL_TRANSACTION_STMT:




2,676✔





939



    case QUERY_NODE_KILL_CONNECTION_STMT:










940



    case QUERY_NODE_KILL_COMPACT_STMT:










941



    case QUERY_NODE_KILL_RETENTION_STMT:










942



    case QUERY_NODE_KILL_SCAN_STMT:










943



    case QUERY_NODE_KILL_SSMIGRATE_STMT:










944



      code = makeNode(type, sizeof(SKillStmt), &pNode);




2,676✔





945



      break;




2,676✔





946



    case QUERY_NODE_DELETE_STMT:




1,962,463✔





947



      code = makeNode(type, sizeof(SDeleteStmt), &pNode);




1,962,463✔





948



      break;




1,962,463✔





949



    case QUERY_NODE_INSERT_STMT:




528,960✔





950



      code = makeNode(type, sizeof(SInsertStmt), &pNode);




528,960✔





951



      break;




528,960✔





952



    case QUERY_NODE_QUERY:




1,091,871,401✔





953



      code = makeNode(type, sizeof(SQuery), &pNode);




1,091,871,401✔





954



      break;




1,091,908,197✔





955



    case QUERY_NODE_RESTORE_DNODE_STMT:




2,465✔





956



    case QUERY_NODE_RESTORE_QNODE_STMT:










957



    case QUERY_NODE_RESTORE_MNODE_STMT:










958



    case QUERY_NODE_RESTORE_VNODE_STMT:










959



      code = makeNode(type, sizeof(SRestoreComponentNodeStmt), &pNode);




2,465✔





960



      break;




2,465✔





961



    case QUERY_NODE_CREATE_VIEW_STMT:




227,290✔





962



      code = makeNode(type, sizeof(SCreateViewStmt), &pNode);




227,290✔





963



      break;




227,290✔





964



    case QUERY_NODE_DROP_VIEW_STMT:




170,218✔





965



      code = makeNode(type, sizeof(SDropViewStmt), &pNode);




170,218✔





966



      break;




170,218✔





967



    case QUERY_NODE_CREATE_TSMA_STMT:




8,970✔





968



      code = makeNode(type, sizeof(SCreateTSMAStmt), &pNode);




8,970✔





969



      break;




8,970✔





970



    case QUERY_NODE_DROP_TSMA_STMT:




4,262✔





971



      code = makeNode(type, sizeof(SDropTSMAStmt), &pNode);




4,262✔





972



      break;




4,262✔





973



    case QUERY_NODE_TSMA_OPTIONS:




10,034✔





974



      code = makeNode(type, sizeof(STSMAOptions), &pNode);




10,034✔





975



      break;




10,034✔





976



    case QUERY_NODE_LOGIC_PLAN_SCAN:




1,104,211,112✔





977



      code = makeNode(type, sizeof(SScanLogicNode), &pNode);




1,104,211,112✔





978



      break;




1,104,257,580✔





979



    case QUERY_NODE_LOGIC_PLAN_JOIN:




53,376,167✔





980



      code = makeNode(type, sizeof(SJoinLogicNode), &pNode);




53,376,167✔





981



      break;




53,376,967✔





982



    case QUERY_NODE_LOGIC_PLAN_AGG:




393,908,449✔





983



      code = makeNode(type, sizeof(SAggLogicNode), &pNode);




393,908,449✔





984



      break;




393,931,965✔





985



    case QUERY_NODE_LOGIC_PLAN_PROJECT:




794,505,565✔





986



      code = makeNode(type, sizeof(SProjectLogicNode), &pNode);




794,505,565✔





987



      break;




794,570,763✔





988



    case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY:




1,385,534,180✔





989



      code = makeNode(type, sizeof(SVnodeModifyLogicNode), &pNode);




1,385,534,180✔





990



      break;




1,385,700,423✔





991



    case QUERY_NODE_LOGIC_PLAN_EXCHANGE:




294,272,508✔





992



      code = makeNode(type, sizeof(SExchangeLogicNode), &pNode);




294,272,508✔





993



      break;




294,282,636✔





994



    case QUERY_NODE_LOGIC_PLAN_MERGE:




72,425,850✔





995



      code = makeNode(type, sizeof(SMergeLogicNode), &pNode);




72,425,850✔





996



      break;




72,432,049✔





997



    case QUERY_NODE_LOGIC_PLAN_WINDOW:




88,621,255✔





998



      code = makeNode(type, sizeof(SWindowLogicNode), &pNode);




88,621,255✔





999



      break;




88,631,468✔





1000



    case QUERY_NODE_LOGIC_PLAN_FILL:




1,143,067✔





1001



      code = makeNode(type, sizeof(SFillLogicNode), &pNode);




1,143,067✔





1002



      break;




1,143,067✔





1003



    case QUERY_NODE_LOGIC_PLAN_SORT:




189,197,391✔





1004



      code = makeNode(type, sizeof(SSortLogicNode), &pNode);




189,197,391✔





1005



      break;




189,207,145✔





1006



    case QUERY_NODE_LOGIC_PLAN_PARTITION:




64,650,809✔





1007



      code = makeNode(type, sizeof(SPartitionLogicNode), &pNode);




64,650,809✔





1008



      break;




64,656,483✔





1009



    case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC:




12,009,506✔





1010



      code = makeNode(type, sizeof(SIndefRowsFuncLogicNode), &pNode);




12,009,506✔





1011



      break;




12,009,506✔





1012



    case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC:




7,587,800✔





1013



      code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode);




7,587,800✔





1014



      break;




7,588,688✔






UNCOV

1015



    case QUERY_NODE_LOGIC_PLAN_FORECAST_FUNC:




×







1016



      code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode);




×







1017



      break;




×







1018



    case QUERY_NODE_LOGIC_PLAN_ANALYSIS_FUNC:




×







1019



      code = makeNode(type, sizeof(SGenericAnalysisLogicNode), &pNode);




×







1020



      break;




×







1021



    case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE:




4,097,738✔





1022



      code = makeNode(type, sizeof(SGroupCacheLogicNode), &pNode);




4,097,738✔





1023



      break;




4,097,738✔





1024



    case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL:




17,996,802✔





1025



      code = makeNode(type, sizeof(SDynQueryCtrlLogicNode), &pNode);




17,996,802✔





1026



      break;




17,996,802✔





1027



    case QUERY_NODE_LOGIC_PLAN_VIRTUAL_TABLE_SCAN:




17,104,106✔





1028



      code = makeNode(type, sizeof(SVirtualScanLogicNode), &pNode);




17,104,106✔





1029



      break;




17,104,106✔





1030



    case QUERY_NODE_LOGIC_SUBPLAN:




2,147,483,647✔





1031



      code = makeNode(type, sizeof(SLogicSubplan), &pNode);




2,147,483,647✔





1032



      break;




2,147,483,647✔





1033



    case QUERY_NODE_LOGIC_PLAN:




1,061,124,013✔





1034



      code = makeNode(type, sizeof(SQueryLogicPlan), &pNode);




1,061,124,013✔





1035



      break;




1,061,349,730✔





1036



    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:




30,960,008✔





1037



      code = makeNode(type, sizeof(STagScanPhysiNode), &pNode);




30,960,008✔





1038



      break;




30,962,610✔





1039



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:




762,765,165✔





1040



      code = makeNode(type, sizeof(STableScanPhysiNode), &pNode);




762,765,165✔





1041



      break;




762,850,404✔






UNCOV

1042



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:




×







1043



      code = makeNode(type, sizeof(STableSeqScanPhysiNode), &pNode);




×







1044



      break;




×







1045



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:




81,119,311✔





1046



      code = makeNode(type, sizeof(STableMergeScanPhysiNode), &pNode);




81,119,311✔





1047



      break;




81,125,304✔





1048



    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:




486,741✔





1049



      code = makeNode(type, sizeof(SStreamScanPhysiNode), &pNode);




486,741✔





1050



      break;




486,741✔





1051



    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:




64,038,057✔





1052



      code = makeNode(type, sizeof(SSystemTableScanPhysiNode), &pNode);




64,038,057✔





1053



      break;




64,042,576✔





1054



    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:




13,623✔





1055



      code = makeNode(type, sizeof(SBlockDistScanPhysiNode), &pNode);




13,623✔





1056



      break;




13,623✔





1057



    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:




4,136,268✔





1058



      code = makeNode(type, sizeof(SLastRowScanPhysiNode), &pNode);




4,136,268✔





1059



      break;




4,136,485✔





1060



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN:




83,860✔





1061



      code = makeNode(type, sizeof(STableCountScanPhysiNode), &pNode);




83,860✔





1062



      break;




83,877✔





1063



    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:




463,480,371✔





1064



      code = makeNode(type, sizeof(SProjectPhysiNode), &pNode);




463,480,371✔





1065



      break;




463,494,292✔





1066



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:




36,934,879✔





1067



      code = makeNode(type, sizeof(SSortMergeJoinPhysiNode), &pNode);




36,934,879✔





1068



      break;




36,936,586✔





1069



    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:




3,326,082✔





1070



      code = makeNode(type, sizeof(SHashJoinPhysiNode), &pNode);




3,326,082✔





1071



      break;




3,326,082✔





1072



    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:




351,902,946✔





1073



      code = makeNode(type, sizeof(SAggPhysiNode), &pNode);




351,902,946✔





1074



      break;




351,918,851✔





1075



    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:




344,885,579✔





1076



      code = makeNode(type, sizeof(SExchangePhysiNode), &pNode);




344,885,579✔





1077



      break;




344,903,153✔





1078



    case QUERY_NODE_PHYSICAL_PLAN_MERGE:




50,779,762✔





1079



      code = makeNode(type, sizeof(SMergePhysiNode), &pNode);




50,779,762✔





1080



      break;




50,783,314✔





1081



    case QUERY_NODE_PHYSICAL_PLAN_SORT:




121,754,714✔





1082



      code = makeNode(type, sizeof(SSortPhysiNode), &pNode);




121,754,714✔





1083



      break;




121,769,997✔





1084



    case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT:




244,668✔





1085



      code = makeNode(type, sizeof(SGroupSortPhysiNode), &pNode);




244,668✔





1086



      break;




244,668✔





1087



    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:




29,626,082✔





1088



      code = makeNode(type, sizeof(SIntervalPhysiNode), &pNode);




29,626,082✔





1089



      break;




29,631,424✔






UNCOV

1090



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL:




×







1091



      code = makeNode(type, sizeof(SMergeIntervalPhysiNode), &pNode);




×







1092



      break;




×







1093



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL:




4,512,525✔





1094



      code = makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode), &pNode);




4,512,525✔





1095



      break;




4,512,323✔





1096



    case QUERY_NODE_PHYSICAL_PLAN_FILL:




1,217,543✔





1097



      code = makeNode(type, sizeof(SFillPhysiNode), &pNode);




1,217,543✔





1098



      break;




1,217,543✔





1099



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:




6,167,452✔





1100



      code = makeNode(type, sizeof(SSessionWinodwPhysiNode), &pNode);




6,167,452✔





1101



      break;




6,168,529✔





1102



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:




5,505,578✔





1103



      code = makeNode(type, sizeof(SStateWindowPhysiNode), &pNode);




5,505,578✔





1104



      break;




5,506,267✔





1105



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:




4,447,185✔





1106



      code = makeNode(type, sizeof(SEventWinodwPhysiNode), &pNode);




4,447,185✔





1107



      break;




4,448,030✔





1108



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:




4,039,072✔





1109



      code = makeNode(type, sizeof(SCountWindowPhysiNode), &pNode);




4,039,072✔





1110



      break;




4,040,414✔






UNCOV

1111



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ANOMALY:




×







1112



      code = makeNode(type, sizeof(SAnomalyWindowPhysiNode), &pNode);




×







1113



      break;




×







1114



    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:




23,223,291✔





1115



      code = makeNode(type, sizeof(SPartitionPhysiNode), &pNode);




23,223,291✔





1116



      break;




23,227,724✔





1117



    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:




7,849,514✔





1118



      code = makeNode(type, sizeof(SIndefRowsFuncPhysiNode), &pNode);




7,849,514✔





1119



      break;




7,849,514✔





1120



    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:




7,471,968✔





1121



      code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode);




7,471,968✔





1122



      break;




7,473,388✔






UNCOV

1123



    case QUERY_NODE_PHYSICAL_PLAN_FORECAST_FUNC:




×







1124



      code = makeNode(type, sizeof(SForecastFuncLogicNode), &pNode);




×







1125



      break;




×







1126



    case QUERY_NODE_PHYSICAL_PLAN_ANALYSIS_FUNC:




×







1127



      code = makeNode(type, sizeof(SGenericAnalysisPhysiNode), &pNode);




×







1128



      break;




×







1129



    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:




1,152,420,062✔





1130



      code = makeNode(type, sizeof(SDataDispatcherNode), &pNode);




1,152,420,062✔





1131



      break;




1,152,486,356✔





1132



    case QUERY_NODE_PHYSICAL_PLAN_INSERT:




700,257,951✔





1133



      code = makeNode(type, sizeof(SDataInserterNode), &pNode);




700,257,951✔





1134



      break;




700,347,334✔





1135



    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:




1,010,104✔





1136



      code = makeNode(type, sizeof(SQueryInserterNode), &pNode);




1,010,104✔





1137



      break;




1,010,104✔





1138



    case QUERY_NODE_PHYSICAL_PLAN_DELETE:




3,777,135✔





1139



      code = makeNode(type, sizeof(SDataDeleterNode), &pNode);




3,777,135✔





1140



      break;




3,777,734✔





1141



    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:




3,324,446✔





1142



      code = makeNode(type, sizeof(SGroupCachePhysiNode), &pNode);




3,324,446✔





1143



      break;




3,324,446✔





1144



    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:




10,543,417✔





1145



      code = makeNode(type, sizeof(SDynQueryCtrlPhysiNode), &pNode);




10,543,417✔





1146



      break;




10,543,417✔





1147



    case QUERY_NODE_PHYSICAL_SUBPLAN:




1,857,965,920✔





1148



      code = makeNode(type, sizeof(SSubplan), &pNode);




1,857,965,920✔





1149



      break;




1,858,217,564✔





1150



    case QUERY_NODE_PHYSICAL_PLAN:




1,062,248,383✔





1151



      code = makeNode(type, sizeof(SQueryPlan), &pNode);




1,062,248,383✔





1152



      break;




1,062,331,772✔





1153



    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN:




8,928,010✔





1154



      code = makeNode(type, sizeof(SVirtualScanPhysiNode), &pNode);




8,928,010✔





1155



      break;




8,928,010✔





1156



    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:




3,733,622✔





1157



    case QUERY_NODE_PHYSICAL_PLAN_HASH_EXTERNAL:










1158



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_EXTERNAL:










1159



      code = makeNode(type, sizeof(SExternalWindowPhysiNode), &pNode);




3,733,622✔





1160



      break;




3,733,622✔






UNCOV

1161



    case QUERY_NODE_SHOW_SCORES_STMT:




×







1162



      code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1163



      break;




×







1164



    case QUERY_NODE_XNODE_TASK_OPTIONS:




19,950✔





1165



      code = makeNode(type, sizeof(SXnodeTaskOptions), &pNode);




19,950✔





1166



      break;




19,950✔





1167



    case QUERY_NODE_XNODE_TASK_SOURCE_OPT:




4,655✔





1168



      code = makeNode(type, sizeof(SXTaskSource), &pNode);




4,655✔





1169



      break;




4,655✔





1170



    case QUERY_NODE_XNODE_TASK_SINK_OPT:




4,788✔





1171



      code = makeNode(type, sizeof(SXTaskSink), &pNode);




4,788✔





1172



      break;




4,788✔





1173



    case QUERY_NODE_CREATE_XNODE_STMT:




2,650✔





1174



      code = makeNode(type, sizeof(SCreateXnodeStmt), &pNode);




2,650✔





1175



      break;




2,650✔





1176



    case QUERY_NODE_DROP_XNODE_STMT:




2,520✔





1177



      code = makeNode(type, sizeof(SDropXnodeStmt), &pNode);




2,520✔





1178



      break;




2,520✔





1179



    case QUERY_NODE_DRAIN_XNODE_STMT:




398✔





1180



      code = makeNode(type, sizeof(SDrainXnodeStmt), &pNode);




398✔





1181



      break;




398✔





1182



    case QUERY_NODE_ALTER_XNODE_STMT:




931✔





1183



      code = makeNode(type, sizeof(SAlterXnodeStmt), &pNode);




931✔





1184



      break;




931✔





1185



    case QUERY_NODE_CREATE_XNODE_TASK_STMT:




4,522✔





1186



      code = makeNode(type, sizeof(SCreateXnodeTaskStmt), &pNode);




4,522✔





1187



      break;




4,522✔





1188



    case QUERY_NODE_START_XNODE_TASK_STMT:




133✔





1189



      code = makeNode(type, sizeof(SStartXnodeTaskStmt), &pNode);




133✔





1190



      break;




133✔





1191



    case QUERY_NODE_STOP_XNODE_TASK_STMT:




133✔





1192



      code = makeNode(type, sizeof(SStopXnodeTaskStmt), &pNode);




133✔





1193



      break;




133✔





1194



    case QUERY_NODE_UPDATE_XNODE_TASK_STMT:




532✔





1195



      code = makeNode(type, sizeof(SUpdateXnodeTaskStmt), &pNode);




532✔





1196



      break;




532✔





1197



    case QUERY_NODE_DROP_XNODE_TASK_STMT:




3,591✔





1198



      code = makeNode(type, sizeof(SDropXnodeTaskStmt), &pNode);




3,591✔





1199



      break;




3,591✔





1200



    case QUERY_NODE_CREATE_XNODE_JOB_STMT:




11,571✔





1201



      code = makeNode(type, sizeof(SCreateXnodeJobStmt), &pNode);




11,571✔





1202



      break;




11,571✔





1203



    case QUERY_NODE_ALTER_XNODE_JOB_STMT:




133✔





1204



      code = makeNode(type, sizeof(SAlterXnodeJobStmt), &pNode);




133✔





1205



      break;




133✔





1206



    case QUERY_NODE_REBALANCE_XNODE_JOB_STMT:




266✔





1207



      code = makeNode(type, sizeof(SRebalanceXnodeJobStmt), &pNode);




266✔





1208



      break;




266✔





1209



    case QUERY_NODE_REBALANCE_XNODE_JOB_WHERE_STMT:




798✔





1210



      code = makeNode(type, sizeof(SRebalanceXnodeJobWhereStmt), &pNode);




798✔





1211



      break;




798✔





1212



    case QUERY_NODE_DROP_XNODE_JOB_STMT:




21,812✔





1213



      code = makeNode(type, sizeof(SDropXnodeJobStmt), &pNode);




21,812✔





1214



      break;




21,812✔





1215



    case QUERY_NODE_CREATE_XNODE_AGENT_STMT:




2,527✔





1216



      code = makeNode(type, sizeof(SCreateXnodeAgentStmt), &pNode);




2,527✔





1217



      break;




2,527✔





1218



    case QUERY_NODE_ALTER_XNODE_AGENT_STMT:




399✔





1219



      code = makeNode(type, sizeof(SAlterXnodeAgentStmt), &pNode);




399✔





1220



      break;




399✔





1221



    case QUERY_NODE_DROP_XNODE_AGENT_STMT:




2,660✔





1222



      code = makeNode(type, sizeof(SDropXnodeAgentStmt), &pNode);




2,660✔





1223



      break;




2,660✔






UNCOV

1224



    case QUERY_NODE_ALTER_DNODES_RELOAD_TLS_STMT:




×







1225



      code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode);




×







1226



      break;




×







1227



    case QUERY_NODE_ALTER_ENCRYPT_KEY_STMT:




294✔





1228



      code = makeNode(type, sizeof(SAlterEncryptKeyStmt), &pNode);




294✔





1229



      break;




294✔






UNCOV

1230



    case QUERY_NODE_ALTER_KEY_EXPIRATION_STMT:




×







1231



      code = makeNode(type, sizeof(SAlterKeyExpirationStmt), &pNode);




×







1232



      break;




×







1233



    case QUERY_NODE_SHOW_VALIDATE_VTABLE_STMT:




241✔





1234



      code = makeNode(type, sizeof(SShowValidateVirtualTable), &pNode);




241✔





1235



      break;




3,846✔






UNCOV

1236



    default:




×







1237













UNCOV

1238



      code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1239



      break;




×







1240



  }










1241



  if (TSDB_CODE_SUCCESS != code) {




2,147,483,647✔






UNCOV

1242



    nodesError("nodesMakeNode unknown node = %s", nodesNodeName(type));




×







1243



  } else










1244



    *ppNodeOut = pNode;




2,147,483,647✔





1245



  return code;




2,147,483,647✔





1246



}










1247












1248



static void destroyVgDataBlockArray(SArray* pArray) {




2,066,781,219✔





1249



  size_t size = taosArrayGetSize(pArray);




2,066,781,219✔





1250



  for (size_t i = 0; i < size; ++i) {




2,147,483,647✔





1251



    SVgDataBlocks* pVg = taosArrayGetP(pArray, i);




700,211,417✔





1252



    taosMemoryFreeClear(pVg->pData);




700,363,172✔





1253



    taosMemoryFreeClear(pVg);




700,273,910✔





1254



  }










1255



  taosArrayDestroy(pArray);




2,066,976,991✔





1256



}




2,066,795,200✔





1257












1258



static void destroyLogicNode(SLogicNode* pNode) {




2,147,483,647✔





1259



  nodesDestroyList(pNode->pTargets);




2,147,483,647✔





1260



  nodesDestroyNode(pNode->pConditions);




2,147,483,647✔





1261



  nodesDestroyList(pNode->pChildren);




2,147,483,647✔





1262



  nodesDestroyNode(pNode->pLimit);




2,147,483,647✔





1263



  nodesDestroyNode(pNode->pSlimit);




2,147,483,647✔





1264



  nodesDestroyList(pNode->pHint);




2,147,483,647✔





1265



}




2,147,483,647✔





1266












1267



static void destroyPhysiNode(SPhysiNode* pNode) {




2,147,483,647✔





1268



  nodesDestroyList(pNode->pChildren);




2,147,483,647✔





1269



  nodesDestroyNode(pNode->pConditions);




2,147,483,647✔





1270



  nodesDestroyNode((SNode*)pNode->pOutputDataBlockDesc);




2,147,483,647✔





1271



  nodesDestroyNode(pNode->pLimit);




2,147,483,647✔





1272



  nodesDestroyNode(pNode->pSlimit);




2,147,483,647✔





1273



}




2,147,483,647✔





1274












1275



static void destroyWinodwPhysiNode(SWindowPhysiNode* pNode) {




58,048,377✔





1276



  destroyPhysiNode((SPhysiNode*)pNode);




58,048,377✔





1277



  nodesDestroyList(pNode->pExprs);




58,046,924✔





1278



  nodesDestroyList(pNode->pFuncs);




58,046,712✔





1279



  nodesDestroyNode(pNode->pTspk);




58,047,140✔





1280



  nodesDestroyNode(pNode->pTsEnd);




58,047,547✔





1281



  nodesDestroyList(pNode->pProjs);




58,048,209✔





1282



}




58,047,308✔





1283












1284



static void destroyExtWindowFillInfo(SExtWindowFillInfo* pFill) {




92,372,631✔





1285



  nodesDestroyList(pFill->pFillExprs);




92,372,631✔





1286



  nodesDestroyNode(pFill->pFillValues);




92,376,799✔





1287



}




92,378,755✔





1288












1289



static void destroyPartitionPhysiNode(SPartitionPhysiNode* pNode) {




23,230,974✔





1290



  destroyPhysiNode((SPhysiNode*)pNode);




23,230,974✔





1291



  nodesDestroyList(pNode->pExprs);




23,230,533✔





1292



  nodesDestroyList(pNode->pPartitionKeys);




23,229,822✔





1293



  nodesDestroyList(pNode->pTargets);




23,230,479✔





1294



}




23,230,546✔





1295












1296



static void destroyScanPhysiNode(SScanPhysiNode* pNode) {




952,571,324✔





1297



  destroyPhysiNode((SPhysiNode*)pNode);




952,571,324✔





1298



  nodesDestroyList(pNode->pScanCols);




952,572,512✔





1299



  nodesDestroyList(pNode->pScanPseudoCols);




952,568,425✔





1300



}




952,574,578✔





1301












1302



static void destroyDataSinkNode(SDataSinkNode* pNode) { nodesDestroyNode((SNode*)pNode->pInputDataBlockDesc); }




1,857,647,604✔





1303












1304



static void destroyExprNode(SExprNode* pExpr) { taosArrayDestroy(pExpr->pAssociation); }




2,147,483,647✔





1305












1306



static void destroyTableCfg(STableCfg* pCfg) {




110,940✔





1307



  if (NULL == pCfg) {




110,940✔





1308



    return;




15,675✔





1309



  }










1310



  taosArrayDestroy(pCfg->pFuncs);




95,265✔





1311



  taosMemoryFree(pCfg->pComment);




95,265✔





1312



  taosMemoryFree(pCfg->pSchemas);




95,265✔





1313



  taosMemoryFree(pCfg->pSchemaExt);




95,265✔





1314



  taosMemoryFree(pCfg->pColRefs);




95,265✔





1315



  taosMemoryFree(pCfg->pTagRefs);




95,265✔





1316



  taosMemoryFree(pCfg->pTags);




95,265✔





1317



  taosMemoryFree(pCfg);




95,265✔





1318



}










1319













UNCOV

1320



static void destroySmaIndex(void* pIndex) { taosMemoryFree(((STableIndexInfo*)pIndex)->expr); }




×







1321













UNCOV

1322



void destroyFuncParam(void* pValue) { taosMemoryFree(((SFunctParam*)pValue)->pCol); }




×







1323












1324



static void destroyHintValue(EHintOption option, void* value) {




17,766,718✔





1325



  switch (option) {










1326



    default:










1327



      break;




17,766,718✔





1328



  }










1329












1330



  taosMemoryFree(value);




17,766,718✔





1331



}




17,766,718✔





1332













UNCOV

1333



void destroySSDataBlock(void* param) {




×







1334



  if (NULL == param) {




×







1335



    return;




×







1336



  }










1337













UNCOV

1338



  SSDataBlock* pBlock = (SSDataBlock*)param;




×







1339



  blockDataDestroy(pBlock);




×







1340



}










1341












1342



void nodesDestroyNode(SNode* pNode) {




2,147,483,647✔





1343



  if (NULL == pNode) {




2,147,483,647✔





1344



    return;




2,147,483,647✔





1345



  }










1346












1347



  switch (nodeType(pNode)) {




2,147,483,647✔





1348



    case QUERY_NODE_COLUMN:




2,147,483,647✔





1349



      destroyExprNode((SExprNode*)pNode);




2,147,483,647✔





1350



      break;




2,147,483,647✔





1351



    case QUERY_NODE_REMOTE_VALUE:




2,147,483,647✔





1352



    case QUERY_NODE_VALUE:










1353



    case QUERY_NODE_REMOTE_ROW:










1354



    case QUERY_NODE_REMOTE_ZERO_ROWS: {










1355



      SValueNode* pValue = (SValueNode*)pNode;




2,147,483,647✔





1356



      destroyExprNode((SExprNode*)pNode);




2,147,483,647✔





1357



      taosMemoryFreeClear(pValue->literal);




2,147,483,647✔





1358



      if (IS_VAR_DATA_TYPE(pValue->node.resType.type) || pValue->node.resType.type == TSDB_DATA_TYPE_DECIMAL) {




2,147,483,647✔





1359



        taosMemoryFreeClear(pValue->datum.p);




608,999,328✔





1360



      }










1361



      break;




2,147,483,647✔





1362



    }










1363



    case QUERY_NODE_REMOTE_VALUE_LIST: {




145,165,948✔





1364



      SRemoteValueListNode* pRemote = (SRemoteValueListNode*)pNode;




145,165,948✔





1365



      destroyExprNode((SExprNode*)pNode);




145,165,948✔





1366



      if (pRemote->hashAllocated) {




145,168,469✔





1367



        taosHashCleanup(pRemote->pHashFilter);




11,344,878✔





1368



        taosHashCleanup(pRemote->pHashFilterOthers);




11,344,312✔





1369



      }










1370



      break;




145,168,437✔





1371



    }










1372



    case QUERY_NODE_REMOTE_TABLE: {




1,174,266✔





1373



      SRemoteTableNode* pRemote = (SRemoteTableNode*)pNode;




1,174,266✔





1374



      if (pRemote->pResBlks && (pRemote->flag & REMOTE_TABLE_FLAG_RES_ALLOCED)) {




1,174,266✔






UNCOV

1375



        taosArrayDestroyEx(pRemote->pResBlks, destroySSDataBlock);




×







1376



      }










1377



      pRemote->pResBlks = NULL;




1,174,266✔





1378



      break;




1,173,846✔





1379



    }










1380



    case QUERY_NODE_UPDATE_TAG_VALUE: {




9,045,551✔





1381



      SUpdateTagValueNode* pTagVal = (SUpdateTagValueNode*)pNode;




9,045,551✔





1382



      nodesDestroyNode((SNode*)pTagVal->pVal);




9,045,551✔





1383



      taosMemoryFree(pTagVal->regexp);




9,045,551✔





1384



      taosMemoryFree(pTagVal->replacement);




9,045,551✔





1385



      break;




9,045,551✔





1386



    }










1387



    case QUERY_NODE_ALTER_TABLE_UPDATE_TAG_VAL_CLAUSE: {




8,925,274✔





1388



      SAlterTableUpdateTagValClause* pClause = (SAlterTableUpdateTagValClause*)pNode;




8,925,274✔





1389



      nodesDestroyList(pClause->pTagList);




8,925,274✔





1390



      break;




8,925,274✔





1391



    }










1392



    case QUERY_NODE_OPERATOR: {




2,147,483,647✔





1393



      SOperatorNode* pOp = (SOperatorNode*)pNode;




2,147,483,647✔





1394



      destroyExprNode((SExprNode*)pNode);




2,147,483,647✔





1395



      nodesDestroyNode(pOp->pLeft);




2,147,483,647✔





1396



      nodesDestroyNode(pOp->pRight);




2,147,483,647✔





1397



      break;




2,147,483,647✔





1398



    }










1399



    case QUERY_NODE_LOGIC_CONDITION:




620,496,865✔





1400



      destroyExprNode((SExprNode*)pNode);




620,496,865✔





1401



      nodesDestroyList(((SLogicConditionNode*)pNode)->pParameterList);




620,494,439✔





1402



      break;




620,497,636✔





1403



    case QUERY_NODE_FUNCTION:




2,147,483,647✔





1404



      destroyExprNode((SExprNode*)pNode);




2,147,483,647✔





1405



      nodesDestroyList(((SFunctionNode*)pNode)->pParameterList);




2,147,483,647✔





1406



      break;




2,147,483,647✔





1407



    case QUERY_NODE_REAL_TABLE: {




1,029,741,180✔





1408



      SRealTableNode* pReal = (SRealTableNode*)pNode;




1,029,741,180✔





1409



      taosMemoryFreeClear(pReal->pMeta);




1,029,741,180✔





1410



      taosMemoryFreeClear(pReal->pVgroupList);




1,029,754,323✔





1411



      taosArrayDestroyEx(pReal->pSmaIndexes, destroySmaIndex);




1,029,752,091✔





1412



      taosArrayDestroyP(pReal->tsmaTargetTbVgInfo, NULL);




1,029,728,638✔





1413



      taosArrayDestroy(pReal->tsmaTargetTbInfo);




1,029,753,352✔





1414



      break;




1,029,756,037✔





1415



    }










1416



    case QUERY_NODE_VIRTUAL_TABLE: {




7,493,353✔





1417



      SVirtualTableNode* pVirtual = (SVirtualTableNode*)pNode;




7,493,353✔





1418



      taosMemoryFreeClear(pVirtual->pMeta);




7,493,353✔





1419



      taosMemoryFreeClear(pVirtual->pVgroupList);




7,493,353✔





1420



      nodesDestroyList(pVirtual->refTables);




7,493,353✔





1421



      break;




7,493,353✔





1422



    }










1423



    case QUERY_NODE_TEMP_TABLE:




63,339,474✔





1424



      nodesDestroyNode(((STempTableNode*)pNode)->pSubquery);




63,339,474✔





1425



      break;




63,339,815✔





1426



    case QUERY_NODE_PLACE_HOLDER_TABLE: {




181,625✔





1427



      SPlaceHolderTableNode* pPlaceHolder = (SPlaceHolderTableNode*)pNode;




181,625✔





1428



      taosMemoryFreeClear(pPlaceHolder->pMeta);




181,625✔





1429



      taosMemoryFreeClear(pPlaceHolder->pVgroupList);




181,625✔





1430



      break;




181,625✔





1431



    }










1432



    case QUERY_NODE_TIME_RANGE: {




4,793,887✔





1433



      STimeRangeNode* pTimeRange = (STimeRangeNode*)pNode;




4,793,887✔





1434



      nodesDestroyNode((SNode*)pTimeRange->pStart);




4,793,887✔





1435



      nodesDestroyNode((SNode*)pTimeRange->pEnd);




4,794,286✔





1436



      break;




4,794,286✔





1437



    }










1438



    case QUERY_NODE_STREAM: {




585,997✔





1439



      SStreamNode* pStream = (SStreamNode*)pNode;




585,997✔





1440



      destroyExprNode((SExprNode*)pNode);




585,997✔





1441



      break;




585,997✔





1442



    }










1443



    case QUERY_NODE_STREAM_OUT_TABLE: {




6,380✔





1444



      SStreamOutTableNode* pOut = (SStreamOutTableNode*)pNode;




6,380✔





1445



      nodesDestroyNode(pOut->pOutTable);




6,380✔





1446



      nodesDestroyNode(pOut->pSubtable);




6,380✔





1447



      nodesDestroyList(pOut->pTags);




6,380✔





1448



      nodesDestroyList(pOut->pCols);




6,380✔





1449



      break;




6,380✔





1450



    }










1451



    case QUERY_NODE_JOIN_TABLE: {




51,899,013✔





1452



      SJoinTableNode* pJoin = (SJoinTableNode*)pNode;




51,899,013✔





1453



      nodesDestroyNode(pJoin->pWindowOffset);




51,899,013✔





1454



      nodesDestroyNode(pJoin->pJLimit);




51,898,591✔





1455



      nodesDestroyNode(pJoin->addPrimCond);




51,899,430✔





1456



      nodesDestroyNode(pJoin->pLeft);




51,899,776✔





1457



      nodesDestroyNode(pJoin->pRight);




51,900,119✔





1458



      nodesDestroyNode(pJoin->pOnCond);




51,899,987✔





1459



      break;




51,899,567✔





1460



    }










1461



    case QUERY_NODE_GROUPING_SET:




230,857,773✔





1462



      nodesDestroyList(((SGroupingSetNode*)pNode)->pParameterList);




230,857,773✔





1463



      break;




230,860,636✔





1464



    case QUERY_NODE_ORDER_BY_EXPR:




840,554,425✔





1465



      nodesDestroyNode(((SOrderByExprNode*)pNode)->pExpr);




840,554,425✔





1466



      break;




840,568,119✔





1467



    case QUERY_NODE_LIMIT: {




146,231,025✔





1468



      SLimitNode* pLimit = (SLimitNode*)pNode;




146,231,025✔





1469



      nodesDestroyNode((SNode*)pLimit->limit);




146,231,025✔





1470



      nodesDestroyNode((SNode*)pLimit->offset);




146,226,354✔





1471



      break;




146,227,114✔





1472



    }










1473



    case QUERY_NODE_STATE_WINDOW: {




6,052,320✔





1474



      SStateWindowNode* pState = (SStateWindowNode*)pNode;




6,052,320✔





1475



      nodesDestroyNode(pState->pCol);




6,052,320✔





1476



      nodesDestroyNode(pState->pExpr);




6,052,320✔





1477



      nodesDestroyNode(pState->pTrueForLimit);




6,052,320✔





1478



      nodesDestroyNode(pState->pExtend);




6,052,320✔





1479



      nodesDestroyNode(pState->pZeroth);




6,052,320✔





1480



      break;




6,052,306✔





1481



    }










1482



    case QUERY_NODE_SESSION_WINDOW: {




18,318,977✔





1483



      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;




18,318,977✔





1484



      nodesDestroyNode((SNode*)pSession->pCol);




18,318,977✔





1485



      nodesDestroyNode((SNode*)pSession->pGap);




18,319,320✔





1486



      break;




18,320,205✔





1487



    }










1488



    case QUERY_NODE_INTERVAL_WINDOW: {




53,116,616✔





1489



      SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;




53,116,616✔





1490



      nodesDestroyNode(pInterval->pCol);




53,116,616✔





1491



      nodesDestroyNode(pInterval->pInterval);




53,116,644✔





1492



      nodesDestroyNode(pInterval->pOffset);




53,118,189✔





1493



      nodesDestroyNode(pInterval->pSliding);




53,118,283✔





1494



      nodesDestroyNode(pInterval->pSOffset);




53,118,046✔





1495



      nodesDestroyNode(pInterval->pFill);




53,118,142✔





1496



      break;




53,116,637✔





1497



    }











UNCOV

1498



    case QUERY_NODE_SLIDING_WINDOW: {




×







1499



      SSlidingWindowNode* pSliding = (SSlidingWindowNode*)pNode;




×







1500



      nodesDestroyNode(pSliding->pSlidingVal);




×







1501



      nodesDestroyNode(pSliding->pOffset);




×







1502



      break;




×







1503



    }










1504



    case QUERY_NODE_PERIOD_WINDOW: {




65,358✔





1505



      SPeriodWindowNode* pPeriod = (SPeriodWindowNode*)pNode;




65,358✔





1506



      nodesDestroyNode(pPeriod->pPeroid);




65,358✔





1507



      nodesDestroyNode(pPeriod->pOffset);




65,358✔





1508



      break;




65,358✔





1509



    }










1510



    case QUERY_NODE_NODE_LIST:




1,280,103,575✔





1511



      nodesDestroyList(((SNodeListNode*)pNode)->pNodeList);




1,280,103,575✔





1512



      break;




1,280,082,518✔





1513



    case QUERY_NODE_SURROUND: {




86,890✔





1514



      SSurroundNode* pSurround = (SSurroundNode*)pNode;




86,890✔





1515



      nodesDestroyNode(pSurround->pSurroundingTime);




86,890✔





1516



      nodesDestroyNode(pSurround->pValues);




86,890✔





1517



      break;




86,890✔





1518



    }










1519



    case QUERY_NODE_FILL: {




4,698,542✔





1520



      SFillNode* pFill = (SFillNode*)pNode;




4,698,542✔





1521



      nodesDestroyNode(pFill->pValues);




4,698,542✔





1522



      nodesDestroyNode(pFill->pWStartTs);




4,698,542✔





1523



      nodesDestroyNode(pFill->pTimeRange);




4,698,542✔





1524



      nodesDestroyNode(pFill->pSurroundingTime);




4,698,542✔





1525



      break;




4,698,542✔





1526



    }










1527



    case QUERY_NODE_RAW_EXPR:




2,147,483,647✔





1528



      nodesDestroyNode(((SRawExprNode*)pNode)->pNode);




2,147,483,647✔





1529



      break;




2,147,483,647✔





1530



    case QUERY_NODE_STREAM_TAG_DEF:




311,922✔





1531



      nodesDestroyNode(((SStreamTagDefNode*)pNode)->pTagExpr);




311,922✔





1532



      break;




311,922✔





1533



    case QUERY_NODE_TARGET:




2,147,483,647✔





1534



      nodesDestroyNode(((STargetNode*)pNode)->pExpr);




2,147,483,647✔





1535



      break;




2,147,483,647✔





1536



    case QUERY_NODE_DATABLOCK_DESC:




2,147,483,647✔





1537



      nodesDestroyList(((SDataBlockDescNode*)pNode)->pSlots);




2,147,483,647✔





1538



      break;




2,147,483,647✔





1539



    case QUERY_NODE_SLOT_DESC:  // no pointer field




2,147,483,647✔





1540



      break;




2,147,483,647✔





1541



    case QUERY_NODE_COLUMN_DEF:




457,806,283✔





1542



      nodesDestroyNode(((SColumnDefNode*)pNode)->pOptions);




457,806,283✔





1543



      break;




457,806,283✔





1544



    case QUERY_NODE_DOWNSTREAM_SOURCE:  // no pointer field




691,630,370✔





1545



      break;




691,630,370✔





1546



    case QUERY_NODE_DATABASE_OPTIONS: {




2,034,724✔





1547



      SDatabaseOptions* pOptions = (SDatabaseOptions*)pNode;




2,034,724✔





1548



      nodesDestroyNode((SNode*)pOptions->pDaysPerFile);




2,034,724✔





1549



      nodesDestroyNode((SNode*)pOptions->ssKeepLocalStr);




2,034,724✔





1550



      nodesDestroyList(pOptions->pKeep);




2,034,724✔





1551



      nodesDestroyList(pOptions->pRetentions);




2,034,724✔





1552



      nodesDestroyNode((SNode*)pOptions->pCompactIntervalNode);




2,034,724✔





1553



      nodesDestroyList(pOptions->pCompactTimeRangeList);




2,034,724✔





1554



      nodesDestroyNode((SNode*)pOptions->pCompactTimeOffsetNode);




2,034,724✔





1555



      nodesDestroyNode((SNode*)pOptions->pKeepTimeOffsetNode);




2,034,724✔





1556



      break;




2,034,724✔





1557



    }










1558



    case QUERY_NODE_TABLE_OPTIONS: {




54,816,748✔





1559



      STableOptions* pOptions = (STableOptions*)pNode;




54,816,748✔





1560



      nodesDestroyList(pOptions->pMaxDelay);




54,816,748✔





1561



      nodesDestroyList(pOptions->pWatermark);




54,822,792✔





1562



      nodesDestroyList(pOptions->pRollupFuncs);




54,816,268✔





1563



      nodesDestroyList(pOptions->pSma);




54,808,097✔





1564



      nodesDestroyList(pOptions->pDeleteMark);




54,798,997✔





1565



      nodesDestroyNode((SNode*)pOptions->pKeepNode);




54,802,520✔





1566



      break;




54,797,143✔





1567



    }










1568



    case QUERY_NODE_COLUMN_OPTIONS: {




450,237,799✔





1569



      SColumnOptions* pOptions = (SColumnOptions*)pNode;




450,237,799✔





1570



      break;




450,237,799✔





1571



    }











UNCOV

1572



    case QUERY_NODE_INDEX_OPTIONS: {




×







1573



      SIndexOptions* pOptions = (SIndexOptions*)pNode;




×







1574



      nodesDestroyList(pOptions->pFuncs);




×







1575



      nodesDestroyNode(pOptions->pInterval);




×







1576



      nodesDestroyNode(pOptions->pOffset);




×







1577



      nodesDestroyNode(pOptions->pSliding);




×







1578



      nodesDestroyNode(pOptions->pStreamOptions);




×







1579



      break;




×







1580



    }










1581



    case QUERY_NODE_EXPLAIN_OPTIONS:  // no pointer field




107,458,367✔





1582



      break;




107,458,367✔





1583



    case QUERY_NODE_STREAM_TRIGGER: {




695,244✔





1584



      SStreamTriggerNode* pTrigger = (SStreamTriggerNode*)pNode;




695,244✔





1585



      nodesDestroyNode(pTrigger->pTriggerWindow);




695,244✔





1586



      nodesDestroyNode(pTrigger->pTrigerTable);




695,244✔





1587



      nodesDestroyNode(pTrigger->pOptions);




695,244✔





1588



      nodesDestroyNode(pTrigger->pNotify);




695,244✔





1589



      nodesDestroyList(pTrigger->pPartitionList);




695,244✔





1590



      break;




695,244✔





1591



    }










1592



    case QUERY_NODE_STREAM_CALC_RANGE: {




12,626✔





1593



      SStreamCalcRangeNode* pRange = (SStreamCalcRangeNode*)pNode;




12,626✔





1594



      nodesDestroyNode(pRange->pStart);




12,626✔





1595



      nodesDestroyNode(pRange->pEnd);




12,626✔





1596



      break;




12,626✔





1597



    }










1598



    case QUERY_NODE_STREAM_TRIGGER_OPTIONS: {




252,911✔





1599



      SStreamTriggerOptions* pOptions = (SStreamTriggerOptions*)pNode;




252,911✔





1600



      nodesDestroyNode(pOptions->pPreFilter);




252,911✔





1601



      nodesDestroyNode(pOptions->pMaxDelay);




252,911✔





1602



      nodesDestroyNode(pOptions->pWaterMark);




252,911✔





1603



      nodesDestroyNode(pOptions->pExpiredTime);




252,911✔





1604



      nodesDestroyNode(pOptions->pFillHisStartTime);




252,911✔





1605



      nodesDestroyNode(pOptions->pIdleTimeout);




252,911✔





1606



      break;




252,911✔





1607



    }










1608



    case QUERY_NODE_TSMA_OPTIONS: {




10,034✔





1609



      STSMAOptions* pOptions = (STSMAOptions*)pNode;




10,034✔





1610



      nodesDestroyList(pOptions->pFuncs);




10,034✔





1611



      nodesDestroyNode(pOptions->pInterval);




10,034✔





1612



      break;




10,034✔





1613



    }










1614



    case QUERY_NODE_LEFT_VALUE:  // no pointer field




93,546,557✔





1615



    case QUERY_NODE_COLUMN_REF:  // no pointer field










1616



      break;




93,546,557✔





1617



    case QUERY_NODE_WHEN_THEN: {




103,791,669✔





1618



      SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;




103,791,669✔





1619



      destroyExprNode((SExprNode*)pNode);




103,791,669✔





1620



      nodesDestroyNode(pWhenThen->pWhen);




103,793,304✔





1621



      nodesDestroyNode(pWhenThen->pThen);




103,798,832✔





1622



      break;




103,797,626✔





1623



    }










1624



    case QUERY_NODE_CASE_WHEN: {




102,245,708✔





1625



      SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;




102,245,708✔





1626



      destroyExprNode((SExprNode*)pNode);




102,245,708✔





1627



      nodesDestroyNode(pCaseWhen->pCase);




102,250,953✔





1628



      nodesDestroyNode(pCaseWhen->pElse);




102,257,676✔





1629



      nodesDestroyList(pCaseWhen->pWhenThenList);




102,261,380✔





1630



      break;




102,259,112✔





1631



    }










1632



    case QUERY_NODE_EVENT_WINDOW: {




5,498,172✔





1633



      SEventWindowNode* pEvent = (SEventWindowNode*)pNode;




5,498,172✔





1634



      nodesDestroyNode(pEvent->pCol);




5,498,172✔





1635



      nodesDestroyNode(pEvent->pStartCond);




5,498,172✔





1636



      nodesDestroyNode(pEvent->pEndCond);




5,498,172✔





1637



      nodesDestroyNode(pEvent->pTrueForLimit);




5,498,172✔





1638



      break;




5,498,172✔





1639



    }










1640



    case QUERY_NODE_COUNT_WINDOW: {




5,171,634✔





1641



      SCountWindowNode* pEvent = (SCountWindowNode*)pNode;




5,171,634✔





1642



      nodesDestroyNode(pEvent->pCol);




5,171,634✔





1643



      nodesDestroyList(pEvent->pColList);




5,171,634✔





1644



      break;




5,171,634✔





1645



    }










1646



    case QUERY_NODE_COUNT_WINDOW_ARGS: {




5,166,068✔





1647



      SCountWindowArgs* pEvent = (SCountWindowArgs*)pNode;




5,166,068✔





1648



      nodesDestroyList(pEvent->pColList);




5,166,068✔





1649



      break;




5,166,224✔





1650



    }











UNCOV

1651



    case QUERY_NODE_ANOMALY_WINDOW: {




×







1652



      SAnomalyWindowNode* pAnomaly = (SAnomalyWindowNode*)pNode;




×







1653



      nodesDestroyNode(pAnomaly->pCol);




×







1654



      nodesDestroyList(pAnomaly->pExpr);




×







1655



      break;




×







1656



    }










1657



    case QUERY_NODE_EXTERNAL_WINDOW: {




299,581✔





1658



      SExternalWindowNode* pExternal = (SExternalWindowNode*)pNode;




299,581✔





1659



      nodesDestroyList(pExternal->pAggFuncList);




299,581✔





1660



      nodesDestroyList(pExternal->pProjectionList);




299,581✔





1661



      nodesDestroyNode(pExternal->pTimeRange);




299,581✔





1662



      taosMemoryFreeClear(pExternal->timezone);




299,581✔





1663



      nodesDestroyNode(pExternal->pCol);




299,581✔





1664



      nodesDestroyNode(pExternal->pSubquery);




299,581✔





1665



      nodesDestroyNode(pExternal->pFill);




299,581✔





1666



      break;




299,581✔





1667



    }










1668



    case QUERY_NODE_HINT: {




17,766,718✔





1669



      SHintNode* pHint = (SHintNode*)pNode;




17,766,718✔





1670



      destroyHintValue(pHint->option, pHint->value);




17,766,718✔





1671



      break;




17,766,718✔





1672



    }










1673



    case QUERY_NODE_VIEW: {




401,481✔





1674



      SViewNode* pView = (SViewNode*)pNode;




401,481✔





1675



      taosMemoryFreeClear(pView->pMeta);




401,481✔





1676



      taosMemoryFreeClear(pView->pVgroupList);




401,481✔





1677



      taosArrayDestroyEx(pView->pSmaIndexes, destroySmaIndex);




401,481✔





1678



      break;




401,481✔





1679



    }










1680



    case QUERY_NODE_WINDOW_OFFSET: {




2,057,988✔





1681



      SWindowOffsetNode* pWin = (SWindowOffsetNode*)pNode;




2,057,988✔





1682



      nodesDestroyNode(pWin->pStartOffset);




2,057,988✔





1683



      nodesDestroyNode(pWin->pEndOffset);




2,057,988✔





1684



      break;




2,057,988✔





1685



    }










1686



    case QUERY_NODE_RANGE_AROUND: {




1,639,304✔





1687



      SRangeAroundNode* pAround = (SRangeAroundNode*)pNode;




1,639,304✔





1688



      nodesDestroyNode(pAround->pInterval);




1,639,304✔





1689



      nodesDestroyNode(pAround->pRange);




1,639,304✔





1690



      break;




1,639,304✔





1691



    }










1692



    case QUERY_NODE_STREAM_NOTIFY_OPTIONS: {




129,851✔





1693



      SStreamNotifyOptions* pNotifyOptions = (SStreamNotifyOptions*)pNode;




129,851✔





1694



      nodesDestroyList(pNotifyOptions->pAddrUrls);




129,851✔





1695



      nodesDestroyNode(pNotifyOptions->pWhere);




129,851✔





1696



      break;




129,851✔





1697



    }










1698



    case QUERY_NODE_TRUE_FOR: {




55,496✔





1699



      STrueForNode* pTrueFor = (STrueForNode*)pNode;




55,496✔





1700



      nodesDestroyNode(pTrueFor->pDuration);




55,496✔





1701



      break;




55,496✔





1702



    }










1703



    case QUERY_NODE_SET_OPERATOR: {




46,523,629✔





1704



      SSetOperator* pStmt = (SSetOperator*)pNode;




46,523,629✔





1705



      nodesDestroyList(pStmt->pSubQueries);




46,523,629✔





1706



      nodesDestroyList(pStmt->pProjectionList);




46,525,036✔





1707



      nodesDestroyNode(pStmt->pLeft);




46,527,302✔





1708



      nodesDestroyNode(pStmt->pRight);




46,527,856✔





1709



      nodesDestroyList(pStmt->pOrderByList);




46,528,276✔





1710



      nodesDestroyNode(pStmt->pLimit);




46,528,308✔





1711



      break;




46,528,034✔





1712



    }










1713



    case QUERY_NODE_SELECT_STMT: {




862,541,850✔





1714



      SSelectStmt* pStmt = (SSelectStmt*)pNode;




862,541,850✔





1715



      nodesDestroyList(pStmt->pSubQueries);




862,541,850✔





1716



      nodesDestroyNode(pStmt->pTimeRange);




862,561,444✔





1717



      nodesDestroyList(pStmt->pProjectionList);




862,569,767✔





1718



      nodesDestroyList(pStmt->pProjectionBindList);




862,567,216✔





1719



      nodesDestroyNode(pStmt->pFromTable);




862,573,789✔





1720



      nodesDestroyNode(pStmt->pWhere);




862,591,068✔





1721



      nodesDestroyList(pStmt->pPartitionByList);




862,586,109✔





1722



      nodesDestroyNode(pStmt->pWindow);




862,585,079✔





1723



      nodesDestroyList(pStmt->pGroupByList);




862,580,588✔





1724



      nodesDestroyNode(pStmt->pHaving);




862,575,805✔





1725



      nodesDestroyNode(pStmt->pRange);




862,573,582✔





1726



      nodesDestroyNode(pStmt->pRangeAround);




862,570,989✔





1727



      nodesDestroyNode(pStmt->pEvery);




862,584,154✔





1728



      nodesDestroyNode(pStmt->pFill);




862,594,440✔





1729



      nodesDestroyList(pStmt->pOrderByList);




862,599,064✔





1730



      nodesDestroyNode((SNode*)pStmt->pLimit);




862,591,778✔





1731



      nodesDestroyNode((SNode*)pStmt->pSlimit);




862,584,024✔





1732



      nodesDestroyList(pStmt->pHint);




862,584,576✔





1733



      break;




862,580,973✔





1734



    }










1735



    case QUERY_NODE_VNODE_MODIFY_STMT: {




681,361,463✔





1736



      SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)pNode;




681,361,463✔





1737



      destroyVgDataBlockArray(pStmt->pDataBlocks);




681,361,463✔





1738



      taosMemoryFreeClear(pStmt->pTableMeta);




681,375,363✔





1739



      if (pStmt->pTagCond) nodesDestroyNode(pStmt->pTagCond);




681,371,579✔





1740



      if (pStmt->pPrivCols) taosArrayDestroy(pStmt->pPrivCols);




681,371,502✔





1741



      if (pStmt->pTableTag) taosArrayDestroy(pStmt->pTableTag);




681,384,805✔





1742



      taosHashCleanup(pStmt->pVgroupsHashObj);




681,387,133✔





1743



      taosHashCleanup(pStmt->pSubTableHashObj);




681,381,942✔





1744



      taosHashCleanup(pStmt->pSuperTableHashObj);




681,393,356✔





1745



      taosHashCleanup(pStmt->pTableNameHashObj);




681,388,334✔





1746



      taosHashCleanup(pStmt->pDbFNameHashObj);




681,390,399✔





1747



      taosHashCleanup(pStmt->pTableCxtHashObj);




681,393,625✔





1748



      if (pStmt->freeHashFunc) {




681,392,120✔





1749



        pStmt->freeHashFunc(pStmt->pTableBlockHashObj);




615,967,449✔





1750



      }










1751



      if (pStmt->freeArrayFunc) {




681,388,843✔





1752



        pStmt->freeArrayFunc(pStmt->pVgDataBlocks);




615,966,204✔





1753



      }










1754



      tdDestroySVCreateTbReq(pStmt->pCreateTblReq);




681,382,280✔





1755



      taosMemoryFreeClear(pStmt->pCreateTblReq);




681,394,904✔





1756



      if (pStmt->freeStbRowsCxtFunc) {




681,393,100✔





1757



        pStmt->freeStbRowsCxtFunc(pStmt->pStbRowsCxt);




615,375,524✔





1758



      }










1759



      taosMemoryFreeClear(pStmt->pStbRowsCxt);




681,381,431✔





1760












1761



      taosMemoryFreeClear(pStmt->pCreateTbInfo);




681,378,511✔





1762












1763



      if (pStmt->destroyParseFileCxt) {




681,389,190✔





1764



        pStmt->destroyParseFileCxt(&pStmt->pParFileCxt);




1,452✔





1765



      }










1766












1767



      int32_t code = taosCloseFile(&pStmt->fp);




681,385,512✔





1768



      if (TSDB_CODE_SUCCESS != code) {




681,384,972✔






UNCOV

1769



        nodesError("failed to close file %s:%d", __func__, __LINE__);




×







1770



      }










1771



      break;




681,376,952✔





1772



    }










1773



    case QUERY_NODE_CREATE_DATABASE_STMT: {




1,681,292✔





1774



      SDatabaseOptions* pOptions = ((SCreateDatabaseStmt*)pNode)->pOptions;




1,681,292✔





1775



      taosMemoryFreeClear(pOptions->pDbCfg);




1,681,292✔





1776



      nodesDestroyNode((SNode*)pOptions);




1,681,292✔





1777



      break;




1,681,292✔





1778



    }










1779



    case QUERY_NODE_DROP_DATABASE_STMT:  // no pointer field




1,417,767✔





1780



      break;




1,417,767✔





1781



    case QUERY_NODE_ALTER_DATABASE_STMT: {




309,088✔





1782



      SDatabaseOptions* pOptions = ((SAlterDatabaseStmt*)pNode)->pOptions;




309,088✔





1783



      taosMemoryFreeClear(pOptions->pDbCfg);




309,088✔





1784



      nodesDestroyNode((SNode*)pOptions);




309,088✔





1785



      break;




309,088✔





1786



    }










1787



    case QUERY_NODE_FLUSH_DATABASE_STMT:  // no pointer field




1,988,155✔





1788



    case QUERY_NODE_TRIM_DATABASE_STMT:   // no pointer field










1789



      break;




1,988,155✔





1790



    case QUERY_NODE_SSMIGRATE_DATABASE_STMT:  // no pointer field




3,137✔





1791



      break;




3,137✔





1792



    case QUERY_NODE_CREATE_TABLE_STMT: {




9,701,955✔





1793



      SCreateTableStmt* pStmt = (SCreateTableStmt*)pNode;




9,701,955✔





1794



      nodesDestroyList(pStmt->pCols);




9,701,955✔





1795



      nodesDestroyList(pStmt->pTags);




9,701,955✔





1796



      nodesDestroyNode((SNode*)pStmt->pOptions);




9,701,955✔





1797



      break;




9,701,955✔





1798



    }










1799



    case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: {




45,070,963✔





1800



      SCreateSubTableClause* pStmt = (SCreateSubTableClause*)pNode;




45,070,963✔





1801



      nodesDestroyList(pStmt->pSpecificTags);




45,070,963✔





1802



      nodesDestroyList(pStmt->pValsOfTags);




45,061,137✔





1803



      nodesDestroyNode((SNode*)pStmt->pOptions);




45,084,218✔





1804



      break;




45,045,500✔





1805



    }










1806



    case QUERY_NODE_CREATE_VIRTUAL_TABLE_STMT: {




232,699✔





1807



      SCreateVTableStmt* pStmt = (SCreateVTableStmt*)pNode;




232,699✔





1808



      nodesDestroyList(pStmt->pCols);




232,699✔





1809



      break;




232,699✔





1810



    }










1811



    case QUERY_NODE_CREATE_VIRTUAL_SUBTABLE_STMT: {




422,101✔





1812



      SCreateVSubTableStmt* pStmt = (SCreateVSubTableStmt*)pNode;




422,101✔





1813



      nodesDestroyList(pStmt->pSpecificColRefs);




422,101✔





1814



      nodesDestroyList(pStmt->pColRefs);




422,101✔





1815



      nodesDestroyList(pStmt->pSpecificTags);




422,101✔





1816



      nodesDestroyList(pStmt->pValsOfTags);




422,101✔





1817



      nodesDestroyList(pStmt->pSpecificTagRefs);




422,101✔





1818



      nodesDestroyList(pStmt->pTagRefs);




422,101✔





1819



      break;




422,101✔





1820



    }










1821



    case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE: {




1,452✔





1822



      SCreateSubTableFromFileClause* pStmt = (SCreateSubTableFromFileClause*)pNode;




1,452✔





1823



      nodesDestroyList(pStmt->pSpecificTags);




1,452✔





1824



      break;




1,452✔





1825



    }










1826



    case QUERY_NODE_CREATE_MULTI_TABLES_STMT:




37,729,009✔





1827



      nodesDestroyList(((SCreateMultiTablesStmt*)pNode)->pSubTables);




37,729,009✔





1828



      break;




37,714,195✔





1829



    case QUERY_NODE_DROP_TABLE_CLAUSE:  // no pointer field




2,841,833✔





1830



      break;




2,841,833✔





1831



    case QUERY_NODE_DROP_TABLE_STMT:




2,723,280✔





1832



      nodesDestroyList(((SDropTableStmt*)pNode)->pTables);




2,723,280✔





1833



      break;




2,723,280✔





1834



    case QUERY_NODE_DROP_SUPER_TABLE_STMT:




180,975✔





1835



    case QUERY_NODE_DROP_VIRTUAL_TABLE_STMT:  // no pointer field










1836



      break;




180,975✔





1837



    case QUERY_NODE_ALTER_TABLE_STMT:




24,009,274✔





1838



    case QUERY_NODE_ALTER_SUPER_TABLE_STMT:










1839



    case QUERY_NODE_ALTER_VIRTUAL_TABLE_STMT: {










1840



      SAlterTableStmt* pStmt = (SAlterTableStmt*)pNode;




24,009,274✔





1841



      nodesDestroyNode((SNode*)pStmt->pOptions);




24,009,274✔





1842



      nodesDestroyNode((SNode*)pStmt->pVal);




24,009,274✔





1843



      nodesDestroyNode(pStmt->pWhere);




24,009,274✔





1844



      nodesDestroyList(pStmt->pList);




24,009,274✔





1845



      break;




24,009,274✔





1846



    }










1847



    case QUERY_NODE_CREATE_MOUNT_STMT:  // no pointer field




1,749✔





1848



      break;




1,749✔





1849



    case QUERY_NODE_DROP_MOUNT_STMT:  // no pointer field




580✔





1850



      break;




580✔





1851



    case QUERY_NODE_CREATE_RSMA_STMT: {




119,582✔





1852



      SCreateRsmaStmt* pStmt = (SCreateRsmaStmt*)pNode;




119,582✔





1853



      nodesDestroyList(pStmt->pFuncs);




119,582✔





1854



      nodesDestroyList(pStmt->pIntervals);




119,582✔





1855



      break;




119,582✔





1856



    }










1857



    case QUERY_NODE_ALTER_RSMA_STMT: {




22,227✔





1858



      SAlterRsmaStmt* pStmt = (SAlterRsmaStmt*)pNode;




22,227✔





1859



      nodesDestroyList(pStmt->pFuncs);




22,227✔





1860



      break;




22,227✔





1861



    }










1862



    case QUERY_NODE_CREATE_USER_STMT: {




118,421✔





1863



      SCreateUserStmt* pStmt = (SCreateUserStmt*)pNode;




118,421✔





1864



      taosMemoryFree(pStmt->pIpRanges);




118,421✔





1865



      taosMemoryFree(pStmt->pTimeRanges);




118,421✔






1866



      nodesDestroyList(pStmt->pSecurityLevels);




118,421✔





1867



      break;




118,421✔





1868



    }











UNCOV

1869



    case QUERY_NODE_CREATE_ENCRYPT_ALGORITHMS_STMT: {




×








UNCOV

1870



      break;




×







1871



    }










1872



    case QUERY_NODE_ALTER_USER_STMT: {




60,061✔





1873



      SAlterUserStmt* pStmt = (SAlterUserStmt*)pNode;




60,061✔





1874



      nodesDestroyNode((SNode*)pStmt->pUserOptions);




60,061✔





1875



      break;




60,061✔





1876



    }










1877



    case QUERY_NODE_ALTER_TOKEN_STMT: {




2,824✔





1878



      SAlterTokenStmt* pStmt = (SAlterTokenStmt*)pNode;




2,824✔





1879



      nodesDestroyNode((SNode*)pStmt->pTokenOptions);




2,824✔





1880



      break;




2,824✔





1881



    }










1882



    case QUERY_NODE_DROP_USER_STMT:     // no pointer field




97,447,183✔





1883



    case QUERY_NODE_USE_DATABASE_STMT:  // no pointer field










1884



    case QUERY_NODE_CREATE_DNODE_STMT:  // no pointer field










1885



    case QUERY_NODE_DROP_DNODE_STMT:    // no pointer field










1886



    case QUERY_NODE_ALTER_DNODE_STMT:   // no pointer field










1887



    case QUERY_NODE_ALTER_DNODES_RELOAD_TLS_STMT:  // no pointer field










1888



    case QUERY_NODE_CREATE_ANODE_STMT:  // no pointer field










1889



    case QUERY_NODE_UPDATE_ANODE_STMT:  // no pointer field










1890



    case QUERY_NODE_DROP_ANODE_STMT:    // no pointer field










1891



    case QUERY_NODE_DROP_BNODE_STMT:    // no pointer field










1892



    case QUERY_NODE_DROP_ENCRYPT_ALGR_STMT:     // no pointer field










1893



      break;




97,447,183✔





1894



    case QUERY_NODE_CREATE_BNODE_STMT: {




26,676✔





1895



      SBnodeOptions* pOptions = ((SCreateBnodeStmt*)pNode)->pOptions;




26,676✔





1896



      nodesDestroyNode((SNode*)pOptions);




26,676✔





1897



      break;




26,676✔





1898



    }










1899



    case QUERY_NODE_BNODE_OPTIONS: {




26,676✔





1900



      SBnodeOptions* pOptions = (SBnodeOptions*)pNode;




26,676✔





1901



      // nodesDestroyList(pOptions->pProtocol);










1902



      break;




26,676✔





1903



    }










1904



    case QUERY_NODE_DATE_TIME_RANGE:  // no pointer field




40,825✔





1905



    case QUERY_NODE_IP_RANGE:         // no pointer field










1906



    case QUERY_NODE_TOKEN_OPTIONS:    // no pointer field










1907



      break;




40,825✔





1908



    case QUERY_NODE_USER_OPTIONS: {




205,425✔





1909



      SUserOptions* opts = (SUserOptions*)pNode;




205,425✔





1910



      nodesDestroyList(opts->pIpRanges);




205,425✔





1911



      nodesDestroyList(opts->pDropIpRanges);




205,425✔





1912



      nodesDestroyList(opts->pTimeRanges);




205,425✔





1913



      nodesDestroyList(opts->pDropTimeRanges);




205,425✔






1914



      nodesDestroyList(opts->pSecurityLevels);




205,425✔





1915



      break;




205,425✔





1916



    }










1917



    case QUERY_NODE_CREATE_INDEX_STMT: {




23,074✔





1918



      SCreateIndexStmt* pStmt = (SCreateIndexStmt*)pNode;




23,074✔





1919



      nodesDestroyNode((SNode*)pStmt->pOptions);




23,074✔





1920



      nodesDestroyList(pStmt->pCols);




23,074✔





1921



      break;




23,074✔





1922



    }










1923



    case QUERY_NODE_DROP_INDEX_STMT:          // no pointer field




199,673✔





1924



    case QUERY_NODE_CREATE_QNODE_STMT:        // no pointer field










1925



    case QUERY_NODE_DROP_QNODE_STMT:          // no pointer field










1926



    case QUERY_NODE_CREATE_BACKUP_NODE_STMT:  // no pointer field










1927



    case QUERY_NODE_DROP_BACKUP_NODE_STMT:    // no pointer field










1928



    case QUERY_NODE_CREATE_SNODE_STMT:        // no pointer field










1929



    case QUERY_NODE_DROP_SNODE_STMT:          // no pointer field










1930



    case QUERY_NODE_CREATE_MNODE_STMT:        // no pointer field










1931



    case QUERY_NODE_DROP_MNODE_STMT:          // no pointer field










1932



      break;




199,673✔





1933



    case QUERY_NODE_CREATE_TOPIC_STMT:




222,068✔





1934



      nodesDestroyNode(((SCreateTopicStmt*)pNode)->pQuery);




222,068✔





1935



      nodesDestroyNode(((SCreateTopicStmt*)pNode)->pWhere);




222,068✔





1936



      break;




222,068✔





1937



    case QUERY_NODE_DROP_TOPIC_STMT:   // no pointer field




697,311✔





1938



    case QUERY_NODE_DROP_CGROUP_STMT:  // no pointer field










1939



    case QUERY_NODE_ALTER_LOCAL_STMT:  // no pointer field










1940



      break;




697,311✔





1941



    case QUERY_NODE_EXPLAIN_STMT: {




99,008,820✔





1942



      SExplainStmt* pStmt = (SExplainStmt*)pNode;




99,008,820✔





1943



      nodesDestroyNode((SNode*)pStmt->pOptions);




99,008,820✔





1944



      nodesDestroyNode(pStmt->pQuery);




99,017,601✔





1945



      break;




99,032,463✔





1946



    }










1947



    case QUERY_NODE_DESCRIBE_STMT:




576,095✔





1948



      taosMemoryFree(((SDescribeStmt*)pNode)->pMeta);




576,095✔





1949



      break;




576,068✔





1950



    case QUERY_NODE_RESET_QUERY_CACHE_STMT:  // no pointer field




2,237,443✔





1951



      break;




2,237,443✔





1952



    case QUERY_NODE_COMPACT_DATABASE_STMT: {




42,497✔





1953



      SCompactDatabaseStmt* pStmt = (SCompactDatabaseStmt*)pNode;




42,497✔





1954



      nodesDestroyNode(pStmt->pStart);




42,497✔





1955



      nodesDestroyNode(pStmt->pEnd);




42,497✔





1956



      break;




42,497✔





1957



    }










1958



    case QUERY_NODE_ROLLUP_DATABASE_STMT: {




10,565✔





1959



      SRollupDatabaseStmt* pStmt = (SRollupDatabaseStmt*)pNode;




10,565✔





1960



      nodesDestroyNode(pStmt->pStart);




10,565✔





1961



      nodesDestroyNode(pStmt->pEnd);




10,565✔





1962



      break;




10,565✔





1963



    }










1964



    case QUERY_NODE_SCAN_DATABASE_STMT: {




1,032✔





1965



      SScanDatabaseStmt* pStmt = (SScanDatabaseStmt*)pNode;




1,032✔





1966



      nodesDestroyNode(pStmt->pStart);




1,032✔





1967



      nodesDestroyNode(pStmt->pEnd);




1,032✔





1968



      break;




1,032✔





1969



    }










1970



    case QUERY_NODE_COMPACT_VGROUPS_STMT: {




4,075✔





1971



      SCompactVgroupsStmt* pStmt = (SCompactVgroupsStmt*)pNode;




4,075✔





1972



      nodesDestroyNode(pStmt->pDbName);




4,075✔





1973



      nodesDestroyList(pStmt->vgidList);




4,075✔





1974



      nodesDestroyNode(pStmt->pStart);




4,075✔





1975



      nodesDestroyNode(pStmt->pEnd);




4,075✔





1976



      break;




4,075✔





1977



    }










1978



    case QUERY_NODE_ROLLUP_VGROUPS_STMT: {




4,734✔





1979



      SRollupVgroupsStmt* pStmt = (SRollupVgroupsStmt*)pNode;




4,734✔





1980



      nodesDestroyNode(pStmt->pDbName);




4,734✔





1981



      nodesDestroyList(pStmt->vgidList);




4,734✔





1982



      nodesDestroyNode(pStmt->pStart);




4,734✔





1983



      nodesDestroyNode(pStmt->pEnd);




4,734✔





1984



      break;




4,734✔





1985



    }










1986



    case QUERY_NODE_SCAN_VGROUPS_STMT: {




270✔





1987



      SScanVgroupsStmt* pStmt = (SScanVgroupsStmt*)pNode;




270✔





1988



      nodesDestroyNode(pStmt->pDbName);




270✔





1989



      nodesDestroyList(pStmt->vgidList);




270✔





1990



      nodesDestroyNode(pStmt->pStart);




270✔





1991



      nodesDestroyNode(pStmt->pEnd);




270✔





1992



      break;




270✔





1993



    }










1994



    case QUERY_NODE_CREATE_FUNCTION_STMT:  // no pointer field




29,202✔





1995



    case QUERY_NODE_DROP_FUNCTION_STMT:    // no pointer field










1996



      break;




29,202✔





1997



    case QUERY_NODE_CREATE_STREAM_STMT: {




685,823✔





1998



      SCreateStreamStmt* pStmt = (SCreateStreamStmt*)pNode;




685,823✔





1999



      ;










2000



      nodesDestroyNode(pStmt->pQuery);




685,823✔





2001



      nodesDestroyList(pStmt->pTags);




685,823✔





2002



      nodesDestroyList(pStmt->pCols);




685,823✔





2003



      nodesDestroyNode(pStmt->pSubtable);




685,823✔





2004



      nodesDestroyNode(pStmt->pTrigger);




685,823✔





2005



      break;




685,823✔





2006



    }










2007



    case QUERY_NODE_DROP_STREAM_STMT:




20,983✔





2008



      nodesDestroyList(((SDropStreamStmt*)pNode)->pStreamList);




20,983✔





2009



      break;




20,983✔





2010



    case QUERY_NODE_PAUSE_STREAM_STMT:                    // no pointer field




83,022✔





2011



    case QUERY_NODE_RESUME_STREAM_STMT:                   // no pointer field










2012



    case QUERY_NODE_BALANCE_VGROUP_STMT:                  // no pointer field










2013



    case QUERY_NODE_ASSIGN_LEADER_STMT:                   // no pointer field










2014



    case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT:           // no pointer field










2015



    case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT:  // no pointer field










2016



    case QUERY_NODE_SET_VGROUP_KEEP_VERSION_STMT:         // no pointer field










2017



    case QUERY_NODE_TRIM_DATABASE_WAL_STMT:               // no pointer field










2018



    case QUERY_NODE_CREATE_TOKEN_STMT:                    // no pointer field










2019



    case QUERY_NODE_DROP_TOKEN_STMT:                      // no pointer field










2020



    case QUERY_NODE_CREATE_TOTP_SECRET_STMT:              // no pointer field










2021



    case QUERY_NODE_DROP_TOTP_SECRET_STMT:                // no pointer field










2022



    case QUERY_NODE_MERGE_VGROUP_STMT:                    // no pointer field










2023



      break;




83,022✔





2024



    case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:




48,923✔





2025



      nodesDestroyList(((SRedistributeVgroupStmt*)pNode)->pDnodes);




48,923✔





2026



      break;




48,923✔





2027



    case QUERY_NODE_SPLIT_VGROUP_STMT:  // no pointer field




21,008✔





2028



    case QUERY_NODE_SYNCDB_STMT:        // no pointer field










2029



      break;




21,008✔





2030



    case QUERY_NODE_GRANT_STMT:




957,759✔





2031



      nodesDestroyNode(((SGrantStmt*)pNode)->pCond);




957,759✔





2032



      break;




957,759✔





2033



    case QUERY_NODE_REVOKE_STMT:




508,608✔





2034



      nodesDestroyNode(((SRevokeStmt*)pNode)->pCond);




508,608✔





2035



      break;




508,608✔





2036



    case QUERY_NODE_ALTER_CLUSTER_STMT:  // no pointer field




4,454✔





2037



      break;




4,454✔





2038



    case QUERY_NODE_SHOW_DNODES_STMT:




3,275,730✔





2039



    case QUERY_NODE_SHOW_MNODES_STMT:










2040



    case QUERY_NODE_SHOW_MODULES_STMT:










2041



    case QUERY_NODE_SHOW_QNODES_STMT:










2042



    case QUERY_NODE_SHOW_ANODES_STMT:










2043



    case QUERY_NODE_SHOW_ANODES_FULL_STMT:










2044



    case QUERY_NODE_SHOW_XNODES_STMT:










2045



    case QUERY_NODE_SHOW_XNODE_TASKS_STMT:










2046



    case QUERY_NODE_SHOW_XNODE_AGENTS_STMT:










2047



    case QUERY_NODE_SHOW_XNODE_JOBS_STMT:










2048



    case QUERY_NODE_SHOW_SNODES_STMT:










2049



    case QUERY_NODE_SHOW_BACKUP_NODES_STMT:










2050



    case QUERY_NODE_SHOW_ARBGROUPS_STMT:










2051



    case QUERY_NODE_SHOW_CLUSTER_STMT:










2052



    case QUERY_NODE_SHOW_SECURITY_POLICIES_STMT:










2053



    case QUERY_NODE_SHOW_DATABASES_STMT:










2054



    case QUERY_NODE_SHOW_FUNCTIONS_STMT:










2055



    case QUERY_NODE_SHOW_INDEXES_STMT:










2056



    case QUERY_NODE_SHOW_STABLES_STMT:










2057



    case QUERY_NODE_SHOW_STREAMS_STMT:










2058



    case QUERY_NODE_SHOW_TABLES_STMT:










2059



    case QUERY_NODE_SHOW_VTABLES_STMT:










2060



    case QUERY_NODE_SHOW_USERS_STMT:










2061



    case QUERY_NODE_SHOW_USERS_FULL_STMT:










2062



    case QUERY_NODE_SHOW_ROLES_STMT:










2063



    case QUERY_NODE_SHOW_LICENCES_STMT:










2064



    case QUERY_NODE_SHOW_VGROUPS_STMT:










2065



    case QUERY_NODE_SHOW_TOPICS_STMT:










2066



    case QUERY_NODE_SHOW_CONSUMERS_STMT:










2067



    case QUERY_NODE_SHOW_CONNECTIONS_STMT:










2068



    case QUERY_NODE_SHOW_QUERIES_STMT:










2069



    case QUERY_NODE_SHOW_VNODES_STMT:










2070



    case QUERY_NODE_SHOW_APPS_STMT:










2071



    case QUERY_NODE_SHOW_SCORES_STMT:










2072



    case QUERY_NODE_SHOW_VARIABLES_STMT:










2073



    case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:










2074



    case QUERY_NODE_SHOW_TRANSACTIONS_STMT:










2075



    case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:










2076



    case QUERY_NODE_SHOW_TAGS_STMT:










2077



    case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT:










2078



    case QUERY_NODE_SHOW_ROLE_PRIVILEGES_STMT:










2079



    case QUERY_NODE_SHOW_ROLE_COL_PRIVILEGES_STMT:










2080



    case QUERY_NODE_SHOW_VIEWS_STMT:










2081



    case QUERY_NODE_SHOW_GRANTS_FULL_STMT:










2082



    case QUERY_NODE_SHOW_GRANTS_LOGS_STMT:










2083



    case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT:










2084



    case QUERY_NODE_SHOW_ENCRYPTIONS_STMT:










2085



    case QUERY_NODE_SHOW_ENCRYPT_ALGORITHMS_STMT:










2086



    case QUERY_NODE_SHOW_ENCRYPT_STATUS_STMT:










2087



    case QUERY_NODE_SHOW_TSMAS_STMT:










2088



    case QUERY_NODE_SHOW_USAGE_STMT:










2089



    case QUERY_NODE_SHOW_MOUNTS_STMT:










2090



    case QUERY_NODE_SHOW_RSMAS_STMT:










2091



    case QUERY_NODE_SHOW_RETENTIONS_STMT:










2092



    case QUERY_NODE_SHOW_INSTANCES_STMT: {










2093



      SShowStmt* pStmt = (SShowStmt*)pNode;




3,275,730✔





2094



      nodesDestroyNode(pStmt->pDbName);




3,275,730✔





2095



      nodesDestroyNode(pStmt->pTbName);




3,275,730✔





2096



      nodesDestroyNode(pStmt->pWhere);




3,275,730✔





2097



      break;




3,275,730✔





2098



    }










2099



    case QUERY_NODE_SHOW_TABLE_TAGS_STMT: {




9,929✔





2100



      SShowTableTagsStmt* pStmt = (SShowTableTagsStmt*)pNode;




9,929✔





2101



      nodesDestroyNode(pStmt->pDbName);




9,929✔





2102



      nodesDestroyNode(pStmt->pTbName);




9,929✔





2103



      nodesDestroyList(pStmt->pTags);




9,929✔





2104



      break;




9,929✔





2105



    }










2106



    case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:




40,589✔





2107



      nodesDestroyNode(((SShowDnodeVariablesStmt*)pNode)->pDnodeId);




40,589✔





2108



      nodesDestroyNode(((SShowDnodeVariablesStmt*)pNode)->pLikePattern);




40,589✔





2109



      break;




40,589✔





2110



    case QUERY_NODE_SHOW_COMPACTS_STMT:




748,772✔





2111



    case QUERY_NODE_SHOW_SCANS_STMT:










2112



      break;




748,772✔





2113



    case QUERY_NODE_SHOW_COMPACT_DETAILS_STMT:




36,790✔





2114



    case QUERY_NODE_SHOW_RETENTION_DETAILS_STMT: {










2115



      SShowCompactDetailsStmt* pStmt = (SShowCompactDetailsStmt*)pNode;




36,790✔





2116



      nodesDestroyNode(pStmt->pId);




36,790✔





2117



      break;




36,790✔





2118



    }










2119



    case QUERY_NODE_SHOW_SCAN_DETAILS_STMT: {




1,836✔





2120



      SShowScanDetailsStmt* pStmt = (SShowScanDetailsStmt*)pNode;




1,836✔





2121



      nodesDestroyNode(pStmt->pScanId);




1,836✔





2122



      break;




1,836✔





2123



    }










2124



    case QUERY_NODE_SHOW_SSMIGRATES_STMT:




92,313✔





2125



      break;




92,313✔





2126



    case QUERY_NODE_SHOW_TOKENS_STMT:




1,907✔





2127



      break;




1,907✔





2128



    case QUERY_NODE_SHOW_TRANSACTION_DETAILS_STMT: {




310✔





2129



      SShowTransactionDetailsStmt* pStmt = (SShowTransactionDetailsStmt*)pNode;




310✔





2130



      nodesDestroyNode(pStmt->pTransactionId);




310✔





2131



      break;




310✔





2132



    }










2133



    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:




76,082✔





2134



      taosMemoryFreeClear(((SShowCreateDatabaseStmt*)pNode)->pCfg);




76,082✔





2135



      break;




76,082✔





2136



    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:




107,094✔





2137



    case QUERY_NODE_SHOW_CREATE_VTABLE_STMT:










2138



    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:










2139



      taosMemoryFreeClear(((SShowCreateTableStmt*)pNode)->pDbCfg);




107,094✔





2140



      destroyTableCfg((STableCfg*)(((SShowCreateTableStmt*)pNode)->pTableCfg));




107,094✔





2141



      break;




107,094✔





2142



    case QUERY_NODE_SHOW_CREATE_VIEW_STMT:        // no pointer field




18,062✔





2143



    case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:  // no pointer field










2144



    case QUERY_NODE_KILL_CONNECTION_STMT:         // no pointer field










2145



    case QUERY_NODE_KILL_QUERY_STMT:              // no pointer field










2146



    case QUERY_NODE_KILL_TRANSACTION_STMT:        // no pointer field










2147



    case QUERY_NODE_KILL_COMPACT_STMT:            // no pointer field










2148



    case QUERY_NODE_KILL_RETENTION_STMT:          // no pointer field










2149



    case QUERY_NODE_KILL_SCAN_STMT:










2150



    case QUERY_NODE_KILL_SSMIGRATE_STMT:          // no pointer field










2151



      break;




18,062✔





2152



    case QUERY_NODE_SHOW_VALIDATE_VTABLE_STMT:




3,846✔





2153



      taosMemoryFreeClear(((SShowValidateVirtualTable*)pNode)->pDbCfg);




3,846✔





2154



      destroyTableCfg((STableCfg*)(((SShowValidateVirtualTable*)pNode)->pTableCfg));




3,846✔





2155



      break;




3,846✔





2156



    case QUERY_NODE_SHOW_CREATE_RSMA_STMT: {




3,445✔





2157



      SRsmaInfoRsp* pMeta = ((SShowCreateRsmaStmt*)pNode)->pRsmaMeta;




3,445✔





2158



      if (pMeta != NULL) {




3,445✔





2159



        tFreeRsmaInfoRsp(pMeta, true);




2,656✔





2160



        taosMemFreeClear(((SShowCreateRsmaStmt*)pNode)->pRsmaMeta);




2,656✔





2161



      }










2162



      break;




3,445✔





2163



    }










2164



    case QUERY_NODE_DELETE_STMT: {




1,962,463✔





2165



      SDeleteStmt* pStmt = (SDeleteStmt*)pNode;




1,962,463✔





2166



      nodesDestroyNode(pStmt->pFromTable);




1,962,463✔





2167



      nodesDestroyNode(pStmt->pWhere);




1,962,463✔





2168



      nodesDestroyNode(pStmt->pCountFunc);




1,962,463✔





2169



      nodesDestroyNode(pStmt->pFirstFunc);




1,962,463✔





2170



      nodesDestroyNode(pStmt->pLastFunc);




1,962,463✔





2171



      nodesDestroyNode(pStmt->pTagCond);




1,962,463✔





2172



      break;




1,962,463✔





2173



    }










2174



    case QUERY_NODE_INSERT_STMT: {




528,960✔





2175



      SInsertStmt* pStmt = (SInsertStmt*)pNode;




528,960✔





2176



      nodesDestroyNode(pStmt->pTable);




528,960✔





2177



      nodesDestroyList(pStmt->pCols);




528,960✔





2178



      nodesDestroyNode(pStmt->pQuery);




528,960✔





2179



      break;




528,960✔





2180



    }










2181



    case QUERY_NODE_QUERY: {




1,091,748,090✔





2182



      SQuery* pQuery = (SQuery*)pNode;




1,091,748,090✔





2183



      nodesDestroyNode(pQuery->pPrevRoot);




1,091,748,090✔





2184



      nodesDestroyNode(pQuery->pRoot);




1,091,756,543✔





2185



      nodesDestroyNode(pQuery->pPostRoot);




1,091,791,252✔





2186



      taosMemoryFreeClear(pQuery->pResSchema);




1,091,798,632✔





2187



      if (NULL != pQuery->pCmdMsg) {




1,091,807,163✔





2188



        taosMemoryFreeClear(pQuery->pCmdMsg->pMsg);




147,588✔





2189



        taosMemoryFreeClear(pQuery->pCmdMsg);




147,588✔





2190



      }










2191



      taosMemoryFreeClear(pQuery->pResExtSchema);




1,091,797,197✔





2192



      taosArrayDestroy(pQuery->pDbList);




1,091,807,505✔





2193



      taosArrayDestroy(pQuery->pTableList);




1,091,801,897✔





2194



      taosArrayDestroy(pQuery->pTargetTableList);




1,091,801,527✔





2195



      taosArrayDestroy(pQuery->pPlaceholderValues);




1,091,801,268✔





2196



      nodesDestroyNode(pQuery->pPrepareRoot);




1,091,783,969✔





2197



      break;




1,091,793,938✔





2198



    }










2199



    case QUERY_NODE_RESTORE_DNODE_STMT:  // no pointer field




2,465✔





2200



    case QUERY_NODE_RESTORE_QNODE_STMT:  // no pointer field










2201



    case QUERY_NODE_RESTORE_MNODE_STMT:  // no pointer field










2202



    case QUERY_NODE_RESTORE_VNODE_STMT:  // no pointer field










2203



      break;




2,465✔





2204



    case QUERY_NODE_CREATE_VIEW_STMT: {




227,290✔





2205



      SCreateViewStmt* pStmt = (SCreateViewStmt*)pNode;




227,290✔





2206



      taosMemoryFree(pStmt->pQuerySql);




227,290✔





2207



      tFreeSCMCreateViewReq(&pStmt->createReq);




227,290✔





2208



      nodesDestroyNode(pStmt->pQuery);




227,290✔





2209



      break;




227,290✔





2210



    }










2211



    case QUERY_NODE_DROP_VIEW_STMT:




170,218✔





2212



      break;




170,218✔





2213



    case QUERY_NODE_CREATE_TSMA_STMT: {




8,970✔





2214



      SCreateTSMAStmt* pStmt = (SCreateTSMAStmt*)pNode;




8,970✔





2215



      nodesDestroyNode((SNode*)pStmt->pOptions);




8,970✔





2216



      break;




8,970✔





2217



    }










2218



    case QUERY_NODE_RECALCULATE_STREAM_STMT: {




12,626✔





2219



      SRecalcStreamStmt* pStmt = (SRecalcStreamStmt*)pNode;




12,626✔





2220



      nodesDestroyNode((SNode*)pStmt->pRange);




12,626✔





2221



      break;




12,626✔





2222



    }










2223



    case QUERY_NODE_LOGIC_PLAN_SCAN: {




1,104,275,438✔





2224



      SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode;




1,104,275,438✔





2225



      destroyLogicNode((SLogicNode*)pLogicNode);




1,104,275,438✔





2226



      nodesDestroyList(pLogicNode->pScanCols);




1,104,300,067✔





2227



      nodesDestroyList(pLogicNode->pScanPseudoCols);




1,104,318,534✔





2228



      taosMemoryFreeClear(pLogicNode->pVgroupList);




1,104,322,612✔





2229



      nodesDestroyList(pLogicNode->pDynamicScanFuncs);




1,104,336,358✔





2230



      nodesDestroyNode(pLogicNode->pTagCond);




1,104,330,987✔





2231



      nodesDestroyNode(pLogicNode->pTagIndexCond);




1,104,330,017✔





2232



      taosArrayDestroyEx(pLogicNode->pSmaIndexes, destroySmaIndex);




1,104,326,688✔





2233



      nodesDestroyList(pLogicNode->pGroupTags);




1,104,306,286✔





2234



      taosArrayDestroyEx(pLogicNode->pFuncTypes, destroyFuncParam);




1,104,321,521✔





2235



      taosArrayDestroyP(pLogicNode->pTsmaTargetTbVgInfo, NULL);




1,104,321,376✔





2236



      taosArrayDestroy(pLogicNode->pTsmaTargetTbInfo);




1,104,290,481✔





2237



      taosMemoryFreeClear(pLogicNode->pExtScanRange);




1,104,310,076✔





2238



      nodesDestroyNode(pLogicNode->pTimeRange);




1,104,309,590✔





2239



      nodesDestroyNode(pLogicNode->pExtTimeRange);




1,104,277,668✔





2240



      nodesDestroyNode(pLogicNode->pPrimaryCond);




1,104,311,788✔





2241



      break;




1,104,323,703✔





2242



    }










2243



    case QUERY_NODE_LOGIC_PLAN_JOIN: {




53,379,518✔





2244



      SJoinLogicNode* pLogicNode = (SJoinLogicNode*)pNode;




53,379,518✔





2245



      destroyLogicNode((SLogicNode*)pLogicNode);




53,379,518✔





2246



      nodesDestroyNode(pLogicNode->pWindowOffset);




53,379,654✔





2247



      nodesDestroyNode(pLogicNode->pJLimit);




53,379,566✔





2248



      nodesDestroyNode(pLogicNode->addPrimEqCond);




53,379,568✔





2249



      nodesDestroyNode(pLogicNode->pPrimKeyEqCond);




53,379,051✔





2250



      nodesDestroyNode(pLogicNode->pColEqCond);




53,379,654✔





2251



      nodesDestroyNode(pLogicNode->pColOnCond);




53,379,654✔





2252



      nodesDestroyNode(pLogicNode->pTagEqCond);




53,379,568✔





2253



      nodesDestroyNode(pLogicNode->pTagOnCond);




53,379,396✔





2254



      nodesDestroyNode(pLogicNode->pFullOnCond);




53,379,400✔





2255



      nodesDestroyList(pLogicNode->pLeftEqNodes);




53,379,484✔





2256



      nodesDestroyList(pLogicNode->pRightEqNodes);




53,379,410✔





2257



      nodesDestroyNode(pLogicNode->pLeftOnCond);




53,378,547✔





2258



      nodesDestroyNode(pLogicNode->pRightOnCond);




53,378,955✔





2259



      break;




53,379,312✔





2260



    }










2261



    case QUERY_NODE_LOGIC_PLAN_VIRTUAL_TABLE_SCAN: {




15,401,694✔





2262



      SVirtualScanLogicNode* pLogicNode = (SVirtualScanLogicNode*)pNode;




15,401,694✔





2263



      destroyLogicNode((SLogicNode*)pLogicNode);




15,401,694✔





2264



      nodesDestroyList(pLogicNode->pScanCols);




15,401,694✔





2265



      nodesDestroyList(pLogicNode->pScanPseudoCols);




15,401,694✔





2266



      taosMemoryFreeClear(pLogicNode->pVgroupList);




15,401,694✔





2267



      break;




15,401,694✔





2268



    }










2269



    case QUERY_NODE_LOGIC_PLAN_AGG: {




393,928,694✔





2270



      SAggLogicNode* pLogicNode = (SAggLogicNode*)pNode;




393,928,694✔





2271



      destroyLogicNode((SLogicNode*)pLogicNode);




393,928,694✔





2272



      nodesDestroyList(pLogicNode->pAggFuncs);




393,944,547✔





2273



      nodesDestroyList(pLogicNode->pGroupKeys);




393,942,985✔





2274



      break;




393,942,451✔





2275



    }










2276



    case QUERY_NODE_LOGIC_PLAN_PROJECT: {




794,520,082✔





2277



      SProjectLogicNode* pLogicNode = (SProjectLogicNode*)pNode;




794,520,082✔





2278



      destroyLogicNode((SLogicNode*)pLogicNode);




794,520,082✔





2279



      nodesDestroyList(pLogicNode->pProjections);




794,582,009✔





2280



      break;




794,598,252✔





2281



    }










2282



    case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: {




1,385,491,420✔





2283



      SVnodeModifyLogicNode* pLogicNode = (SVnodeModifyLogicNode*)pNode;




1,385,491,420✔





2284



      destroyLogicNode((SLogicNode*)pLogicNode);




1,385,491,420✔





2285



      destroyVgDataBlockArray(pLogicNode->pDataBlocks);




1,385,455,753✔





2286



      // pVgDataBlocks is weak reference










2287



      nodesDestroyNode(pLogicNode->pAffectedRows);




1,385,533,441✔





2288



      nodesDestroyNode(pLogicNode->pStartTs);




1,385,570,172✔





2289



      nodesDestroyNode(pLogicNode->pEndTs);




1,385,584,572✔





2290



      taosMemoryFreeClear(pLogicNode->pVgroupList);




1,385,519,305✔





2291



      nodesDestroyList(pLogicNode->pInsertCols);




1,385,572,394✔





2292



      break;




1,385,612,384✔





2293



    }










2294



    case QUERY_NODE_LOGIC_PLAN_EXCHANGE:




294,289,252✔





2295



      destroyLogicNode((SLogicNode*)pNode);




294,289,252✔





2296



      break;




294,288,913✔





2297



    case QUERY_NODE_LOGIC_PLAN_MERGE: {




72,433,084✔





2298



      SMergeLogicNode* pLogicNode = (SMergeLogicNode*)pNode;




72,433,084✔





2299



      destroyLogicNode((SLogicNode*)pLogicNode);




72,433,084✔





2300



      nodesDestroyList(pLogicNode->pMergeKeys);




72,433,764✔





2301



      nodesDestroyList(pLogicNode->pInputs);




72,433,676✔





2302



      break;




72,433,636✔





2303



    }










2304



    case QUERY_NODE_LOGIC_PLAN_WINDOW: {




88,636,016✔





2305



      SWindowLogicNode* pLogicNode = (SWindowLogicNode*)pNode;




88,636,016✔





2306



      destroyLogicNode((SLogicNode*)pLogicNode);




88,636,016✔





2307



      nodesDestroyList(pLogicNode->pFuncs);




88,645,547✔





2308



      nodesDestroyNode(pLogicNode->pTspk);




88,644,884✔





2309



      nodesDestroyNode(pLogicNode->pTimeRange);




88,646,955✔





2310



      nodesDestroyNode(pLogicNode->pTsEnd);




88,646,608✔





2311



      nodesDestroyNode(pLogicNode->pStateExpr);




88,646,786✔





2312



      nodesDestroyNode(pLogicNode->pStartCond);




88,647,030✔





2313



      nodesDestroyNode(pLogicNode->pEndCond);




88,647,442✔





2314



      nodesDestroyList(pLogicNode->pColList);




88,647,735✔





2315



      nodesDestroyList(pLogicNode->pProjs);




88,647,641✔





2316



      destroyExtWindowFillInfo(&pLogicNode->extFill);




88,642,553✔





2317



      break;




88,645,199✔





2318



    }










2319



    case QUERY_NODE_LOGIC_PLAN_FILL: {




1,143,067✔





2320



      SFillLogicNode* pLogicNode = (SFillLogicNode*)pNode;




1,143,067✔





2321



      destroyLogicNode((SLogicNode*)pLogicNode);




1,143,067✔





2322



      nodesDestroyNode(pLogicNode->pWStartTs);




1,143,067✔





2323



      nodesDestroyNode(pLogicNode->pValues);




1,143,067✔





2324



      nodesDestroyNode(pLogicNode->pTimeRange);




1,143,067✔





2325



      nodesDestroyNode(pLogicNode->pSurroundingTime);




1,143,067✔





2326



      nodesDestroyList(pLogicNode->pFillExprs);




1,143,067✔





2327



      nodesDestroyList(pLogicNode->pNotFillExprs);




1,143,067✔





2328



      nodesDestroyList(pLogicNode->pFillNullExprs);




1,143,067✔





2329



      break;




1,143,067✔





2330



    }










2331



    case QUERY_NODE_LOGIC_PLAN_SORT: {




189,210,480✔





2332



      SSortLogicNode* pLogicNode = (SSortLogicNode*)pNode;




189,210,480✔





2333



      destroyLogicNode((SLogicNode*)pLogicNode);




189,210,480✔





2334



      nodesDestroyList(pLogicNode->pSortKeys);




189,219,466✔





2335



      break;




189,220,448✔





2336



    }










2337



    case QUERY_NODE_LOGIC_PLAN_PARTITION: {




64,657,374✔





2338



      SPartitionLogicNode* pLogicNode = (SPartitionLogicNode*)pNode;




64,657,374✔





2339



      destroyLogicNode((SLogicNode*)pLogicNode);




64,657,374✔





2340



      nodesDestroyList(pLogicNode->pPartitionKeys);




64,660,431✔





2341



      nodesDestroyList(pLogicNode->pTags);




64,663,352✔





2342



      nodesDestroyNode(pLogicNode->pSubtable);




64,664,040✔





2343



      nodesDestroyList(pLogicNode->pAggFuncs);




64,664,292✔





2344



      break;




64,660,506✔





2345



    }










2346



    case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: {




12,009,506✔





2347



      SIndefRowsFuncLogicNode* pLogicNode = (SIndefRowsFuncLogicNode*)pNode;




12,009,506✔





2348



      destroyLogicNode((SLogicNode*)pLogicNode);




12,009,506✔





2349



      nodesDestroyList(pLogicNode->pFuncs);




12,009,506✔





2350



      break;




12,009,506✔





2351



    }










2352



    case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: {




7,588,688✔





2353



      SInterpFuncLogicNode* pLogicNode = (SInterpFuncLogicNode*)pNode;




7,588,688✔





2354



      destroyLogicNode((SLogicNode*)pLogicNode);




7,588,688✔





2355



      nodesDestroyList(pLogicNode->pFuncs);




7,588,688✔





2356



      nodesDestroyNode(pLogicNode->pTimeRange);




7,588,688✔





2357



      nodesDestroyNode(pLogicNode->pFillValues);




7,588,688✔





2358



      nodesDestroyNode(pLogicNode->pTimeSeries);




7,588,688✔





2359



      break;




7,588,688✔





2360



    }











UNCOV

2361



    case QUERY_NODE_LOGIC_PLAN_FORECAST_FUNC: {




×








UNCOV

2362



      SForecastFuncLogicNode* pLogicNode = (SForecastFuncLogicNode*)pNode;




×








UNCOV

2363



      destroyLogicNode((SLogicNode*)pLogicNode);




×








UNCOV

2364



      nodesDestroyList(pLogicNode->pFuncs);




×







2365



      break;




×







2366



    }










2367



    case QUERY_NODE_LOGIC_PLAN_ANALYSIS_FUNC: {




×







2368



      SGenericAnalysisLogicNode* pLogicNode = (SGenericAnalysisLogicNode*)pNode;




×







2369



      destroyLogicNode((SLogicNode*)pLogicNode);




×








UNCOV

2370



      nodesDestroyList(pLogicNode->pFuncs);




×







2371



      break;




×







2372



    }










2373



    case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: {




4,097,738✔





2374



      SGroupCacheLogicNode* pLogicNode = (SGroupCacheLogicNode*)pNode;




4,097,738✔





2375



      destroyLogicNode((SLogicNode*)pLogicNode);




4,097,738✔





2376



      nodesDestroyList(pLogicNode->pGroupCols);




4,097,738✔





2377



      break;




4,097,738✔





2378



    }










2379



    case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: {




17,996,802✔





2380



      SDynQueryCtrlLogicNode* pLogicNode = (SDynQueryCtrlLogicNode*)pNode;




17,996,802✔





2381



      destroyLogicNode((SLogicNode*)pLogicNode);




17,996,802✔





2382



      if (pLogicNode->qType == DYN_QTYPE_VTB_SCAN ||




17,996,802✔





2383



          pLogicNode->qType == DYN_QTYPE_VTB_AGG ||




11,015,590✔





2384



          pLogicNode->qType == DYN_QTYPE_VTB_INTERVAL ||




5,510,356✔





2385



          pLogicNode->qType == DYN_QTYPE_VTB_WINDOW ||




5,445,396✔





2386



          pLogicNode->qType == DYN_QTYPE_VTB_TS_SCAN) {




4,209,890✔





2387



        taosMemoryFreeClear(pLogicNode->vtbScan.pVgroupList);




13,899,064✔





2388



        nodesDestroyList(pLogicNode->vtbScan.pOrgVgIds);




13,899,064✔





2389



      }










2390



      break;




17,996,802✔





2391



    }










2392



    case QUERY_NODE_LOGIC_SUBPLAN: {




2,147,483,647✔





2393



      SLogicSubplan* pSubplan = (SLogicSubplan*)pNode;




2,147,483,647✔





2394



      nodesDestroyList(pSubplan->pChildren);




2,147,483,647✔





2395



      nodesDestroyNode((SNode*)pSubplan->pNode);




2,147,483,647✔





2396



      nodesClearList(pSubplan->pParents);




2,147,483,647✔





2397



      taosMemoryFreeClear(pSubplan->pVgroupList);




2,147,483,647✔





2398



      break;




2,147,483,647✔





2399



    }










2400



    case QUERY_NODE_LOGIC_PLAN:




1,061,235,267✔





2401



      nodesDestroyList(((SQueryLogicPlan*)pNode)->pTopSubplans);




1,061,235,267✔





2402



      break;




1,061,259,371✔





2403



    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:




95,011,081✔





2404



    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:










2405



    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:










2406



      destroyScanPhysiNode((SScanPhysiNode*)pNode);




95,011,081✔





2407



      break;




95,010,610✔





2408



    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN: {




8,928,010✔





2409



      SVirtualScanPhysiNode* pPhyNode = (SVirtualScanPhysiNode*)pNode;




8,928,010✔





2410



      destroyScanPhysiNode((SScanPhysiNode*)pNode);




8,928,010✔





2411



      nodesDestroyList(pPhyNode->pGroupTags);




8,928,010✔





2412



      nodesDestroyList(pPhyNode->pTargets);




8,928,010✔





2413



      nodesDestroyList(pPhyNode->pTags);




8,928,010✔





2414



      nodesDestroyNode(pPhyNode->pSubtable);




8,928,010✔





2415



      break;




8,928,010✔





2416



    }










2417



    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:




3,733,622✔





2418



    case QUERY_NODE_PHYSICAL_PLAN_HASH_EXTERNAL:










2419



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_EXTERNAL: {










2420



      SExternalWindowPhysiNode* pPhyNode = (SExternalWindowPhysiNode*)pNode;




3,733,622✔





2421



      nodesDestroyNode(pPhyNode->pSubquery);




3,733,622✔





2422



      nodesDestroyNode(pPhyNode->pTimeRange);




3,733,202✔





2423



      destroyExtWindowFillInfo(&pPhyNode->extFill);




3,733,622✔





2424



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




3,733,622✔





2425



      break;




3,733,622✔





2426



    }










2427



    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:




4,216,849✔





2428



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: {










2429



      SLastRowScanPhysiNode* pPhyNode = (SLastRowScanPhysiNode*)pNode;




4,216,849✔





2430



      destroyScanPhysiNode((SScanPhysiNode*)pNode);




4,216,849✔





2431



      nodesDestroyList(pPhyNode->pGroupTags);




4,216,815✔





2432



      nodesDestroyList(pPhyNode->pTargets);




4,216,815✔





2433



      taosArrayDestroy(pPhyNode->pFuncTypes);




4,216,876✔





2434



      break;




4,216,849✔





2435



    }










2436



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:




844,380,998✔





2437



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:










2438



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:










2439



    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: {










2440



      STableScanPhysiNode* pPhyNode = (STableScanPhysiNode*)pNode;




844,380,998✔





2441



      destroyScanPhysiNode((SScanPhysiNode*)pNode);




844,380,998✔





2442



      nodesDestroyList(pPhyNode->pDynamicScanFuncs);




844,381,952✔





2443



      nodesDestroyList(pPhyNode->pGroupTags);




844,416,814✔





2444



      nodesDestroyList(pPhyNode->pTags);




844,415,585✔





2445



      nodesDestroyNode(pPhyNode->pSubtable);




844,378,494✔





2446



      taosMemoryFreeClear(pPhyNode->pExtScanRange);




844,361,994✔





2447



      nodesDestroyNode(pPhyNode->pTimeRange);




844,360,145✔





2448



      nodesDestroyNode(pPhyNode->pExtTimeRange);




844,378,436✔





2449



      nodesDestroyNode(pPhyNode->pPrimaryCond);




844,395,735✔





2450



      break;




844,352,753✔





2451



    }










2452



    case QUERY_NODE_PHYSICAL_PLAN_PROJECT: {




463,502,838✔





2453



      SProjectPhysiNode* pPhyNode = (SProjectPhysiNode*)pNode;




463,502,838✔





2454



      destroyPhysiNode((SPhysiNode*)pPhyNode);




463,502,838✔





2455



      nodesDestroyList(pPhyNode->pProjections);




463,502,411✔





2456



      break;




463,488,583✔





2457



    }










2458



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: {




36,936,935✔





2459



      SSortMergeJoinPhysiNode* pPhyNode = (SSortMergeJoinPhysiNode*)pNode;




36,936,935✔





2460



      destroyPhysiNode((SPhysiNode*)pPhyNode);




36,936,935✔





2461



      nodesDestroyNode(pPhyNode->pWindowOffset);




36,937,044✔





2462



      nodesDestroyNode(pPhyNode->pJLimit);




36,937,457✔





2463



      nodesDestroyNode(pPhyNode->leftPrimExpr);




36,937,457✔





2464



      nodesDestroyNode(pPhyNode->rightPrimExpr);




36,936,910✔





2465



      nodesDestroyList(pPhyNode->pEqLeft);




36,936,910✔





2466



      nodesDestroyList(pPhyNode->pEqRight);




36,937,457✔





2467



      nodesDestroyNode(pPhyNode->pPrimKeyCond);




36,936,910✔





2468



      nodesDestroyNode(pPhyNode->pFullOnCond);




36,937,457✔





2469



      nodesDestroyList(pPhyNode->pTargets);




36,936,910✔





2470



      nodesDestroyNode(pPhyNode->pColEqCond);




36,936,910✔





2471



      nodesDestroyNode(pPhyNode->pColOnCond);




36,937,457✔





2472



      break;




36,936,910✔





2473



    }










2474



    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: {




3,326,082✔





2475



      SHashJoinPhysiNode* pPhyNode = (SHashJoinPhysiNode*)pNode;




3,326,082✔





2476



      destroyPhysiNode((SPhysiNode*)pPhyNode);




3,326,082✔





2477



      nodesDestroyNode(pPhyNode->pWindowOffset);




3,326,082✔





2478



      nodesDestroyNode(pPhyNode->pJLimit);




3,326,082✔





2479



      nodesDestroyList(pPhyNode->pOnLeft);




3,326,082✔





2480



      nodesDestroyList(pPhyNode->pOnRight);




3,326,082✔





2481



      nodesDestroyNode(pPhyNode->leftPrimExpr);




3,326,082✔





2482



      nodesDestroyNode(pPhyNode->rightPrimExpr);




3,326,082✔





2483



      nodesDestroyNode(pPhyNode->pLeftOnCond);




3,326,082✔





2484



      nodesDestroyNode(pPhyNode->pRightOnCond);




3,326,082✔





2485



      nodesDestroyNode(pPhyNode->pFullOnCond);




3,326,082✔





2486



      nodesDestroyList(pPhyNode->pTargets);




3,326,082✔





2487












2488



      nodesDestroyNode(pPhyNode->pPrimKeyCond);




3,326,082✔





2489



      nodesDestroyNode(pPhyNode->pColEqCond);




3,326,082✔





2490



      nodesDestroyNode(pPhyNode->pTagEqCond);




3,326,082✔





2491












2492



      break;




3,326,082✔





2493



    }










2494



    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: {




351,919,436✔





2495



      SAggPhysiNode* pPhyNode = (SAggPhysiNode*)pNode;




351,919,436✔





2496



      destroyPhysiNode((SPhysiNode*)pPhyNode);




351,919,436✔





2497



      nodesDestroyList(pPhyNode->pExprs);




351,913,497✔





2498



      nodesDestroyList(pPhyNode->pAggFuncs);




351,925,011✔





2499



      nodesDestroyList(pPhyNode->pGroupKeys);




351,919,303✔





2500



      break;




351,925,168✔





2501



    }










2502



    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: {




344,694,833✔





2503



      SExchangePhysiNode* pPhyNode = (SExchangePhysiNode*)pNode;




344,694,833✔





2504



      destroyPhysiNode((SPhysiNode*)pPhyNode);




344,694,833✔





2505



      nodesDestroyList(pPhyNode->pSrcEndPoints);




344,693,481✔





2506



      taosArrayDestroy(pPhyNode->childrenVgIds);




344,696,247✔





2507



      break;




344,695,306✔





2508



    }










2509



    case QUERY_NODE_PHYSICAL_PLAN_MERGE: {




50,788,178✔





2510



      SMergePhysiNode* pPhyNode = (SMergePhysiNode*)pNode;




50,788,178✔





2511



      destroyPhysiNode((SPhysiNode*)pPhyNode);




50,788,178✔





2512



      nodesDestroyList(pPhyNode->pMergeKeys);




50,788,636✔





2513



      nodesDestroyList(pPhyNode->pTargets);




50,788,374✔





2514



      break;




50,788,104✔





2515



    }










2516



    case QUERY_NODE_PHYSICAL_PLAN_SORT:




122,017,732✔





2517



    case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: {










2518



      SSortPhysiNode* pPhyNode = (SSortPhysiNode*)pNode;




122,017,732✔





2519



      destroyPhysiNode((SPhysiNode*)pPhyNode);




122,017,732✔





2520



      nodesDestroyList(pPhyNode->pExprs);




122,016,618✔





2521



      nodesDestroyList(pPhyNode->pSortKeys);




122,016,624✔





2522



      nodesDestroyList(pPhyNode->pTargets);




122,013,632✔





2523



      break;




122,019,220✔





2524



    }










2525



    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:




34,145,313✔





2526



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL:










2527



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL:










2528



      destroyWinodwPhysiNode((SWindowPhysiNode*)pNode);




34,145,313✔





2529



      break;




34,143,647✔





2530



    case QUERY_NODE_PHYSICAL_PLAN_FILL: {




1,217,151✔





2531



      SFillPhysiNode* pPhyNode = (SFillPhysiNode*)pNode;




1,217,151✔





2532



      destroyPhysiNode((SPhysiNode*)pPhyNode);




1,217,151✔





2533



      nodesDestroyList(pPhyNode->pFillExprs);




1,217,151✔





2534



      nodesDestroyList(pPhyNode->pNotFillExprs);




1,217,151✔





2535



      nodesDestroyNode(pPhyNode->pWStartTs);




1,217,151✔





2536



      nodesDestroyNode(pPhyNode->pValues);




1,217,151✔





2537



      nodesDestroyList(pPhyNode->pFillNullExprs);




1,217,151✔





2538



      nodesDestroyNode(pPhyNode->pTimeRange);




1,217,151✔





2539



      nodesDestroyNode(pPhyNode->pSurroundingTime);




1,217,151✔





2540



      break;




1,217,151✔





2541



    }










2542



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:




6,170,809✔





2543



      destroyWinodwPhysiNode((SWindowPhysiNode*)pNode);




6,170,809✔





2544



      break;




6,170,895✔





2545



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: {




5,507,296✔





2546



      SStateWindowPhysiNode* pPhyNode = (SStateWindowPhysiNode*)pNode;




5,507,296✔





2547



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




5,507,296✔





2548



      nodesDestroyNode(pPhyNode->pStateKey);




5,507,384✔





2549



      break;




5,507,384✔





2550



    }










2551



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: {




4,450,389✔





2552



      SEventWinodwPhysiNode* pPhyNode = (SEventWinodwPhysiNode*)pNode;




4,450,389✔





2553



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




4,450,389✔





2554



      nodesDestroyNode(pPhyNode->pStartCond);




4,450,315✔





2555



      nodesDestroyNode(pPhyNode->pEndCond);




4,449,965✔





2556



      break;




4,450,389✔





2557



    }










2558



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT: {




4,041,858✔





2559



      SCountWindowPhysiNode* pPhyNode = (SCountWindowPhysiNode*)pNode;




4,041,858✔





2560



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




4,041,858✔





2561



      break;




4,041,858✔





2562



    }











UNCOV

2563



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ANOMALY: {




×








UNCOV

2564



      SAnomalyWindowPhysiNode* pPhyNode = (SAnomalyWindowPhysiNode*)pNode;




×








UNCOV

2565



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




×








UNCOV

2566



      nodesDestroyList(pPhyNode->pAnomalyKeys);




×







2567



      break;




×







2568



    }










2569



    case QUERY_NODE_PHYSICAL_PLAN_PARTITION: {




23,230,305✔





2570



      destroyPartitionPhysiNode((SPartitionPhysiNode*)pNode);




23,230,305✔





2571



      break;




23,230,462✔





2572



    }










2573



    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: {




7,849,490✔





2574



      SIndefRowsFuncPhysiNode* pPhyNode = (SIndefRowsFuncPhysiNode*)pNode;




7,849,490✔





2575



      destroyPhysiNode((SPhysiNode*)pPhyNode);




7,849,490✔





2576



      nodesDestroyList(pPhyNode->pExprs);




7,849,490✔





2577



      nodesDestroyList(pPhyNode->pFuncs);




7,849,490✔





2578



      break;




7,849,490✔





2579



    }










2580



    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: {




7,473,832✔





2581



      SInterpFuncPhysiNode* pPhyNode = (SInterpFuncPhysiNode*)pNode;




7,473,832✔





2582



      destroyPhysiNode((SPhysiNode*)pPhyNode);




7,473,832✔





2583



      nodesDestroyList(pPhyNode->pExprs);




7,473,304✔





2584



      nodesDestroyList(pPhyNode->pFuncs);




7,473,832✔





2585



      nodesDestroyNode(pPhyNode->pTimeRange);




7,473,832✔





2586



      nodesDestroyNode(pPhyNode->pFillValues);




7,473,832✔





2587



      nodesDestroyNode(pPhyNode->pTimeSeries);




7,473,304✔





2588



      break;




7,473,832✔





2589



    }











UNCOV

2590



    case QUERY_NODE_PHYSICAL_PLAN_ANALYSIS_FUNC:




×







2591



    case QUERY_NODE_PHYSICAL_PLAN_FORECAST_FUNC: {











UNCOV

2592



      SForecastFuncPhysiNode* pPhyNode = (SForecastFuncPhysiNode*)pNode;




×








UNCOV

2593



      destroyPhysiNode((SPhysiNode*)pPhyNode);




×







2594



      nodesDestroyList(pPhyNode->pExprs);




×








UNCOV

2595



      nodesDestroyList(pPhyNode->pFuncs);




×







2596



      break;




×







2597



    }










2598



    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:




1,152,470,348✔





2599



      destroyDataSinkNode((SDataSinkNode*)pNode);




1,152,470,348✔





2600



      break;




1,152,436,714✔





2601



    case QUERY_NODE_PHYSICAL_PLAN_INSERT: {




700,401,157✔





2602



      SDataInserterNode* pSink = (SDataInserterNode*)pNode;




700,401,157✔





2603



      destroyDataSinkNode((SDataSinkNode*)pSink);




700,401,157✔





2604



      taosMemFreeClear(pSink->pData);




700,370,088✔





2605



      break;




700,391,940✔





2606



    }










2607



    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: {




1,010,104✔





2608



      SQueryInserterNode* pSink = (SQueryInserterNode*)pNode;




1,010,104✔





2609



      destroyDataSinkNode((SDataSinkNode*)pSink);




1,010,104✔





2610



      nodesDestroyList(pSink->pCols);




1,010,104✔





2611



      break;




1,010,104✔





2612



    }










2613



    case QUERY_NODE_PHYSICAL_PLAN_DELETE: {




3,777,734✔





2614



      SDataDeleterNode* pSink = (SDataDeleterNode*)pNode;




3,777,734✔





2615



      destroyDataSinkNode((SDataSinkNode*)pSink);




3,777,734✔





2616



      nodesDestroyNode(pSink->pAffectedRows);




3,777,734✔





2617



      nodesDestroyNode(pSink->pStartTs);




3,777,734✔





2618



      nodesDestroyNode(pSink->pEndTs);




3,777,734✔





2619



      break;




3,777,734✔





2620



    }










2621



    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: {




3,324,446✔





2622



      SGroupCachePhysiNode* pPhyNode = (SGroupCachePhysiNode*)pNode;




3,324,446✔





2623



      destroyPhysiNode((SPhysiNode*)pPhyNode);




3,324,446✔





2624



      nodesDestroyList(pPhyNode->pGroupCols);




3,324,446✔





2625



      break;




3,324,446✔





2626



    }










2627



    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: {




10,543,417✔





2628



      SDynQueryCtrlPhysiNode* pPhyNode = (SDynQueryCtrlPhysiNode*)pNode;




10,543,417✔





2629



      if (pPhyNode->qType == DYN_QTYPE_VTB_SCAN || pPhyNode->qType == DYN_QTYPE_VTB_TS_SCAN ||




10,543,417✔





2630



          pPhyNode->qType == DYN_QTYPE_VTB_AGG || pPhyNode->qType == DYN_QTYPE_VTB_INTERVAL ||




6,882,377✔





2631



          pPhyNode->qType == DYN_QTYPE_VTB_WINDOW) {




4,483,275✔





2632



        nodesDestroyList(pPhyNode->vtbScan.pScanCols);




7,218,971✔





2633



        nodesDestroyList(pPhyNode->vtbScan.pOrgVgIds);




7,218,971✔





2634



      }










2635



      if (pPhyNode->qType == DYN_QTYPE_VTB_WINDOW) {




10,543,417✔





2636



        nodesDestroyList(pPhyNode->vtbWindow.pTargets);




1,158,829✔





2637



      }










2638



      destroyPhysiNode((SPhysiNode*)pPhyNode);




10,543,417✔





2639



      break;




10,543,417✔





2640



    }










2641



    case QUERY_NODE_PHYSICAL_SUBPLAN: {




1,858,136,065✔





2642



      SSubplan* pSubplan = (SSubplan*)pNode;




1,858,136,065✔





2643



      SNode*    pTmp = NULL;




1,858,136,065✔





2644



      WHERE_EACH(pTmp, pSubplan->pChildren) {




2,147,483,647✔





2645



        if (QUERY_NODE_VALUE == nodeType(pTmp)) {




385,362,314✔





2646



          ERASE_NODE(pSubplan->pChildren);




1,828,664✔





2647



          continue;




1,828,664✔





2648



        }










2649



        WHERE_NEXT;




383,533,650✔





2650



      }










2651



      nodesClearList(pSubplan->pChildren);




1,858,095,477✔





2652



      nodesDestroyNode((SNode*)pSubplan->pNode);




1,857,991,341✔





2653



      nodesDestroyNode((SNode*)pSubplan->pDataSink);




1,858,057,436✔





2654



      nodesDestroyList(pSubplan->pSubQ);




1,858,067,091✔





2655



      nodesDestroyNode((SNode*)pSubplan->pTagCond);




1,858,066,337✔





2656



      nodesDestroyNode((SNode*)pSubplan->pTagIndexCond);




1,858,058,260✔





2657



      tSimpleHashCleanup(pSubplan->pVTables);




1,858,049,304✔





2658



      nodesClearList(pSubplan->pParents);




1,858,048,807✔





2659



      break;




1,858,088,973✔





2660



    }










2661



    case QUERY_NODE_PHYSICAL_PLAN:




1,062,369,036✔





2662



      nodesDestroyList(((SQueryPlan*)pNode)->pSubplans);




1,062,369,036✔





2663



      nodesDestroyList(((SQueryPlan*)pNode)->pChildren);




1,062,355,209✔





2664



      break;




1,062,373,790✔





2665



    case QUERY_NODE_XNODE_TASK_SOURCE_OPT:




4,655✔





2666



      xFreeTaskSource(&((SXTaskSource*)pNode)->source);




4,655✔





2667



      break;




4,655✔





2668



    case QUERY_NODE_XNODE_TASK_SINK_OPT:




4,788✔





2669



      xFreeTaskSink(&((SXTaskSink*)pNode)->sink);




4,788✔





2670



      break;




4,788✔





2671



    case QUERY_NODE_XNODE_TASK_OPTIONS: {




20,083✔





2672



      // xFreeTaskOptions(&((SXnodeTaskOptions*)pNode)->opts);










2673



      SXnodeTaskOptions* pOptions = (SXnodeTaskOptions*)pNode;




20,083✔





2674



      taosMemFreeClear(pOptions->parser);




20,083✔





2675



      for (int32_t i = 0; i < pOptions->optionsNum; ++i) {




62,244✔





2676



        taosMemFreeClear(pOptions->options[i]);




42,161✔





2677



      }










2678



      break;




20,083✔





2679



    }










2680



    case QUERY_NODE_ALTER_XNODE_STMT: {




931✔





2681



      SAlterXnodeStmt* pStmt = (SAlterXnodeStmt*)pNode;




931✔





2682



      xFreeCowStr(&pStmt->url);




931✔





2683



      xFreeCowStr(&pStmt->token);




931✔





2684



      xFreeCowStr(&pStmt->user);




931✔





2685



      xFreeCowStr(&pStmt->pass);




931✔





2686



      nodesDestroyNode((SNode*)pStmt->options);




931✔





2687



      break;




931✔





2688



    }










2689



    case QUERY_NODE_CREATE_XNODE_TASK_STMT: {




4,522✔





2690



      SCreateXnodeTaskStmt* pStmt = (SCreateXnodeTaskStmt*)pNode;




4,522✔





2691



      nodesDestroyNode((SNode*)pStmt->source);




4,522✔





2692



      nodesDestroyNode((SNode*)pStmt->sink);




4,522✔





2693



      nodesDestroyNode((SNode*)pStmt->options);




4,522✔





2694



      break;




4,522✔





2695



    }










2696



    case QUERY_NODE_START_XNODE_TASK_STMT: {




133✔





2697



      SStartXnodeTaskStmt* pStmt = (SStartXnodeTaskStmt*)pNode;




133✔





2698



      xFreeCowStr(&pStmt->name);




133✔





2699



      break;




133✔





2700



    }










2701



    case QUERY_NODE_STOP_XNODE_TASK_STMT: {




133✔





2702



      SStopXnodeTaskStmt* pStmt = (SStopXnodeTaskStmt*)pNode;




133✔





2703



      xFreeCowStr(&pStmt->name);




133✔





2704



      break;




133✔





2705



    }










2706



    case QUERY_NODE_DROP_XNODE_TASK_STMT: {




3,591✔





2707



      SDropXnodeTaskStmt* pStmt = (SDropXnodeTaskStmt*)pNode;




3,591✔





2708



      taosMemFreeClear(pStmt->name);




3,591✔





2709



      break;




3,591✔





2710



    }










2711



    case QUERY_NODE_CREATE_XNODE_JOB_STMT: {




11,571✔





2712



      SCreateXnodeJobStmt* pStmt = (SCreateXnodeJobStmt*)pNode;




11,571✔





2713



      nodesDestroyNode((SNode*)pStmt->options);




11,571✔





2714



      break;




11,571✔





2715



    }










2716



    case QUERY_NODE_ALTER_XNODE_JOB_STMT: {




133✔





2717



      SAlterXnodeJobStmt* pStmt = (SAlterXnodeJobStmt*)pNode;




133✔





2718



      nodesDestroyNode((SNode*)pStmt->options);




133✔





2719



      break;




133✔





2720



    }










2721



    case QUERY_NODE_UPDATE_XNODE_TASK_STMT: {




532✔





2722



      SUpdateXnodeTaskStmt* pStmt = (SUpdateXnodeTaskStmt*)pNode;




532✔





2723



      nodesDestroyNode((SNode*)pStmt->source);




532✔





2724



      nodesDestroyNode((SNode*)pStmt->sink);




532✔





2725



      nodesDestroyNode((SNode*)pStmt->options);




532✔





2726



      xFreeCowStr(&pStmt->name);




532✔





2727



      break;




532✔





2728



    }










2729



    case QUERY_NODE_REBALANCE_XNODE_JOB_STMT: {




266✔





2730



      SRebalanceXnodeJobStmt* pStmt = (SRebalanceXnodeJobStmt*)pNode;




266✔





2731



      nodesDestroyNode((SNode*)pStmt->options);




266✔





2732



      break;




266✔





2733



    }










2734



    case QUERY_NODE_REBALANCE_XNODE_JOB_WHERE_STMT: {




798✔





2735



      SRebalanceXnodeJobWhereStmt* pStmt = (SRebalanceXnodeJobWhereStmt*)pNode;




798✔





2736



      nodesDestroyNode((SNode*)pStmt->pWhere);




798✔





2737



      break;




798✔





2738



    }










2739



    case QUERY_NODE_DROP_XNODE_JOB_STMT: {




21,812✔





2740



      SDropXnodeJobStmt* pStmt = (SDropXnodeJobStmt*)pNode;




21,812✔





2741



      nodesDestroyNode((SNode*)pStmt->options);




21,812✔





2742



      nodesDestroyNode((SNode*)pStmt->pWhere);




21,812✔





2743



      break;




21,812✔





2744



    }










2745



    case QUERY_NODE_CREATE_XNODE_AGENT_STMT: {




2,527✔





2746



      SCreateXnodeAgentStmt* pStmt = (SCreateXnodeAgentStmt*)pNode;




2,527✔





2747



      nodesDestroyNode((SNode*)pStmt->options);




2,527✔





2748



      break;




2,527✔





2749



    }










2750



    case QUERY_NODE_ALTER_XNODE_AGENT_STMT: {




399✔





2751



      SAlterXnodeAgentStmt* pStmt = (SAlterXnodeAgentStmt*)pNode;




399✔





2752



      xFreeCowStr(&pStmt->name);




399✔





2753



      nodesDestroyNode((SNode*)pStmt->options);




399✔





2754



      break;




399✔





2755



    }










2756



    case QUERY_NODE_DROP_XNODE_AGENT_STMT: {




1,665✔





2757



      SDropXnodeAgentStmt* pStmt = (SDropXnodeAgentStmt*)pNode;




1,665✔





2758



      taosMemFreeClear(pStmt->name);




1,665✔





2759



      break;




2,660✔





2760



    }










2761



    default:




95,045✔





2762



      break;




95,045✔





2763



  }










2764



  nodesFree(pNode);




2,147,483,647✔





2765



  return;




2,147,483,647✔





2766



}










2767












2768



int32_t nodesMakeList(SNodeList** ppListOut) {




2,147,483,647✔





2769



  SNodeList* p = NULL;




2,147,483,647✔





2770



  int32_t    code = nodesCalloc(1, sizeof(SNodeList), (void**)&p);




2,147,483,647✔





2771



  if (TSDB_CODE_SUCCESS == code) {




2,147,483,647✔





2772



    *ppListOut = p;




2,147,483,647✔





2773



  }










2774



  return code;




2,147,483,647✔





2775



}










2776












2777



int32_t nodesListAppend(SNodeList* pList, SNode* pNode) {




2,147,483,647✔





2778



  if (NULL == pList || NULL == pNode) {




2,147,483,647✔






UNCOV

2779



    return TSDB_CODE_INVALID_PARA;




×







2780



  }










2781



  SListCell* p = NULL;




2,147,483,647✔





2782



  int32_t    code = nodesCalloc(1, sizeof(SListCell), (void**)&p);




2,147,483,647✔





2783



  if (TSDB_CODE_SUCCESS != code) {




2,147,483,647✔






UNCOV

2784



    return code;




×







2785



  }










2786



  p->pNode = pNode;




2,147,483,647✔





2787



  if (NULL == pList->pHead) {




2,147,483,647✔





2788



    pList->pHead = p;




2,147,483,647✔





2789



  }










2790



  if (NULL != pList->pTail) {




2,147,483,647✔





2791



    pList->pTail->pNext = p;




2,147,483,647✔





2792



  }










2793



  p->pPrev = pList->pTail;




2,147,483,647✔





2794



  pList->pTail = p;




2,147,483,647✔





2795



  ++(pList->length);




2,147,483,647✔





2796



  return TSDB_CODE_SUCCESS;




2,147,483,647✔





2797



}










2798












2799



int32_t nodesListStrictAppend(SNodeList* pList, SNode* pNode) {




2,147,483,647✔





2800



  if (NULL == pNode) {




2,147,483,647✔






UNCOV

2801



    return TSDB_CODE_INVALID_PARA;




×







2802



  }










2803



  int32_t code = nodesListAppend(pList, pNode);




2,147,483,647✔





2804



  if (TSDB_CODE_SUCCESS != code) {




2,147,483,647✔





2805



    nodesDestroyNode(pNode);




×







2806



  }










2807



  return code;




2,147,483,647✔





2808



}










2809












2810



int32_t nodesListMakeAppend(SNodeList** pList, SNode* pNode) {




2,147,483,647✔





2811



  if (NULL == *pList) {




2,147,483,647✔





2812



    int32_t code = nodesMakeList(pList);




1,542,921,082✔





2813



    if (NULL == *pList) {




1,542,942,083✔






UNCOV

2814



      return code;




×







2815



    }










2816



  }










2817



  return nodesListAppend(*pList, pNode);




2,147,483,647✔





2818



}










2819












2820



int32_t nodesListMakeStrictAppend(SNodeList** pList, SNode* pNode) {




2,147,483,647✔





2821



  if (NULL == *pList) {




2,147,483,647✔





2822



    int32_t code = nodesMakeList(pList);




2,147,483,647✔





2823



    if (NULL == *pList) {




2,147,483,647✔






UNCOV

2824



      nodesDestroyNode(pNode);




×








UNCOV

2825



      return code;




×







2826



    }










2827



  }










2828



  return nodesListStrictAppend(*pList, pNode);




2,147,483,647✔





2829



}










2830












2831



int32_t nodesListAppendList(SNodeList* pTarget, SNodeList* pSrc) {




34,098,497✔





2832



  if (NULL == pTarget || NULL == pSrc) {




34,098,497✔






UNCOV

2833



    return TSDB_CODE_FAILED;




×







2834



  }










2835












2836



  if (NULL == pTarget->pHead) {




34,098,497✔





2837



    pTarget->pHead = pSrc->pHead;




28,892,133✔





2838



  } else {










2839



    pTarget->pTail->pNext = pSrc->pHead;




5,206,364✔





2840



    if (NULL != pSrc->pHead) {




5,206,364✔





2841



      pSrc->pHead->pPrev = pTarget->pTail;




5,206,364✔





2842



    }










2843



  }










2844



  pTarget->pTail = pSrc->pTail;




34,098,497✔





2845



  pTarget->length += pSrc->length;




34,098,497✔





2846



  nodesFree(pSrc);




34,098,497✔





2847












2848



  return TSDB_CODE_SUCCESS;




34,098,497✔





2849



}










2850












2851



int32_t nodesListStrictAppendList(SNodeList* pTarget, SNodeList* pSrc) {




2,331,805✔





2852



  if (NULL == pSrc) {




2,331,805✔






UNCOV

2853



    return TSDB_CODE_OUT_OF_MEMORY;




×







2854



  }










2855



  int32_t code = nodesListAppendList(pTarget, pSrc);




2,331,805✔





2856



  if (TSDB_CODE_SUCCESS != code) {




2,331,805✔





2857



    nodesDestroyList(pSrc);




×







2858



  }










2859



  return code;




2,331,805✔





2860



}










2861












2862



int32_t nodesListMakeStrictAppendList(SNodeList** pTarget, SNodeList* pSrc) {




282,936✔





2863



  if (NULL == *pTarget) {




282,936✔





2864



    int32_t code = nodesMakeList(pTarget);




224,590✔





2865



    if (NULL == *pTarget) {




224,590✔






UNCOV

2866



      return code;




×







2867



    }










2868



  }










2869



  return nodesListStrictAppendList(*pTarget, pSrc);




282,936✔





2870



}










2871












2872



int32_t nodesListMakePushFront(SNodeList** pList, SNode* pNode) {




5,443,243✔





2873



  if (*pList == NULL) {




5,443,243✔





2874



    int32_t code = nodesMakeList(pList);




5,004,933✔





2875



    if (*pList == NULL) {




5,005,471✔






UNCOV

2876



      return code;




×







2877



    }










2878



  }










2879



  return nodesListPushFront(*pList, pNode);




5,443,781✔





2880



}










2881












2882



int32_t nodesListPushFront(SNodeList* pList, SNode* pNode) {




5,932,459✔





2883



  if (NULL == pList || NULL == pNode) {




5,932,459✔






UNCOV

2884



    return TSDB_CODE_FAILED;




×







2885



  }










2886



  SListCell* p = NULL;




5,932,681✔





2887



  int32_t    code = nodesCalloc(1, sizeof(SListCell), (void**)&p);




5,932,681✔





2888



  if (TSDB_CODE_SUCCESS != code) {




5,933,723✔






UNCOV

2889



    return code;




×







2890



  }










2891



  p->pNode = pNode;




5,933,723✔





2892



  if (NULL != pList->pHead) {




5,933,723✔





2893



    pList->pHead->pPrev = p;




443,220✔





2894



    p->pNext = pList->pHead;




443,220✔





2895



  }










2896



  pList->pHead = p;




5,933,723✔





2897



  pList->pTail = pList->pTail ? pList->pTail : p;




5,933,723✔





2898



  ++(pList->length);




5,933,723✔





2899



  return TSDB_CODE_SUCCESS;




5,933,723✔





2900



}










2901












2902



// remove current node from the list and return next node










2903



SListCell* nodesListErase(SNodeList* pList, SListCell* pCell) {




2,147,483,647✔





2904



  if (NULL == pCell->pPrev) {




2,147,483,647✔





2905



    pList->pHead = pCell->pNext;




2,147,483,647✔





2906



  } else {










2907



    pCell->pPrev->pNext = pCell->pNext;




246,656,738✔





2908



  }










2909



  if (NULL == pCell->pNext) {




2,147,483,647✔





2910



    pList->pTail = pCell->pPrev;




2,147,483,647✔





2911



  } else {










2912



    pCell->pNext->pPrev = pCell->pPrev;




2,147,483,647✔





2913



  }










2914



  SListCell* pNext = pCell->pNext;




2,147,483,647✔





2915



  nodesDestroyNode(pCell->pNode);




2,147,483,647✔





2916



  nodesFree(pCell);




2,147,483,647✔





2917



  --(pList->length);




2,147,483,647✔





2918



  return pNext;




2,147,483,647✔





2919



}










2920












2921



void nodesListInsertList(SNodeList* pTarget, SListCell* pPos, SNodeList* pSrc) {




58,485,815✔





2922



  if (NULL == pTarget || NULL == pPos || NULL == pSrc || NULL == pSrc->pHead) {




58,485,815✔





2923



    return;




16,221✔





2924



  }










2925












2926



  if (NULL == pPos->pPrev) {




58,471,707✔





2927



    pTarget->pHead = pSrc->pHead;




50,933,836✔





2928



  } else {










2929



    pPos->pPrev->pNext = pSrc->pHead;




7,537,832✔





2930



  }










2931



  pSrc->pHead->pPrev = pPos->pPrev;




58,471,619✔





2932



  pSrc->pTail->pNext = pPos;




58,471,745✔





2933



  pPos->pPrev = pSrc->pTail;




58,471,558✔





2934












2935



  pTarget->length += pSrc->length;




58,471,555✔





2936



  nodesFree(pSrc);




58,471,697✔





2937



}










2938












2939



void nodesListInsertListAfterPos(SNodeList* pTarget, SListCell* pPos, SNodeList* pSrc) {




4,475✔





2940



  if (NULL == pTarget || NULL == pPos || NULL == pSrc || NULL == pSrc->pHead) {




4,475✔






UNCOV

2941



    return;




×







2942



  }










2943












2944



  if (NULL == pPos->pNext) {




4,475✔





2945



    pTarget->pTail = pSrc->pHead;




4,475✔





2946



  } else {











UNCOV

2947



    pPos->pNext->pPrev = pSrc->pHead;




×







2948



  }










2949












2950



  pSrc->pHead->pPrev = pPos;




4,475✔





2951



  pSrc->pTail->pNext = pPos->pNext;




4,475✔





2952












2953



  pPos->pNext = pSrc->pHead;




4,475✔





2954












2955



  pTarget->length += pSrc->length;




4,475✔





2956



  nodesFree(pSrc);




4,475✔





2957



}










2958












2959



SNode* nodesListGetNode(SNodeList* pList, int32_t index) {




2,147,483,647✔





2960



  SNode* node;










2961



  FOREACH(node, pList) {




2,147,483,647✔





2962



    if (0 == index--) {




2,147,483,647✔





2963



      return node;




2,147,483,647✔





2964



    }










2965



  }










2966



  return NULL;




196,130,357✔





2967



}










2968












2969












2970



SListCell* nodesListGetCell(SNodeList* pList, int32_t index) {




30,633,657✔





2971



  SNode* node;










2972



  FOREACH(node, pList) {




866,980,414✔





2973



    if (0 == index--) {




866,979,970✔





2974



      return cell;




30,633,213✔





2975



    }










2976



  }











UNCOV

2977



  return NULL;




×







2978



}










2979












2980



void nodesDestroyList(SNodeList* pList) {




2,147,483,647✔





2981



  if (NULL == pList) {




2,147,483,647✔





2982



    return;




2,147,483,647✔





2983



  }










2984












2985



  SListCell* pNext = pList->pHead;




2,147,483,647✔





2986



  while (NULL != pNext) {




2,147,483,647✔





2987



    pNext = nodesListErase(pList, pNext);




2,147,483,647✔





2988



  }










2989



  nodesFree(pList);




2,147,483,647✔





2990



}










2991












2992



void nodesClearList(SNodeList* pList) {




2,147,483,647✔





2993



  if (NULL == pList) {




2,147,483,647✔





2994



    return;




2,147,483,647✔





2995



  }










2996












2997



  SListCell* pNext = pList->pHead;




2,147,483,647✔





2998



  while (NULL != pNext) {




2,147,483,647✔





2999



    SListCell* tmp = pNext;




2,147,483,647✔





3000



    pNext = pNext->pNext;




2,147,483,647✔





3001



    nodesFree(tmp);




2,147,483,647✔





3002



  }










3003



  nodesFree(pList);




2,147,483,647✔





3004



}










3005












3006



void* nodesGetValueFromNode(SValueNode* pNode) {




1,319,779,538✔





3007



  switch (pNode->node.resType.type) {




1,319,779,538✔





3008



    case TSDB_DATA_TYPE_BOOL:




1,222,235,314✔





3009



    case TSDB_DATA_TYPE_TINYINT:










3010



    case TSDB_DATA_TYPE_SMALLINT:










3011



    case TSDB_DATA_TYPE_INT:










3012



    case TSDB_DATA_TYPE_BIGINT:










3013



    case TSDB_DATA_TYPE_TIMESTAMP:










3014



    case TSDB_DATA_TYPE_UTINYINT:










3015



    case TSDB_DATA_TYPE_USMALLINT:










3016



    case TSDB_DATA_TYPE_UINT:










3017



    case TSDB_DATA_TYPE_UBIGINT:










3018



    case TSDB_DATA_TYPE_FLOAT:










3019



    case TSDB_DATA_TYPE_DOUBLE:










3020



    case TSDB_DATA_TYPE_DECIMAL64:










3021



      return (void*)&pNode->typeData;




1,222,235,314✔





3022



    case TSDB_DATA_TYPE_NCHAR:




97,626,296✔





3023



    case TSDB_DATA_TYPE_VARCHAR:










3024



    case TSDB_DATA_TYPE_VARBINARY:










3025



    case TSDB_DATA_TYPE_BLOB:










3026



    case TSDB_DATA_TYPE_MEDIUMBLOB:










3027



    case TSDB_DATA_TYPE_JSON:










3028



    case TSDB_DATA_TYPE_GEOMETRY:










3029



    case TSDB_DATA_TYPE_DECIMAL:










3030



      return (void*)pNode->datum.p;




97,626,296✔





3031



    default:




214✔





3032



      break;




214✔





3033



  }










3034












3035



  return NULL;




214✔





3036



}










3037












3038



int32_t nodesSetValueNodeValue(SValueNode* pNode, void* value) {




434,079,968✔





3039



  switch (pNode->node.resType.type) {




434,079,968✔





3040



    case TSDB_DATA_TYPE_NULL:




2,072✔





3041



      break;




2,072✔





3042



    case TSDB_DATA_TYPE_BOOL:




18,951,516✔





3043



      pNode->datum.b = *(bool*)value;




18,951,516✔





3044



      *(bool*)&pNode->typeData = pNode->datum.b;




18,950,072✔





3045



      break;




18,949,430✔





3046



    case TSDB_DATA_TYPE_TINYINT:




88,789✔





3047



      pNode->datum.i = *(int8_t*)value;




88,789✔





3048



      *(int8_t*)&pNode->typeData = pNode->datum.i;




88,789✔





3049



      break;




88,789✔





3050



    case TSDB_DATA_TYPE_SMALLINT:




150,639✔





3051



      pNode->datum.i = *(int16_t*)value;




150,639✔





3052



      *(int16_t*)&pNode->typeData = pNode->datum.i;




150,639✔





3053



      break;




150,639✔





3054



    case TSDB_DATA_TYPE_INT:




34,293,544✔





3055



      pNode->datum.i = *(int32_t*)value;




34,293,544✔





3056



      *(int32_t*)&pNode->typeData = pNode->datum.i;




34,294,994✔





3057



      break;




34,299,736✔





3058



    case TSDB_DATA_TYPE_BIGINT:




43,685,165✔





3059



      pNode->datum.i = *(int64_t*)value;




43,685,165✔





3060



      *(int64_t*)&pNode->typeData = pNode->datum.i;




43,685,165✔





3061



      break;




43,685,165✔





3062



    case TSDB_DATA_TYPE_TIMESTAMP:




333,029,968✔





3063



      pNode->datum.i = *(int64_t*)value;




333,029,968✔





3064



      *(int64_t*)&pNode->typeData = pNode->datum.i;




333,091,667✔





3065



      break;




333,091,211✔





3066



    case TSDB_DATA_TYPE_UTINYINT:




35,117✔





3067



      pNode->datum.u = *(int8_t*)value;




35,117✔





3068



      *(int8_t*)&pNode->typeData = pNode->datum.u;




35,117✔





3069



      break;




35,117✔





3070



    case TSDB_DATA_TYPE_USMALLINT:




18,307✔





3071



      pNode->datum.u = *(int16_t*)value;




18,307✔





3072



      *(int16_t*)&pNode->typeData = pNode->datum.u;




18,307✔





3073



      break;




18,307✔





3074



    case TSDB_DATA_TYPE_UINT:




31,468✔





3075



      pNode->datum.u = *(int32_t*)value;




31,468✔





3076



      *(int32_t*)&pNode->typeData = pNode->datum.u;




31,468✔





3077



      break;




31,468✔





3078



    case TSDB_DATA_TYPE_UBIGINT:




20,483✔





3079



      pNode->datum.u = *(uint64_t*)value;




20,483✔





3080



      *(uint64_t*)&pNode->typeData = pNode->datum.u;




20,483✔





3081



      break;




20,483✔





3082



    case TSDB_DATA_TYPE_FLOAT:




154,481✔





3083



      pNode->datum.d = *(float*)value;




154,481✔





3084



      *(float*)&pNode->typeData = pNode->datum.d;




154,481✔





3085



      break;




154,481✔





3086



    case TSDB_DATA_TYPE_DOUBLE:




3,587,593✔





3087



      pNode->datum.d = *(double*)value;




3,587,593✔





3088



      *(double*)&pNode->typeData = pNode->datum.d;




3,587,593✔





3089



      break;




3,587,593✔






UNCOV

3090



    case TSDB_DATA_TYPE_NCHAR:




×







3091



    case TSDB_DATA_TYPE_VARCHAR:










3092



    case TSDB_DATA_TYPE_VARBINARY:










3093



    case TSDB_DATA_TYPE_JSON:










3094



    case TSDB_DATA_TYPE_BLOB:










3095



    case TSDB_DATA_TYPE_MEDIUMBLOB:










3096



    case TSDB_DATA_TYPE_GEOMETRY:











UNCOV

3097



      pNode->datum.p = (char*)value;




×








UNCOV

3098



      break;




×







3099



    case TSDB_DATA_TYPE_DECIMAL64:




15,720✔





3100



      pNode->datum.i = *(int64_t*)value;




15,720✔





3101



      pNode->typeData = *(int64_t*)value;




15,720✔





3102



      break;




15,720✔






UNCOV

3103



    case TSDB_DATA_TYPE_DECIMAL:




×








UNCOV

3104



      pNode->datum.p = (char*)value;




×







3105



      break;




34✔






UNCOV

3106



    default:




×







3107



      return TSDB_CODE_APP_ERROR;




×







3108



  }










3109












3110



  return TSDB_CODE_SUCCESS;




434,114,789✔





3111



}










3112












3113












3114



int32_t nodesSetValueNodeValueExt(SValueNode* pNode, void* value, bool* needFree) {




14,586,096✔





3115



  *needFree = true;




14,586,096✔





3116












3117



  switch (pNode->node.resType.type) {




14,586,096✔






UNCOV

3118



    case TSDB_DATA_TYPE_NULL:




×








UNCOV

3119



      break;




×







3120



    case TSDB_DATA_TYPE_BOOL:




663,936✔





3121



      pNode->datum.b = *(bool*)value;




663,936✔





3122



      *(bool*)&pNode->typeData = pNode->datum.b;




663,936✔





3123



      break;




663,936✔





3124



    case TSDB_DATA_TYPE_TINYINT:




663,936✔





3125



      pNode->datum.i = *(int8_t*)value;




663,936✔





3126



      *(int8_t*)&pNode->typeData = pNode->datum.i;




663,936✔





3127



      break;




663,936✔





3128



    case TSDB_DATA_TYPE_SMALLINT:




663,936✔





3129



      pNode->datum.i = *(int16_t*)value;




663,936✔





3130



      *(int16_t*)&pNode->typeData = pNode->datum.i;




663,936✔





3131



      break;




663,936✔





3132



    case TSDB_DATA_TYPE_INT:




1,294,956✔





3133



      pNode->datum.i = *(int32_t*)value;




1,294,956✔





3134



      *(int32_t*)&pNode->typeData = pNode->datum.i;




1,294,388✔





3135



      break;




1,294,956✔





3136



    case TSDB_DATA_TYPE_BIGINT:




2,962,422✔





3137



      pNode->datum.i = *(int64_t*)value;




2,962,422✔





3138



      *(int64_t*)&pNode->typeData = pNode->datum.i;




2,962,990✔





3139



      break;




2,961,858✔





3140



    case TSDB_DATA_TYPE_TIMESTAMP:




1,390,419✔





3141



      pNode->datum.i = *(int64_t*)value;




1,390,419✔





3142



      *(int64_t*)&pNode->typeData = pNode->datum.i;




1,390,419✔





3143



      break;




1,390,419✔





3144



    case TSDB_DATA_TYPE_UTINYINT:




663,936✔





3145



      pNode->datum.u = *(int8_t*)value;




663,936✔





3146



      *(int8_t*)&pNode->typeData = pNode->datum.u;




663,936✔





3147



      break;




663,936✔





3148



    case TSDB_DATA_TYPE_USMALLINT:




663,936✔





3149



      pNode->datum.u = *(int16_t*)value;




663,936✔





3150



      *(int16_t*)&pNode->typeData = pNode->datum.u;




663,936✔





3151



      break;




663,936✔





3152



    case TSDB_DATA_TYPE_UINT:




663,936✔





3153



      pNode->datum.u = *(int32_t*)value;




663,936✔





3154



      *(int32_t*)&pNode->typeData = pNode->datum.u;




663,936✔





3155



      break;




663,936✔





3156



    case TSDB_DATA_TYPE_UBIGINT:




665,194✔





3157



      pNode->datum.u = *(uint64_t*)value;




665,194✔





3158



      *(uint64_t*)&pNode->typeData = pNode->datum.u;




665,194✔





3159



      break;




665,194✔





3160



    case TSDB_DATA_TYPE_FLOAT:




663,936✔





3161



      pNode->datum.d = *(float*)value;




663,936✔





3162



      *(float*)&pNode->typeData = pNode->datum.d;




663,936✔





3163



      break;




663,936✔





3164



    case TSDB_DATA_TYPE_DOUBLE:




969,241✔





3165



      pNode->datum.d = *(double*)value;




969,241✔





3166



      *(double*)&pNode->typeData = pNode->datum.d;




969,241✔





3167



      break;




969,241✔





3168



    case TSDB_DATA_TYPE_NCHAR:




1,991,808✔





3169



    case TSDB_DATA_TYPE_VARCHAR:










3170



    case TSDB_DATA_TYPE_VARBINARY:










3171



    case TSDB_DATA_TYPE_JSON:










3172



    case TSDB_DATA_TYPE_BLOB:










3173



    case TSDB_DATA_TYPE_MEDIUMBLOB:










3174



    case TSDB_DATA_TYPE_GEOMETRY:










3175



      pNode->datum.p = (char*)value;




1,991,808✔





3176



      *needFree = false;




1,991,808✔





3177



      break;




1,991,808✔





3178



    case TSDB_DATA_TYPE_DECIMAL64:




663,936✔





3179



      pNode->datum.i = *(int64_t*)value;




663,936✔





3180



      pNode->typeData = *(int64_t*)value;




663,936✔





3181



      break;




663,936✔






UNCOV

3182



    case TSDB_DATA_TYPE_DECIMAL:




×








UNCOV

3183



      pNode->datum.p = (char*)value;




×








UNCOV

3184



      *needFree = false;




×







3185



      break;




564✔





3186



    default:




×







3187



      return TSDB_CODE_APP_ERROR;




×







3188



  }










3189












3190



  return TSDB_CODE_SUCCESS;




14,585,528✔





3191



}










3192












3193












3194



char* nodesGetStrValueFromNode(SValueNode* pNode) {




5,579,137✔





3195



  switch (pNode->node.resType.type) {




5,579,137✔





3196



    case TSDB_DATA_TYPE_NULL: {




2,264✔





3197



      return tstrdup("NULL");




2,264✔





3198



    }










3199



    case TSDB_DATA_TYPE_BOOL: {




10,396✔





3200



      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);




10,396✔





3201



      if (NULL == buf) {




10,396✔






UNCOV

3202



        return NULL;




×







3203



      }










3204












3205



      snprintf(buf, MAX_NUM_STR_SIZE, "%s", pNode->datum.b ? "true" : "false");




10,396✔





3206



      return buf;




10,396✔





3207



    }










3208



    case TSDB_DATA_TYPE_TINYINT:




5,440,403✔





3209



    case TSDB_DATA_TYPE_SMALLINT:










3210



    case TSDB_DATA_TYPE_INT:










3211



    case TSDB_DATA_TYPE_BIGINT:










3212



    case TSDB_DATA_TYPE_TIMESTAMP: {










3213



      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);




5,440,403✔





3214



      if (NULL == buf) {




5,440,764✔






UNCOV

3215



        return NULL;




×







3216



      }










3217












3218



      snprintf(buf, MAX_NUM_STR_SIZE, "%" PRId64, pNode->datum.i);




5,440,764✔





3219



      return buf;




5,440,764✔





3220



    }











UNCOV

3221



    case TSDB_DATA_TYPE_UTINYINT:




×







3222



    case TSDB_DATA_TYPE_USMALLINT:










3223



    case TSDB_DATA_TYPE_UINT:










3224



    case TSDB_DATA_TYPE_UBIGINT: {










3225



      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);




×








UNCOV

3226



      if (NULL == buf) {




×








UNCOV

3227



        return NULL;




×







3228



      }










3229












3230



      snprintf(buf, MAX_NUM_STR_SIZE, "%" PRIu64, pNode->datum.u);




×







3231



      return buf;




×







3232



    }










3233



    case TSDB_DATA_TYPE_FLOAT:




1,670✔





3234



    case TSDB_DATA_TYPE_DOUBLE: {










3235



      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);




1,670✔





3236



      if (NULL == buf) {




1,670✔






UNCOV

3237



        return NULL;




×







3238



      }










3239












3240



      snprintf(buf, MAX_NUM_STR_SIZE, "%e", pNode->datum.d);




1,670✔





3241



      return buf;




1,670✔





3242



    }










3243



    case TSDB_DATA_TYPE_NCHAR:




124,404✔





3244



    case TSDB_DATA_TYPE_VARCHAR:










3245



    case TSDB_DATA_TYPE_VARBINARY:










3246



    case TSDB_DATA_TYPE_GEOMETRY: {










3247



      if (NULL == pNode->datum.p) {




124,404✔





3248



        return NULL;




1,112✔





3249



      }










3250



      int32_t bufSize = varDataLen(pNode->datum.p) + 2 + 1;




123,292✔





3251



      void*   buf = taosMemoryMalloc(bufSize);




123,292✔





3252



      if (NULL == buf) {




123,292✔






UNCOV

3253



        return NULL;




×







3254



      }










3255












3256



      snprintf(buf, bufSize, "'%s'", varDataVal(pNode->datum.p));




123,292✔





3257



      return buf;




123,292✔





3258



    }











UNCOV

3259



    case TSDB_DATA_TYPE_BLOB: {




×








UNCOV

3260



      int32_t bufSize = blobDataLen(pNode->datum.p) + 4 + 1;




×








UNCOV

3261



      void*   buf = taosMemoryMalloc(bufSize);




×








UNCOV

3262



      if (NULL == buf) {




×







3263



        return NULL;




×







3264



      }










3265












3266



      snprintf(buf, bufSize, "'%s'", blobDataVal(pNode->datum.p));




×







3267



      return buf;




×







3268



    }











UNCOV

3269



    default:




×







3270



      break;




×







3271



  }










3272













UNCOV

3273



  return NULL;




×







3274



}










3275












3276



bool nodesIsExprNode(const SNode* pNode) {




2,147,483,647✔





3277



  ENodeType type = nodeType(pNode);




2,147,483,647✔





3278



  return (QUERY_NODE_COLUMN == type || QUERY_NODE_VALUE == type || QUERY_NODE_OPERATOR == type ||




2,147,483,647✔





3279



          QUERY_NODE_FUNCTION == type || QUERY_NODE_LOGIC_CONDITION == type || QUERY_NODE_CASE_WHEN == type ||




864,225,128✔





3280



          QUERY_NODE_REMOTE_VALUE == type || QUERY_NODE_SELECT_STMT == type || QUERY_NODE_SET_OPERATOR == type ||




582,892,163✔





3281



          QUERY_NODE_REMOTE_VALUE_LIST == type || QUERY_NODE_REMOTE_ROW == type || QUERY_NODE_REMOTE_ZERO_ROWS == type);




2,147,483,647✔





3282



}










3283













UNCOV

3284



bool nodesIsUnaryOp(const SOperatorNode* pOp) {




×








UNCOV

3285



  switch (pOp->opType) {




×








UNCOV

3286



    case OP_TYPE_MINUS:




×







3287



    case OP_TYPE_IS_NULL:










3288



    case OP_TYPE_IS_NOT_NULL:










3289



    case OP_TYPE_IS_TRUE:










3290



    case OP_TYPE_IS_FALSE:










3291



    case OP_TYPE_IS_UNKNOWN:










3292



    case OP_TYPE_IS_NOT_TRUE:










3293



    case OP_TYPE_IS_NOT_FALSE:










3294



    case OP_TYPE_IS_NOT_UNKNOWN:











UNCOV

3295



      return true;




×








UNCOV

3296



    default:




×








UNCOV

3297



      break;




×







3298



  }










3299



  return false;




×







3300



}










3301













UNCOV

3302



bool nodesIsArithmeticOp(const SOperatorNode* pOp) {




×







3303



  switch (pOp->opType) {




×








UNCOV

3304



    case OP_TYPE_ADD:




×







3305



    case OP_TYPE_SUB:










3306



    case OP_TYPE_MULTI:










3307



    case OP_TYPE_DIV:










3308



    case OP_TYPE_REM:











UNCOV

3309



      return true;




×








UNCOV

3310



    default:




×








UNCOV

3311



      break;




×







3312



  }










3313



  return false;




×







3314



}










3315












3316



bool nodesIsBasicArithmeticOp(const SOperatorNode* pOp) {




144,306,647✔





3317



  switch (pOp->opType) {




144,306,647✔





3318



    case OP_TYPE_ADD:




2,469,774✔





3319



    case OP_TYPE_SUB:










3320



    case OP_TYPE_MULTI:










3321



    case OP_TYPE_DIV:










3322



      return true;




2,469,774✔





3323



    default:




141,836,906✔





3324



      break;




141,836,906✔





3325



  }










3326



  return false;




141,836,906✔





3327



}










3328












3329



bool nodesIsComparisonOp(const SOperatorNode* pOp) {




270,015,899✔





3330



  switch (pOp->opType) {




270,015,899✔





3331



    case OP_TYPE_GREATER_THAN:




269,939,541✔





3332



    case OP_TYPE_GREATER_EQUAL:










3333



    case OP_TYPE_LOWER_THAN:










3334



    case OP_TYPE_LOWER_EQUAL:










3335



    case OP_TYPE_EQUAL:










3336



    case OP_TYPE_NOT_EQUAL:










3337



    case OP_TYPE_IN:










3338



    case OP_TYPE_NOT_IN:










3339



    case OP_TYPE_LIKE:










3340



    case OP_TYPE_NOT_LIKE:










3341



    case OP_TYPE_MATCH:










3342



    case OP_TYPE_NMATCH:










3343



    case OP_TYPE_JSON_CONTAINS:










3344



    case OP_TYPE_IS_NULL:










3345



    case OP_TYPE_IS_NOT_NULL:










3346



    case OP_TYPE_IS_TRUE:










3347



    case OP_TYPE_IS_FALSE:










3348



    case OP_TYPE_IS_UNKNOWN:










3349



    case OP_TYPE_IS_NOT_TRUE:










3350



    case OP_TYPE_IS_NOT_FALSE:










3351



    case OP_TYPE_IS_NOT_UNKNOWN:










3352



    case OP_TYPE_EXISTS:










3353



    case OP_TYPE_NOT_EXISTS:










3354



      return true;




269,939,541✔





3355



    default:




79,407✔





3356



      break;




79,407✔





3357



  }










3358



  return false;




79,407✔





3359



}










3360













UNCOV

3361



bool nodesIsJsonOp(const SOperatorNode* pOp) {




×








UNCOV

3362



  switch (pOp->opType) {




×








UNCOV

3363



    case OP_TYPE_JSON_GET_VALUE:




×







3364



    case OP_TYPE_JSON_CONTAINS:










3365



      return true;




×







3366



    default:




×







3367



      break;




×







3368



  }










3369



  return false;




×







3370



}










3371












3372



bool nodesIsRegularOp(const SOperatorNode* pOp) {




339,071,457✔





3373



  switch (pOp->opType) {




339,071,457✔





3374



    case OP_TYPE_LIKE:




12,830,521✔





3375



    case OP_TYPE_NOT_LIKE:










3376



    case OP_TYPE_MATCH:










3377



    case OP_TYPE_NMATCH:










3378



      return true;




12,830,521✔





3379



    default:




326,240,936✔





3380



      break;




326,240,936✔





3381



  }










3382



  return false;




326,240,936✔





3383



}










3384












3385



bool nodesIsMatchRegularOp(const SOperatorNode* pOp) {




12,794,322✔





3386



  switch (pOp->opType) {




12,794,322✔





3387



    case OP_TYPE_MATCH:




6,614,050✔





3388



    case OP_TYPE_NMATCH:










3389



      return true;




6,614,050✔





3390



    default:




6,180,272✔





3391



      break;




6,180,272✔





3392



  }










3393



  return false;




6,180,272✔





3394



}










3395













UNCOV

3396



bool nodesIsBitwiseOp(const SOperatorNode* pOp) {




×








UNCOV

3397



  switch (pOp->opType) {




×








UNCOV

3398



    case OP_TYPE_BIT_AND:




×







3399



    case OP_TYPE_BIT_OR:










3400



      return true;




×







3401



    default:




×







3402



      break;




×







3403



  }










3404



  return false;




×







3405



}










3406












3407



typedef struct SCollectColumnsCxt {










3408



  int32_t         errCode;










3409



  const char*     pTableAlias;










3410



  SSHashObj*      pMultiTableAlias;










3411



  ECollectColType collectType;










3412



  SNodeList*      pCols;










3413



  SHashObj*       pColHash;










3414



} SCollectColumnsCxt;










3415












3416



static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pNode) {




2,147,483,647✔





3417



  char    name[TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN];




2,113,586,502✔





3418



  int32_t len = 0;




2,147,483,647✔





3419



  if ('\0' == pCol->tableAlias[0]) {




2,147,483,647✔





3420



    len = snprintf(name, sizeof(name), "%s", pCol->colName);




87,730,677✔





3421



  } else {










3422



    len = snprintf(name, sizeof(name), "%s.%s", pCol->tableAlias, pCol->colName);




2,147,483,647✔





3423



  }










3424



  if (pCol->projRefIdx > 0) {




2,147,483,647✔





3425



    len = taosHashBinary(name, strlen(name), sizeof(name));




4,893,158✔





3426



    len += snprintf(name + len, TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN - len, "_%d", pCol->projRefIdx);




4,893,158✔





3427



  }










3428



  SNode** pNodeFound = taosHashGet(pCxt->pColHash, name, len);




2,147,483,647✔





3429



  if (pNodeFound == NULL) {




2,147,483,647✔





3430



    SNode* pNew = NULL;




1,885,571,306✔





3431



    pCxt->errCode = nodesCloneNode(pNode, &pNew);




1,885,571,393✔





3432



    if (TSDB_CODE_SUCCESS == pCxt->errCode) {




1,885,664,283✔





3433



      pCxt->errCode = nodesListStrictAppend(pCxt->pCols, pNew);




1,885,663,514✔





3434



    }










3435



    if (TSDB_CODE_SUCCESS == pCxt->errCode) {




1,885,674,876✔





3436



      // Store cloned node pointer in hash so we can update its flags later










3437



      pCxt->errCode = taosHashPut(pCxt->pColHash, name, len, &pNew, POINTER_BYTES);




1,885,675,128✔





3438



    } else {










3439



      nodesDestroyNode(pNew);




183✔





3440



    }










3441



    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);




1,885,697,978✔





3442



  } else if (0 == pCol->appendByPrivCond) {




645,977,504✔





3443



    SColumnNode* pExistCol = (SColumnNode*)(*pNodeFound);




645,968,552✔





3444



    if (pExistCol->appendByPrivCond == 1) {




645,968,457✔





3445



      pExistCol->appendByPrivCond = 0;




6,408✔





3446



    }










3447



  }










3448



  return DEAL_RES_CONTINUE;




645,976,331✔





3449



}










3450












3451



static bool isCollectType(ECollectColType collectType, EColumnType colType) {




2,147,483,647✔





3452



  return COLLECT_COL_TYPE_ALL == collectType










3453



             ? true










3454



             : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType




2,147,483,647✔





3455



                                                    : (COLUMN_TYPE_TAG != colType && COLUMN_TYPE_TBNAME != colType));




1,765,321,168✔





3456



}










3457












3458



static EDealRes collectColumns(SNode* pNode, void* pContext) {




2,147,483,647✔





3459



  SCollectColumnsCxt* pCxt = (SCollectColumnsCxt*)pContext;




2,147,483,647✔





3460



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




2,147,483,647✔





3461



    SColumnNode* pCol = (SColumnNode*)pNode;




2,147,483,647✔





3462



    if (isCollectType(pCxt->collectType, pCol->colType) && 0 != strcmp(pCol->colName, "*") &&




2,147,483,647✔





3463



        (NULL == pCxt->pTableAlias || 0 == strcmp(pCxt->pTableAlias, pCol->tableAlias))) {




2,147,483,647✔





3464



      return doCollect(pCxt, pCol, pNode);




2,147,483,647✔





3465



    }










3466



  }










3467



  return DEAL_RES_CONTINUE;




2,147,483,647✔





3468



}










3469












3470



static EDealRes collectColumnsExt(SNode* pNode, void* pContext) {




144,522,148✔





3471



  SCollectColumnsCxt* pCxt = (SCollectColumnsCxt*)pContext;




144,522,148✔





3472



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




144,522,148✔





3473



    SColumnNode* pCol = (SColumnNode*)pNode;




76,416,929✔





3474



    if (isCollectType(pCxt->collectType, pCol->colType) && 0 != strcmp(pCol->colName, "*") &&




76,416,929✔





3475



        (NULL == pCxt->pMultiTableAlias ||




76,417,564✔





3476



         NULL != (pCxt->pTableAlias =




76,418,293✔





3477



                      tSimpleHashGet(pCxt->pMultiTableAlias, pCol->tableAlias, strlen(pCol->tableAlias))))) {




76,417,840✔





3478



      return doCollect(pCxt, pCol, pNode);




75,817,245✔





3479



    }










3480



  }










3481



  return DEAL_RES_CONTINUE;




68,705,774✔





3482



}










3483












3484



int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char* pTableAlias, ECollectColType type,




1,009,622,987✔





3485



                            SNodeList** pCols) {










3486



  if (NULL == pSelect || NULL == pCols) {




1,009,622,987✔






UNCOV

3487



    return TSDB_CODE_FAILED;




×







3488



  }










3489



  SNodeList* pList = NULL;




1,009,696,780✔





3490



  if (!*pCols) {




1,009,696,359✔





3491



    int32_t code = nodesMakeList(&pList);




1,009,701,832✔





3492



    if (TSDB_CODE_SUCCESS != code) {




1,009,684,506✔






UNCOV

3493



      return code;




×







3494



    }










3495



  }










3496



  SCollectColumnsCxt cxt = {




1,919,274,745✔





3497



      .errCode = TSDB_CODE_SUCCESS,










3498



      .pTableAlias = pTableAlias,










3499



      .collectType = type,










3500



      .pCols = (NULL == *pCols ? pList : *pCols),




1,009,677,073✔





3501



      .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)};




1,009,675,438✔





3502



  if (NULL == cxt.pCols || NULL == cxt.pColHash) {




1,009,716,228✔






UNCOV

3503



    return TSDB_CODE_OUT_OF_MEMORY;




×







3504



  }










3505



  *pCols = NULL;




1,009,716,228✔





3506



  nodesWalkSelectStmt(pSelect, clause, collectColumns, &cxt);




1,009,715,640✔





3507



  taosHashCleanup(cxt.pColHash);




1,009,743,034✔





3508



  if (TSDB_CODE_SUCCESS != cxt.errCode) {




1,009,721,147✔






UNCOV

3509



    nodesDestroyList(cxt.pCols);




×








UNCOV

3510



    return cxt.errCode;




×







3511



  }










3512



  if (LIST_LENGTH(cxt.pCols) > 0) {




1,009,721,147✔





3513



    *pCols = cxt.pCols;




517,403,440✔





3514



  } else {










3515



    nodesDestroyList(cxt.pCols);




492,317,782✔





3516



  }










3517












3518



  return TSDB_CODE_SUCCESS;




1,009,729,760✔





3519



}










3520












3521



int32_t nodesCollectColumnsExt(SSelectStmt* pSelect, ESqlClause clause, SSHashObj* pMultiTableAlias,




23,750,492✔





3522



                               ECollectColType type, SNodeList** pCols) {










3523



  if (NULL == pSelect || NULL == pCols) {




23,750,492✔






UNCOV

3524



    return TSDB_CODE_FAILED;




×







3525



  }










3526












3527



  SNodeList* pList = NULL;




23,751,283✔





3528



  if (!*pCols) {




23,751,283✔





3529



    int32_t code = nodesMakeList(&pList);




23,751,446✔





3530



    if (TSDB_CODE_SUCCESS != code) {




23,752,060✔






UNCOV

3531



      return code;




×







3532



    }










3533



  }










3534












3535



  SCollectColumnsCxt cxt = {




38,410,980✔





3536



      .errCode = TSDB_CODE_SUCCESS,










3537



      .pTableAlias = NULL,










3538



      .pMultiTableAlias = pMultiTableAlias,










3539



      .collectType = type,










3540



      .pCols = (NULL == *pCols ? pList : *pCols),




23,751,897✔





3541



      .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)};




23,751,897✔





3542



  if (NULL == cxt.pCols || NULL == cxt.pColHash) {




23,752,058✔






UNCOV

3543



    return TSDB_CODE_OUT_OF_MEMORY;




×







3544



  }










3545



  *pCols = NULL;




23,752,058✔





3546



  nodesWalkSelectStmtImpl(pSelect, clause, collectColumnsExt, &cxt);




23,752,058✔





3547



  taosHashCleanup(cxt.pColHash);




23,752,411✔





3548



  if (TSDB_CODE_SUCCESS != cxt.errCode) {




23,752,495✔






UNCOV

3549



    nodesDestroyList(cxt.pCols);




×








UNCOV

3550



    return cxt.errCode;




×







3551



  }










3552



  if (LIST_LENGTH(cxt.pCols) > 0) {




23,752,495✔





3553



    *pCols = cxt.pCols;




22,385,744✔





3554



  } else {










3555



    nodesDestroyList(cxt.pCols);




1,366,751✔





3556



  }










3557












3558



  return TSDB_CODE_SUCCESS;




23,752,583✔





3559



}










3560












3561



int32_t nodesCollectColumnsFromMultiNodes(SNode** pNodes, int32_t numNodes, const char* pTableAlias,




536,331,440✔





3562



                                          ECollectColType type, SNodeList** pCols) {










3563



  if (NULL == pCols) {




536,331,440✔






UNCOV

3564



    return TSDB_CODE_FAILED;




×







3565



  }










3566



  SNodeList* pList = NULL;




536,331,440✔





3567



  if (!*pCols) {




536,331,472✔





3568



    int32_t code = nodesMakeList(&pList);




2,880,326✔





3569



    if (TSDB_CODE_SUCCESS != code) {




2,880,326✔






UNCOV

3570



      return code;




×







3571



    }










3572



  }










3573












3574



  SCollectColumnsCxt cxt = {




718,557,382✔





3575



      .errCode = TSDB_CODE_SUCCESS,










3576



      .pTableAlias = pTableAlias,










3577



      .collectType = type,










3578



      .pCols = (NULL == *pCols ? pList : *pCols),




536,330,902✔





3579



      .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)};




536,331,645✔





3580



  if (NULL == cxt.pCols || NULL == cxt.pColHash) {




536,356,607✔






UNCOV

3581



    return TSDB_CODE_OUT_OF_MEMORY;




×







3582



  }










3583



  *pCols = NULL;




536,356,607✔





3584












3585



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




1,072,720,245✔





3586



    nodesWalkExpr(pNodes[i], collectColumns, &cxt);




536,356,017✔





3587



    if (TSDB_CODE_SUCCESS != cxt.errCode) {




536,363,092✔






UNCOV

3588



      break;




×







3589



    }










3590



  }










3591












3592



  taosHashCleanup(cxt.pColHash);




536,364,228✔





3593



  if (TSDB_CODE_SUCCESS != cxt.errCode) {




536,360,485✔






UNCOV

3594



    nodesDestroyList(cxt.pCols);




×








UNCOV

3595



    return cxt.errCode;




×







3596



  }










3597



  if (LIST_LENGTH(cxt.pCols) > 0) {




536,360,485✔





3598



    *pCols = cxt.pCols;




453,884,823✔





3599



  } else {










3600



    nodesDestroyList(cxt.pCols);




82,475,083✔





3601



  }










3602












3603



  return TSDB_CODE_SUCCESS;




536,357,429✔





3604



}










3605












3606



int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, ECollectColType type, SNodeList** pCols) {




536,326,840✔





3607



  return nodesCollectColumnsFromMultiNodes(&node, 1, pTableAlias, type, pCols);




536,326,840✔





3608



}










3609












3610



typedef struct SCollectFuncsCxt {










3611



  int32_t         errCode;










3612



  char*           tableAlias;










3613



  FFuncClassifier classifier;










3614



  SNodeList*      pFuncs;










3615



} SCollectFuncsCxt;










3616












3617



static EDealRes collectFuncs(SNode* pNode, void* pContext) {




2,147,483,647✔





3618



  SCollectFuncsCxt* pCxt = (SCollectFuncsCxt*)pContext;




2,147,483,647✔





3619



  if (QUERY_NODE_FUNCTION == nodeType(pNode) && pCxt->classifier(((SFunctionNode*)pNode)->funcId)) {




2,147,483,647✔





3620



    SFunctionNode* pFunc = (SFunctionNode*)pNode;




560,055,878✔





3621



    if (FUNCTION_TYPE_TBNAME == pFunc->funcType && pCxt->tableAlias) {




560,055,878✔





3622



      SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0);




77,424,973✔





3623



      if (pVal && strcmp(pVal->literal, pCxt->tableAlias)) {




77,425,029✔





3624



        return DEAL_RES_CONTINUE;




92,144✔





3625



      }










3626



    }










3627












3628



    bool   bFound = false;




559,963,733✔





3629



    SNode* pn = NULL;




559,963,733✔





3630



    FOREACH(pn, pCxt->pFuncs) {




2,147,483,647✔





3631



      if (nodesEqualNode(pn, pNode)) {




2,067,492,501✔





3632



        bFound = true;




94,286,920✔





3633



        break;




94,286,920✔





3634



      }










3635



    }










3636



    if (!bFound) {




559,958,825✔





3637



      SNode* pNew = NULL;




465,665,704✔





3638



      pCxt->errCode = nodesCloneNode(pNode, &pNew);




465,665,650✔





3639



      if (TSDB_CODE_SUCCESS == pCxt->errCode) {




465,686,456✔





3640



        pCxt->errCode = nodesListStrictAppend(pCxt->pFuncs, pNew);




465,686,329✔





3641



      }










3642



    }










3643



    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);




559,985,131✔





3644



  }










3645



  return DEAL_RES_CONTINUE;




2,147,483,647✔





3646



}










3647













UNCOV

3648



static uint32_t funcNodeHash(const char* pKey, uint32_t len) {




×








UNCOV

3649



  SExprNode* pExpr = *(SExprNode**)pKey;




×








UNCOV

3650



  return MurmurHash3_32(pExpr->aliasName, strlen(pExpr->aliasName));




×







3651



}










3652












3653



static int32_t funcNodeEqual(const void* pLeft, const void* pRight, size_t len) {




×







3654



  // if (0 != strcmp((*(const SExprNode**)pLeft)->aliasName, (*(const SExprNode**)pRight)->aliasName)) {










3655



  //   return 1;










3656



  // }










3657



  return nodesEqualNode(*(const SNode**)pLeft, *(const SNode**)pRight) ? 0 : 1;




×







3658



}










3659












3660



int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier,




12,338,205✔





3661



                                SNodeList* pFuncs) {










3662



  if (NULL == pSelect || NULL == pFuncs) {




12,338,205✔






UNCOV

3663



    return TSDB_CODE_FAILED;




×







3664



  }










3665












3666



  SCollectFuncsCxt cxt = {




12,338,897✔





3667



      .errCode = TSDB_CODE_SUCCESS, .classifier = classifier, .tableAlias = tableAlias, .pFuncs = pFuncs};










3668












3669



  nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);




12,338,897✔





3670



  return cxt.errCode;




12,339,313✔





3671



}










3672












3673



int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier,




668,574,853✔





3674



                          SNodeList** pFuncs) {










3675



  if (NULL == pSelect || NULL == pFuncs) {




668,574,853✔






UNCOV

3676



    return TSDB_CODE_FAILED;




×







3677



  }










3678



  SNodeList* pList = NULL;




668,614,875✔





3679



  if (!*pFuncs) {




668,615,346✔





3680



    int32_t code = nodesMakeList(&pList);




625,209,840✔





3681



    if (TSDB_CODE_SUCCESS != code) {




625,201,107✔






UNCOV

3682



      return code;




×







3683



    }










3684



  }










3685



  SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS,




959,013,406✔





3686



                          .classifier = classifier,










3687



                          .tableAlias = tableAlias,










3688



                          .pFuncs = (NULL == *pFuncs ? pList : *pFuncs)};




668,607,765✔





3689



  if (NULL == cxt.pFuncs) {




668,607,642✔






UNCOV

3690



    return TSDB_CODE_OUT_OF_MEMORY;




×







3691



  }










3692



  *pFuncs = NULL;




668,607,642✔





3693



  nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);




668,605,968✔





3694



  if (TSDB_CODE_SUCCESS == cxt.errCode) {




668,639,051✔





3695



    if (LIST_LENGTH(cxt.pFuncs) > 0) {




668,640,663✔





3696



      *pFuncs = cxt.pFuncs;




246,733,059✔





3697



    } else {










3698



      nodesDestroyList(cxt.pFuncs);




421,907,634✔





3699



    }










3700



  } else {











UNCOV

3701



    nodesDestroyList(cxt.pFuncs);




×







3702



  }










3703












3704



  return cxt.errCode;




668,630,692✔





3705



}










3706












3707



typedef struct SCollectSpecialNodesCxt {










3708



  int32_t    errCode;










3709



  ENodeType  type;










3710



  SNodeList* pNodes;










3711



} SCollectSpecialNodesCxt;










3712













UNCOV

3713



static EDealRes collectSpecialNodes(SNode* pNode, void* pContext) {




×








UNCOV

3714



  SCollectSpecialNodesCxt* pCxt = (SCollectSpecialNodesCxt*)pContext;




×








UNCOV

3715



  if (pCxt->type == nodeType(pNode)) {




×








UNCOV

3716



    SNode* pNew = NULL;




×







3717



    pCxt->errCode = nodesCloneNode(pNode, &pNew);




×







3718



    if (TSDB_CODE_SUCCESS == pCxt->errCode) {




×







3719



      pCxt->errCode = nodesListStrictAppend(pCxt->pNodes, pNew);




×







3720



    }










3721



    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);




×







3722



  }










3723



  return DEAL_RES_CONTINUE;




×







3724



}










3725













UNCOV

3726



int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** ppNodes) {




×







3727



  if (NULL == pSelect || NULL == ppNodes) {




×








UNCOV

3728



    return TSDB_CODE_FAILED;




×







3729



  }










3730



  SCollectSpecialNodesCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .type = type, .pNodes = NULL};




×







3731



  if (!*ppNodes) {




×







3732



    cxt.errCode = nodesMakeList(&cxt.pNodes);




×







3733



  } else {










3734



    cxt.pNodes = *ppNodes;




×







3735



  }










3736



  if (NULL == cxt.pNodes) {




×








UNCOV

3737



    return cxt.errCode;




×







3738



  }











UNCOV

3739



  *ppNodes = NULL;




×







3740



  nodesWalkSelectStmt(pSelect, SQL_CLAUSE_GROUP_BY, collectSpecialNodes, &cxt);




×







3741



  if (TSDB_CODE_SUCCESS != cxt.errCode) {




×








UNCOV

3742



    nodesDestroyList(cxt.pNodes);




×







3743



    return cxt.errCode;




×







3744



  }










3745



  if (LIST_LENGTH(cxt.pNodes) > 0) {




×







3746



    *ppNodes = cxt.pNodes;




×







3747



  } else {











UNCOV

3748



    nodesDestroyList(cxt.pNodes);




×







3749



  }










3750













UNCOV

3751



  return TSDB_CODE_SUCCESS;




×







3752



}










3753












3754



static EDealRes hasColumn(SNode* pNode, void* pContext) {




4,159,091✔





3755



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




4,159,091✔





3756



    *(bool*)pContext = true;




4,153,573✔





3757



    return DEAL_RES_END;




4,153,573✔





3758



  }










3759



  return DEAL_RES_CONTINUE;




5,518✔





3760



}










3761












3762



bool nodesExprHasColumn(SNode* pNode) {




4,159,091✔





3763



  bool hasCol = false;




4,159,091✔





3764



  nodesWalkExprPostOrder(pNode, hasColumn, &hasCol);




4,159,091✔





3765



  return hasCol;




4,159,091✔





3766



}










3767













UNCOV

3768



bool nodesExprsHasColumn(SNodeList* pList) {




×








UNCOV

3769



  bool hasCol = false;




×








UNCOV

3770



  nodesWalkExprsPostOrder(pList, hasColumn, &hasCol);




×








UNCOV

3771



  return hasCol;




×







3772



}










3773












3774



char* nodesGetFillModeString(EFillMode mode) {




185,448✔





3775



  switch (mode) {




185,448✔






UNCOV

3776



    case FILL_MODE_NONE:




×








UNCOV

3777



      return "none";




×







3778



    case FILL_MODE_VALUE:




25,728✔





3779



      return "value";




25,728✔





3780



    case FILL_MODE_VALUE_F:




16,392✔





3781



      return "value_f";




16,392✔





3782



    case FILL_MODE_PREV:




42,636✔





3783



      return "prev";




42,636✔





3784



    case FILL_MODE_NULL:




21,944✔





3785



      return "null";




21,944✔






UNCOV

3786



    case FILL_MODE_NULL_F:




×








UNCOV

3787



      return "null_f";




×







3788



    case FILL_MODE_LINEAR:




45,412✔





3789



      return "linear";




45,412✔





3790



    case FILL_MODE_NEXT:




33,336✔





3791



      return "next";




33,336✔






UNCOV

3792



    default:




×








UNCOV

3793



      return "unknown";




×







3794



  }










3795



}










3796












3797



char* nodesGetNameFromColumnNode(SNode* pNode) {




27,920,941✔





3798



  if (NULL == pNode || QUERY_NODE_COLUMN != pNode->type) {




27,920,941✔






UNCOV

3799



    return "NULL";




×







3800



  }










3801












3802



  return ((SColumnNode*)pNode)->node.userAlias;




27,922,580✔





3803



}










3804












3805



int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots) {




200,920,588✔





3806



  if (NULL == pSlots || pSlots->length <= 0) {




200,920,588✔





3807



    return 0;




746,979✔





3808



  }










3809












3810



  SNode*  pNode = NULL;




200,173,609✔





3811



  int32_t num = 0;




200,173,609✔





3812



  FOREACH(pNode, pSlots) {




546,136,092✔





3813



    if (QUERY_NODE_SLOT_DESC != pNode->type) {




345,962,483✔






UNCOV

3814



      continue;




×







3815



    }










3816












3817



    SSlotDescNode* descNode = (SSlotDescNode*)pNode;




345,962,483✔





3818



    if (descNode->output) {




345,962,483✔





3819



      ++num;




331,957,699✔





3820



    }










3821



  }










3822












3823



  return num;




200,173,609✔





3824



}










3825












3826



int32_t nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {




155,516,242✔





3827



  int32_t code = 0;




155,516,242✔





3828



  if (pNode->isNull) {




155,516,242✔





3829



    pVal->nType = TSDB_DATA_TYPE_NULL;




1,601,149✔





3830



    pVal->nLen = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;




1,600,999✔





3831



    return code;




1,600,013✔





3832



  }










3833



  pVal->nType = pNode->node.resType.type;




153,927,638✔





3834



  pVal->nLen = pNode->node.resType.bytes;




153,913,459✔





3835



  switch (pNode->node.resType.type) {




153,911,653✔






UNCOV

3836



    case TSDB_DATA_TYPE_NULL:




×








UNCOV

3837



      break;




×







3838



    case TSDB_DATA_TYPE_BOOL:




62,177✔





3839



      pVal->i = pNode->datum.b;




62,177✔





3840



      break;




70,868✔





3841



    case TSDB_DATA_TYPE_TINYINT:




130,609,581✔





3842



    case TSDB_DATA_TYPE_SMALLINT:










3843



    case TSDB_DATA_TYPE_INT:










3844



    case TSDB_DATA_TYPE_BIGINT:










3845



    case TSDB_DATA_TYPE_TIMESTAMP:










3846



      pVal->i = pNode->datum.i;




130,609,581✔





3847



      break;




130,628,907✔





3848



    case TSDB_DATA_TYPE_UTINYINT:




15,234✔





3849



    case TSDB_DATA_TYPE_USMALLINT:










3850



    case TSDB_DATA_TYPE_UINT:










3851



    case TSDB_DATA_TYPE_UBIGINT:










3852



      pVal->u = pNode->datum.u;




15,234✔





3853



      break;




15,752✔





3854



    case TSDB_DATA_TYPE_FLOAT:




27,905✔





3855



      pVal->f = pNode->datum.d;




27,905✔





3856



      break;




27,905✔





3857



    case TSDB_DATA_TYPE_DOUBLE:




3,341,632✔





3858



      pVal->d = pNode->datum.d;




3,341,632✔





3859



      break;




3,347,863✔





3860



    case TSDB_DATA_TYPE_NCHAR:




19,790,087✔





3861



    case TSDB_DATA_TYPE_VARCHAR:










3862



    case TSDB_DATA_TYPE_VARBINARY:










3863



    case TSDB_DATA_TYPE_GEOMETRY:










3864



      pVal->nLen += VARSTR_HEADER_SIZE;




19,790,087✔





3865



      pVal->pz = taosMemoryCalloc(1, pVal->nLen + 1);




19,798,265✔





3866



      if (pVal->pz) {




19,798,479✔





3867



        memcpy(pVal->pz, pNode->datum.p, varDataTLen(pNode->datum.p));




19,801,593✔





3868



      } else {











UNCOV

3869



        code = terrno;




×







3870



      }










3871



      break;




19,799,110✔





3872



    case TSDB_DATA_TYPE_JSON:




1,503✔





3873



      pVal->nLen = getJsonValueLen(pNode->datum.p);




1,503✔





3874



      pVal->pz = taosMemoryCalloc(1, pVal->nLen);




1,503✔





3875



      if (pVal->pz) {




1,503✔





3876



        memcpy(pVal->pz, pNode->datum.p, pVal->nLen);




1,503✔





3877



      } else {











UNCOV

3878



        code = terrno;




×







3879



      }










3880



      break;




1,503✔






UNCOV

3881



    case TSDB_DATA_TYPE_DECIMAL64:




×







3882



      pVal->d = pNode->datum.d;




×








UNCOV

3883



      break;




×







3884



    case TSDB_DATA_TYPE_DECIMAL:




2,307✔





3885



      pVal->pz = taosMemoryCalloc(1, pVal->nLen);




2,307✔





3886



      if (!pVal->pz) {




2,307✔





3887



        code = terrno;




×








UNCOV

3888



        break;




×







3889



      }










3890



      memcpy(pVal->pz, pNode->datum.p, pVal->nLen);




2,307✔





3891



      break;




2,307✔





3892



    case TSDB_DATA_TYPE_BLOB:




×








UNCOV

3893



      pVal->nLen = blobDataLen(pNode->datum.p);




×








UNCOV

3894



      pVal->pz = taosMemoryCalloc(1, pVal->nLen);




×








UNCOV

3895



      if (pVal->pz) {




×







3896



        memcpy(pVal->pz, blobDataVal(pNode->datum.p), pVal->nLen);




×







3897



      } else {










3898



        code = terrno;




×







3899



      }










3900



      break;




×








UNCOV

3901



    default:




×







3902



      break;




×







3903



  }










3904



  return code;




153,893,930✔





3905



}










3906












3907



int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc) {




441,081,912✔





3908



  if (NULL == *pSrc) {




441,081,912✔





3909



    return TSDB_CODE_SUCCESS;




335,540,819✔





3910



  }










3911












3912



  if (1 == LIST_LENGTH(*pSrc)) {




105,541,159✔





3913



    *pDst = nodesListGetNode(*pSrc, 0);




33,797,084✔





3914



    nodesClearList(*pSrc);




33,796,478✔





3915



  } else {










3916



    SLogicConditionNode* pLogicCond = NULL;




71,744,665✔





3917



    int32_t              code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);




71,744,665✔





3918



    if (TSDB_CODE_SUCCESS != code) {




71,746,953✔






UNCOV

3919



      return code;




×







3920



    }










3921



    pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;




71,746,953✔





3922



    pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;




71,746,953✔





3923



    pLogicCond->condType = LOGIC_COND_TYPE_AND;




71,746,953✔





3924



    pLogicCond->pParameterList = *pSrc;




71,746,920✔





3925



    *pDst = (SNode*)pLogicCond;




71,746,953✔





3926



  }










3927



  *pSrc = NULL;




105,543,594✔





3928












3929



  return TSDB_CODE_SUCCESS;




105,543,594✔





3930



}










3931













UNCOV

3932



const char* dataOrderStr(EDataOrderLevel order) {




×








UNCOV

3933



  switch (order) {




×








UNCOV

3934



    case DATA_ORDER_LEVEL_NONE:




×








UNCOV

3935



      return "no order required";




×







3936



    case DATA_ORDER_LEVEL_IN_BLOCK:




×







3937



      return "in-datablock order";




×







3938



    case DATA_ORDER_LEVEL_IN_GROUP:




×







3939



      return "in-group order";




×







3940



    case DATA_ORDER_LEVEL_GLOBAL:




×







3941



      return "global order";




×







3942



    default:




×







3943



      break;




×







3944



  }










3945



  return "unknown";




×







3946



}










3947












3948



int32_t nodesMakeDurationValueNodeFromString(char* literal, SValueNode** ppValNode) {




4,110✔





3949



  int32_t     lenStr = strlen(literal);




4,110✔





3950



  SValueNode* pValNode = NULL;




4,110✔





3951



  int32_t     code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode);




4,110✔





3952



  if (pValNode) {




4,110✔





3953



    pValNode->node.resType.type = TSDB_DATA_TYPE_BIGINT;




4,110✔





3954



    pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;




4,110✔





3955



    pValNode->node.resType.precision = TSDB_TIME_PRECISION_MILLI;




4,110✔





3956



    pValNode->literal = tstrdup(literal);




4,110✔





3957



    pValNode->flag |= VALUE_FLAG_IS_DURATION;




4,110✔





3958



    pValNode->translate = false;




4,110✔





3959



    pValNode->isNull = false;




4,110✔





3960



    *ppValNode = pValNode;




4,110✔





3961



  }










3962



  return code;




4,110✔





3963



}










3964












3965



int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode) {




1,103,176✔





3966



  int32_t     lenStr = strlen(literal);




1,103,176✔





3967



  SValueNode* pValNode = NULL;




1,103,176✔





3968



  int32_t     code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode);




1,103,176✔





3969



  if (pValNode) {




1,103,176✔





3970



    pValNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




1,103,176✔





3971



    pValNode->node.resType.bytes = lenStr + VARSTR_HEADER_SIZE;




1,103,176✔





3972



    char* p = taosMemoryMalloc(lenStr + 1 + VARSTR_HEADER_SIZE);




1,103,176✔





3973



    if (p == NULL) {




1,103,176✔






UNCOV

3974



      return terrno;




×







3975



    }










3976



    varDataSetLen(p, lenStr);




1,103,176✔





3977



    memcpy(varDataVal(p), literal, lenStr + 1);




1,103,176✔





3978



    pValNode->datum.p = p;




1,103,176✔





3979



    pValNode->literal = tstrdup(literal);




1,103,176✔





3980



    pValNode->translate = true;




1,103,176✔





3981



    pValNode->isNull = false;




1,103,176✔





3982



    *ppValNode = pValNode;




1,103,176✔





3983



  }










3984



  return code;




1,103,176✔





3985



}










3986












3987



int32_t nodesMakeValueNodeFromBool(bool b, SValueNode** ppValNode) {




356,518✔





3988



  SValueNode* pValNode = NULL;




356,518✔





3989



  int32_t     code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode);




356,518✔





3990



  if (TSDB_CODE_SUCCESS == code) {




356,518✔





3991



    pValNode->node.resType.type = TSDB_DATA_TYPE_BOOL;




356,518✔





3992



    pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;




356,518✔





3993



    code = nodesSetValueNodeValue(pValNode, &b);




356,518✔





3994



    if (TSDB_CODE_SUCCESS == code) {




356,518✔





3995



      pValNode->translate = true;




356,518✔





3996



      pValNode->isNull = false;




356,518✔





3997



      *ppValNode = pValNode;




356,518✔





3998



    } else {











UNCOV

3999



      nodesDestroyNode((SNode*)pValNode);




×







4000



    }










4001



  }










4002



  return code;




356,518✔





4003



}










4004












4005



int32_t nodesMakeValueNodeFromInt32(int32_t value, SNode** ppNode) {




20,470,185✔





4006



  SValueNode* pValNode = NULL;




20,470,185✔





4007



  int32_t     code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode);




20,470,185✔





4008



  if (TSDB_CODE_SUCCESS == code) {




20,470,370✔





4009



    pValNode->node.resType.type = TSDB_DATA_TYPE_INT;




20,470,370✔





4010



    pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes;




20,470,370✔





4011



    code = nodesSetValueNodeValue(pValNode, &value);




20,470,370✔





4012



    if (TSDB_CODE_SUCCESS == code) {




20,470,185✔





4013



      pValNode->translate = true;




20,470,099✔





4014



      pValNode->isNull = false;




20,470,099✔





4015



      *ppNode = (SNode*)pValNode;




20,470,099✔





4016



    } else {










4017



      nodesDestroyNode((SNode*)pValNode);




86✔





4018



    }










4019



  }










4020



  return code;




20,470,099✔





4021



}










4022












4023



int32_t nodesMakeValueNodeFromInt64(int64_t value, SNode** ppNode) {




3,810,949✔





4024



  SValueNode* pValNode = NULL;




3,810,949✔





4025



  int32_t     code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode);




3,810,949✔





4026



  if (TSDB_CODE_SUCCESS == code) {




3,810,949✔





4027



    pValNode->node.resType.type = TSDB_DATA_TYPE_BIGINT;




3,810,949✔





4028



    pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;




3,810,949✔





4029



    code = nodesSetValueNodeValue(pValNode, &value);




3,810,949✔





4030



    if (TSDB_CODE_SUCCESS == code) {




3,810,949✔





4031



      pValNode->translate = true;




3,810,949✔





4032



      pValNode->isNull = false;




3,810,949✔





4033



      *ppNode = (SNode*)pValNode;




3,810,949✔





4034



    } else {











UNCOV

4035



      nodesDestroyNode((SNode*)pValNode);




×







4036



    }










4037



  }










4038



  return code;




3,810,949✔





4039



}










4040












4041



int32_t nodesMakeValueNodeFromTimestamp(int64_t value, SNode** ppNode) {




1,071,409✔





4042



  SValueNode* pValNode = NULL;




1,071,409✔





4043



  int32_t     code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode);




1,071,409✔





4044



  if (TSDB_CODE_SUCCESS == code) {




1,071,409✔





4045



    pValNode->node.resType.type = TSDB_DATA_TYPE_TIMESTAMP;




1,071,409✔





4046



    pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes;




1,071,409✔





4047



    code = nodesSetValueNodeValue(pValNode, &value);




1,071,409✔





4048



    if (TSDB_CODE_SUCCESS == code) {




1,071,409✔





4049



      pValNode->translate = true;




1,071,409✔





4050



      pValNode->isNull = false;




1,071,409✔





4051



      *ppNode = (SNode*)pValNode;




1,071,409✔





4052



    } else {











UNCOV

4053



      nodesDestroyNode((SNode*)pValNode);




×







4054



    }










4055



  }










4056



  return code;




1,071,409✔





4057



}










4058












4059



bool nodesIsStar(SNode* pNode) {




933,509,258✔





4060



  return (QUERY_NODE_COLUMN == nodeType(pNode)) && ('\0' == ((SColumnNode*)pNode)->tableAlias[0]) &&




993,675,489✔





4061



         (0 == strcmp(((SColumnNode*)pNode)->colName, "*"));




60,166,503✔





4062



}










4063












4064



bool nodesIsTableStar(SNode* pNode) {




865,129,086✔





4065



  return (QUERY_NODE_COLUMN == nodeType(pNode)) && ('\0' != ((SColumnNode*)pNode)->tableAlias[0]) &&




1,237,119,433✔





4066



         (0 == strcmp(((SColumnNode*)pNode)->colName, "*"));




371,990,383✔





4067



}










4068












4069



void nodesSortList(SNodeList** pList, int32_t (*comp)(SNode* pNode1, SNode* pNode2)) {




29,809✔





4070



  if ((*pList)->length == 1) return;




29,809✔





4071












4072



  uint32_t   inSize = 1;




27,335✔





4073



  SListCell* pHead = (*pList)->pHead;




27,335✔





4074



  while (1) {




38,688✔





4075



    SListCell* p = pHead;




66,023✔





4076



    pHead = NULL;




66,023✔





4077



    SListCell* pTail = NULL;




66,023✔





4078












4079



    uint32_t nMerges = 0;




66,023✔





4080



    while (p) {




193,942✔





4081



      ++nMerges;




127,919✔





4082



      SListCell* q = p;




127,919✔





4083



      uint32_t   pSize = 0;




127,919✔





4084



      for (uint32_t i = 0; i < inSize; ++i) {




322,104✔





4085



        ++pSize;




217,424✔





4086



        q = q->pNext;




217,424✔





4087



        if (!q) {




217,424✔





4088



          break;




23,239✔





4089



        }










4090



      }










4091












4092



      uint32_t qSize = inSize;




127,919✔





4093












4094



      while (pSize > 0 || (qSize > 0 && q)) {




488,984✔





4095



        SListCell* pCell;










4096



        if (pSize == 0) {




361,065✔





4097



          pCell = q;




132,613✔





4098



          q = q->pNext;




132,613✔





4099



          --qSize;




132,613✔





4100



        } else if (qSize == 0 || !q) {




228,452✔





4101



          pCell = p;




39,303✔





4102



          p = p->pNext;




39,303✔





4103



          --pSize;




39,303✔





4104



        } else if (comp(q->pNode, p->pNode) >= 0) {




189,149✔





4105



          pCell = p;




178,121✔





4106



          p = p->pNext;




178,121✔





4107



          --pSize;




178,121✔





4108



        } else {










4109



          pCell = q;




11,028✔





4110



          q = q->pNext;




11,028✔





4111



          --qSize;




11,028✔





4112



        }










4113












4114



        if (pTail) {




361,065✔





4115



          pTail->pNext = pCell;




295,042✔





4116



          pCell->pPrev = pTail;




295,042✔





4117



        } else {










4118



          pHead = pCell;




66,023✔





4119



          pHead->pPrev = NULL;




66,023✔





4120



        }










4121



        pTail = pCell;




361,065✔





4122



      }










4123



      p = q;




127,919✔





4124



    }










4125



    pTail->pNext = NULL;




66,023✔





4126












4127



    if (nMerges <= 1) {




66,023✔





4128



      (*pList)->pHead = pHead;




27,335✔





4129



      (*pList)->pTail = pTail;




27,335✔





4130



      return;




27,335✔





4131



    }










4132



    inSize *= 2;




38,688✔





4133



  }










4134



}










4135












4136



static SNode* nodesListFindNode(SNodeList* pList, SNode* pNode) {




256,591✔





4137



  SNode* pFound = NULL;




256,591✔





4138



  FOREACH(pFound, pList) {




577,634✔





4139



    if (nodesEqualNode(pFound, pNode)) {




336,095✔





4140



      break;




15,052✔





4141



    }










4142



  }










4143



  return pFound;




256,591✔





4144



}










4145












4146



int32_t nodesListDeduplicate(SNodeList** ppList) {




34,456,770✔





4147



  if (!ppList || LIST_LENGTH(*ppList) <= 1) return TSDB_CODE_SUCCESS;




34,456,770✔





4148



  if (LIST_LENGTH(*ppList) == 2) {




3,628,467✔





4149



    SNode* pNode1 = nodesListGetNode(*ppList, 0);




3,558,891✔





4150



    SNode* pNode2 = nodesListGetNode(*ppList, 1);




3,559,173✔





4151



    if (nodesEqualNode(pNode1, pNode2)) {




3,559,079✔






UNCOV

4152



      SListCell* pCell = nodesListGetCell(*ppList, 1);




×








UNCOV

4153



      (void)nodesListErase(*ppList, pCell);




×







4154



    }










4155



    return TSDB_CODE_SUCCESS;




3,558,714✔





4156



  }










4157



  SNodeList* pTmp = NULL;




70,099✔





4158



  int32_t    code = nodesMakeList(&pTmp);




70,099✔





4159



  if (TSDB_CODE_SUCCESS == code) {




70,099✔





4160



    SNode* pNode = NULL;




70,099✔





4161



    FOREACH(pNode, *ppList) {




326,690✔





4162



      SNode* pFound = nodesListFindNode(pTmp, pNode);




256,591✔





4163



      if (NULL == pFound) {




256,591✔





4164



        code = nodesCloneNode(pNode, &pFound);




241,539✔





4165



        if (TSDB_CODE_SUCCESS == code) code = nodesListStrictAppend(pTmp, pFound);




241,539✔





4166



        if (TSDB_CODE_SUCCESS != code) break;




241,539✔





4167



      }










4168



    }










4169



  }










4170



  if (TSDB_CODE_SUCCESS == code) {




70,099✔





4171



    nodesDestroyList(*ppList);




70,099✔





4172



    *ppList = pTmp;




70,099✔





4173



  } else {











UNCOV

4174



    nodesDestroyList(pTmp);




×







4175



  }










4176



  return code;




70,099✔





4177



}










4178












4179



void rewriteExprAliasName(SExprNode* pNode, int64_t num) {




1,184,879,730✔





4180



  (void)tsnprintf(pNode->aliasName, TSDB_COL_NAME_LEN, "expr_%x", num);




1,184,879,730✔





4181



  return;




1,184,910,678✔





4182



}










4183












4184



bool isRelatedToOtherExpr(SExprNode* pExpr) { return pExpr->relatedTo != 0; }




549,820,925✔





4185












4186



typedef struct SContainsColCxt {










4187



  bool containsCol;










4188



} SContainsColCxt;










4189












4190



static EDealRes nodeContainsCol(SNode* pNode, void* pContext) {




19,534,168✔





4191



  SContainsColCxt* pCxt = pContext;




19,534,168✔





4192



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




19,534,168✔





4193



    pCxt->containsCol = true;




19,491,007✔





4194



    return DEAL_RES_END;




19,491,007✔





4195



  }










4196












4197



  return DEAL_RES_CONTINUE;




43,161✔





4198



}










4199












4200



bool nodesContainsColumn(SNode* pNode) {




19,516,338✔





4201



  if (NULL == pNode) {




19,516,338✔






UNCOV

4202



    return false;




×







4203



  }










4204












4205



  SContainsColCxt cxt = {0};




19,516,338✔





4206



  nodesWalkExpr(pNode, nodeContainsCol, &cxt);




19,516,338✔





4207












4208



  return cxt.containsCol;




19,516,338✔





4209



}










4210












4211



int32_t mergeNodeToLogic(SNode** pDst, SNode** pSrc) {




11,622,687✔





4212



  SLogicConditionNode* pLogicCond = NULL;




11,622,687✔





4213



  int32_t              code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);




11,622,687✔





4214



  if (NULL == pLogicCond) {




11,622,687✔






UNCOV

4215



    return code;




×







4216



  }










4217



  pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;




11,622,687✔





4218



  pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;




11,622,687✔





4219



  pLogicCond->condType = LOGIC_COND_TYPE_AND;




11,622,687✔





4220



  code = nodesListMakeAppend(&pLogicCond->pParameterList, *pSrc);




11,622,687✔





4221



  if (TSDB_CODE_SUCCESS == code) {




11,622,687✔





4222



    *pSrc = NULL;




11,622,687✔





4223



    code = nodesListMakeAppend(&pLogicCond->pParameterList, *pDst);




11,622,687✔





4224



  }










4225



  if (TSDB_CODE_SUCCESS == code) {




11,622,687✔





4226



    *pDst = (SNode*)pLogicCond;




11,622,687✔





4227



  } else {











UNCOV

4228



    nodesDestroyNode((SNode*)pLogicCond);




×







4229



  }










4230



  return code;




11,622,687✔





4231



}










4232












4233



int32_t nodesMergeNode(SNode** pCond, SNode** pAdditionalCond) {




60,985,157✔





4234



  if (NULL == *pCond) {




60,985,157✔





4235



    TSWAP(*pCond, *pAdditionalCond);




47,442,770✔





4236



    return TSDB_CODE_SUCCESS;




47,442,770✔





4237



  }










4238












4239



  int32_t code = TSDB_CODE_SUCCESS;




13,542,387✔





4240



  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pCond) &&




13,542,387✔





4241



      LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)*pCond)->condType) {




1,922,578✔





4242



    code = nodesListAppend(((SLogicConditionNode*)*pCond)->pParameterList, *pAdditionalCond);




1,922,578✔





4243



    if (TSDB_CODE_SUCCESS == code) {




1,922,578✔





4244



      *pAdditionalCond = NULL;




1,922,578✔





4245



    }










4246



  } else {










4247



    code = mergeNodeToLogic(pCond, pAdditionalCond);




11,619,809✔





4248



  }










4249












4250



  return code;




13,545,265✔





4251



}










4252













UNCOV

4253



void tFreeStreamVtbColName(void* param) {




×








UNCOV

4254



  if (NULL == param) {




×








UNCOV

4255



    return;




×







4256



  }










4257












4258



  SColIdName* pColId = (SColIdName*)param;




×







4259













UNCOV

4260



  taosMemoryFreeClear(pColId->colName);




×







4261



}










4262













UNCOV

4263



void tFreeStreamVtbOtbInfo(void* param) {




×







4264



  SArray** ppArray = (SArray**)param;




×








UNCOV

4265



  if (NULL == param || NULL == *ppArray) {




×








UNCOV

4266



    return;




×







4267



  }










4268












4269



  taosArrayDestroyEx(*ppArray, tFreeStreamVtbColName);




×







4270



}










4271













UNCOV

4272



void tFreeStreamVtbVtbInfo(void* param) {




×







4273



  SSHashObj** ppHash = (SSHashObj**)param;




×








UNCOV

4274



  if (NULL == param || NULL == *ppHash) {




×








UNCOV

4275



    return;




×







4276



  }










4277












4278



  tSimpleHashCleanup(*ppHash);




×







4279



}










4280













UNCOV

4281



void tFreeStreamVtbDbVgInfo(void* param) {




×







4282



  SSHashObj** ppHash = (SSHashObj**)param;




×








UNCOV

4283



  if (NULL == param || NULL == *ppHash) {




×








UNCOV

4284



    return;




×







4285



  }










4286












4287



  tSimpleHashCleanup(*ppHash);




×







4288



}










4289












4290












4291



bool nodesIsScalarSubQuery(SNode* pNode) {




×








UNCOV

4292



  switch (nodeType(pNode)) {




×








UNCOV

4293



    case QUERY_NODE_SELECT_STMT: {




×








UNCOV

4294



      SSelectStmt* pSelect = (SSelectStmt*)pNode;




×







4295



      return pSelect->subQType == E_SUB_QUERY_SCALAR;




×







4296



    }










4297



    case QUERY_NODE_SET_OPERATOR: {




×







4298



      SSetOperator* pSet = (SSetOperator*)pNode;




×







4299



      return pSet->subQType == E_SUB_QUERY_SCALAR;




×







4300



    }










4301



    default:




×







4302



      break;




×







4303



  }










4304












4305



  return false;




×







4306



}










4307












4308



char* nodesGetSubSql(SNode* pNode) {




172,817,281✔





4309



  switch (nodeType(pNode)) {




172,817,281✔





4310



    case QUERY_NODE_SELECT_STMT: {




156,469,483✔





4311



      SSelectStmt* pSelect = (SSelectStmt*)pNode;




156,469,483✔





4312



      return pSelect->node.userAlias;




156,469,483✔





4313



    }










4314



    case QUERY_NODE_SET_OPERATOR: {




16,348,861✔





4315



      SSetOperator* pSet = (SSetOperator*)pNode;




16,348,861✔





4316



      return pSet->node.userAlias;




16,348,861✔





4317



    }











UNCOV

4318



    default:




×








UNCOV

4319



      break;




×







4320



  }










4321













UNCOV

4322



  return NULL;




×







4323



}










4324












4325



void nodesGetSubQType(SNode* pNode, int32_t* pType) {




172,816,727✔





4326



  switch (nodeType(pNode)) {




172,816,727✔





4327



    case QUERY_NODE_SELECT_STMT: {




156,493,030✔





4328



      SSelectStmt* pSelect = (SSelectStmt*)pNode;




156,493,030✔





4329



      *pType = pSelect->subQType;




156,493,030✔





4330



      break;




156,493,030✔





4331



    }










4332



    case QUERY_NODE_SET_OPERATOR: {




16,347,130✔





4333



      SSetOperator* pSet = (SSetOperator*)pNode;




16,347,130✔





4334



      *pType = pSet->subQType;




16,347,130✔





4335



      break;




16,347,130✔





4336



    }











UNCOV

4337



    default:




×








UNCOV

4338



      *pType = E_SUB_QUERY_NOT_SET;




×








UNCOV

4339



      break;




×







4340



  }










4341












4342



  return;




172,816,727✔





4343



}










4344












4345



SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr) {




1,186,574,052✔





4346



  SColumnNode* pCol = NULL;




1,186,574,052✔





4347



  terrno = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);




1,186,574,800✔





4348



  if (NULL == pCol) {




1,186,603,863✔






UNCOV

4349



    return NULL;




×







4350



  }










4351



  pCol->node.resType = pExpr->resType;




1,186,603,863✔





4352



  snprintf(pCol->colName, sizeof(pCol->colName), "%s", pExpr->aliasName);




1,186,604,997✔





4353



  if (NULL != pStmtName) {




1,186,604,035✔





4354



    snprintf(pCol->tableAlias, sizeof(pCol->tableAlias), "%s", pStmtName);




1,186,629,066✔





4355



  }










4356



  snprintf(pCol->node.userAlias, sizeof(pCol->node.userAlias), "%s", pExpr->userAlias);




1,186,604,047✔





4357



  pCol->node.relatedTo = pExpr->relatedTo;




1,186,605,913✔





4358



  return pCol;




1,186,604,386✔





4359



}










4360












4361


























    

  • 

    •