Recached

taosdata / TDengine / #5011

coverage: 72.3% (+0.008%) from 72.292%
#5011

push

travis-ci

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

4053 of 5985 new or added lines in 68 files covered. (67.72%)

732 existing lines in 143 files now uncovered.

257430 of 356056 relevant lines covered (72.3%)

131834103.52 hits per line

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

88.48
/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,052,501✔





70



  if (NULL == *ppSrc) {




7,052,501✔





71



    return TSDB_CODE_SUCCESS;




6,962,282✔





72



  }










73



  if (NULL == *ppDst) {




90,299✔





74



    *ppDst = *ppSrc;




79,494✔





75



    *ppSrc = NULL;




79,494✔





76



    return TSDB_CODE_SUCCESS;




79,494✔





77



  }










78



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




10,805✔





79



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




2,005✔





80



    TSWAP(*ppDst, *ppSrc);




×







81



  }










82



  int32_t code = 0;




10,805✔





83



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




10,805✔





84



    SLogicConditionNode* pDst = (SLogicConditionNode*)*ppDst;




1,604✔





85



    if (pDst->condType == LOGIC_COND_TYPE_AND) {




1,604✔





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;




10,805✔





102



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




10,805✔





103



  if (TSDB_CODE_SUCCESS != code) {




10,805✔





104



    return code;




×







105



  }










106



  pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;




10,805✔





107



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




10,805✔





108



  pLogicCond->condType = LOGIC_COND_TYPE_AND;




10,805✔





109



  pLogicCond->pParameterList = NULL;




10,805✔





110



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




10,805✔





111



  if (TSDB_CODE_SUCCESS == code) {




10,805✔





112



    *ppSrc = NULL;




10,805✔





113



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




10,805✔





114



  }










115



  if (TSDB_CODE_SUCCESS == code) {




10,805✔





116



    *ppDst = (SNode*)pLogicCond;




10,805✔





117



  }










118



  return code;




10,805✔





119



}










120












121



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




1,848,072,041✔





122



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




1,848,072,041✔





123



  if (NULL == pNewChunk) {




1,848,067,006✔





124



    if (pOutChunk) *pOutChunk = NULL;




×







125



    return terrno;




×







126



  }










127



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




1,848,067,006✔





128



  pNewChunk->availableSize = pAllocator->chunkSize;




1,848,068,499✔





129



  pNewChunk->usedSize = 0;




1,848,071,058✔





130



  pNewChunk->pNext = NULL;




1,848,071,468✔





131



  if (NULL != pAllocator->pCurrChunk) {




1,848,071,007✔





132



    pAllocator->pCurrChunk->pNext = pNewChunk;




1,383,333,391✔





133



  }










134



  pAllocator->pCurrChunk = pNewChunk;




1,848,071,815✔





135



  if (NULL == pAllocator->pChunks) {




1,848,076,243✔





136



    pAllocator->pChunks = pNewChunk;




464,783,598✔





137



  }










138



  ++(pAllocator->chunkNum);




1,848,078,723✔





139



  if (pOutChunk) *pOutChunk = pNewChunk;




1,848,075,833✔





140



  return TSDB_CODE_SUCCESS;




1,848,075,833✔





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,383,346,380✔





156



    if (TSDB_CODE_SUCCESS != code) {




1,383,337,743✔





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




464,778,693✔





194



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




464,778,693✔





195



  if (NULL == *pAllocator) {




464,767,349✔





196



    return terrno;




×







197



  }










198



  (*pAllocator)->chunkSize = chunkSize;




464,773,702✔





199



  int32_t code = callocNodeChunk(*pAllocator, NULL);




464,781,639✔





200



  if (TSDB_CODE_SUCCESS != code) {




464,782,370✔





201



    taosMemoryFreeClear(*pAllocator);




×







202



    return code;




×







203



  }










204



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




464,782,370✔





205



    return TAOS_SYSTEM_ERROR(ERRNO);




×







206



  }










207



  return TSDB_CODE_SUCCESS;




464,779,408✔





208



}










209












210



static void destroyNodeAllocator(void* p) {




464,782,722✔





211



  if (NULL == p) {




464,782,722✔





212



    return;




×







213



  }










214












215



  SNodeAllocator* pAllocator = p;




464,782,722✔





216












217



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




464,782,722✔





218



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










219












220



  SNodeMemChunk* pChunk = pAllocator->pChunks;




464,788,039✔





221



  while (NULL != pChunk) {




2,147,483,647✔





222



    SNodeMemChunk* pTemp = pChunk->pNext;




1,848,176,586✔





223



    taosMemoryFree(pChunk);




1,848,177,474✔





224



    pChunk = pTemp;




1,848,172,182✔





225



  }










226



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




464,786,682✔





227



  taosMemoryFree(pAllocator);




464,785,653✔





228



}










229












230



int32_t nodesInitAllocatorSet() {




1,475,682✔





231



  if (g_allocatorReqRefPool >= 0) {




1,475,682✔





232



    nodesWarn("nodes already initialized");




×







233



    return TSDB_CODE_SUCCESS;




×







234



  }










235












236



  g_allocatorReqRefPool = taosOpenRef(1024, destroyNodeAllocator);




1,475,682✔





237



  if (g_allocatorReqRefPool < 0) {




1,475,682✔





238



    nodesError("init nodes failed");




×







239



    return TSDB_CODE_OUT_OF_MEMORY;




×







240



  }










241












242



  return TSDB_CODE_SUCCESS;




1,475,682✔





243



}










244












245



void nodesDestroyAllocatorSet() {




1,475,726✔





246



  if (g_allocatorReqRefPool >= 0) {




1,475,726✔





247



    SNodeAllocator* pAllocator = taosIterateRef(g_allocatorReqRefPool, 0);




1,475,682✔





248



    int64_t         refId = 0;




1,475,682✔





249



    while (NULL != pAllocator) {




1,516,931✔





250



      refId = pAllocator->self;




41,249✔





251



      int32_t code = taosRemoveRef(g_allocatorReqRefPool, refId);




41,249✔





252



      if (TSDB_CODE_SUCCESS != code) {




41,249✔





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




41,249✔





257



    }










258



    taosCloseRef(g_allocatorReqRefPool);




1,475,682✔





259



  }










260



}




1,475,726✔





261












262



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




464,775,679✔





263



  SNodeAllocator* pAllocator = NULL;




464,775,679✔





264



  int32_t         code = createNodeAllocator(chunkSize, &pAllocator);




464,777,074✔





265



  if (TSDB_CODE_SUCCESS == code) {




464,783,216✔





266



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




464,780,172✔





267



    if (pAllocator->self <= 0) {




464,790,871✔





268



      return terrno;




3,983✔





269



    }










270



    pAllocator->queryId = queryId;




464,784,459✔





271



    *pAllocatorId = pAllocator->self;




464,784,661✔





272



  }










273



  return code;




464,787,811✔





274



}










275












276



int32_t nodesSimAcquireAllocator(int64_t allocatorId) {




1,036,601,342✔





277



  if (allocatorId <= 0) {




1,036,601,342✔





278



    return TSDB_CODE_SUCCESS;




571,897,335✔





279



  }










280












281



  SNodeAllocator* pAllocator = taosAcquireRef(g_allocatorReqRefPool, allocatorId);




464,704,007✔





282



  if (NULL == pAllocator) {




464,749,586✔





283



    return terrno;




6,991✔





284



  }










285



  return TSDB_CODE_SUCCESS;




464,742,595✔





286



}










287












288



int32_t nodesSimReleaseAllocator(int64_t allocatorId) {




1,036,616,022✔





289



  if (allocatorId <= 0) {




1,036,616,022✔





290



    return TSDB_CODE_SUCCESS;




571,894,720✔





291



  }










292












293



  return taosReleaseRef(g_allocatorReqRefPool, allocatorId);




464,721,302✔





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;




952,562,189✔





299



  }










300












301



  SNodeAllocator* pAllocator = taosAcquireRef(g_allocatorReqRefPool, allocatorId);




1,340,134,259✔





302



  if (NULL == pAllocator) {




1,340,301,454✔





303



    return terrno;




×







304



  }










305



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




1,340,301,454✔





306



  g_pNodeAllocator = pAllocator;




1,340,273,147✔





307



  return TSDB_CODE_SUCCESS;




1,340,273,147✔





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;




952,597,179✔





313



  }










314












315



  if (NULL == g_pNodeAllocator) {




1,340,045,539✔





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,340,045,539✔





323



  g_pNodeAllocator = NULL;




1,340,045,539✔





324



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




1,340,045,539✔





325



  return taosReleaseRef(g_allocatorReqRefPool, allocatorId);




1,340,203,395✔





326



}










327












328



int64_t nodesMakeAllocatorWeakRef(int64_t allocatorId) {




257,224,432✔





329



  if (allocatorId <= 0) {




257,224,432✔





330



    return 0;




×







331



  }










332












333



  SNodeAllocator* pAllocator = taosAcquireRef(g_allocatorReqRefPool, allocatorId);




257,224,432✔





334



  if (NULL == pAllocator) {




257,257,316✔





335



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




319✔





336



    return -1;




×







337



  }










338



  return pAllocator->self;




257,257,000✔





339



}










340












341



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




736,473,913✔





342












343



void nodesDestroyAllocator(int64_t allocatorId) {




1,036,651,322✔





344



  if (allocatorId <= 0) {




1,036,651,322✔





345



    return;




571,941,230✔





346



  }










347












348



  int32_t code = taosRemoveRef(g_allocatorReqRefPool, allocatorId);




464,710,092✔





349



  if (TSDB_CODE_SUCCESS != code) {




464,749,392✔





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:




590,607,031✔





379



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




590,607,031✔





380



      break;




590,615,546✔





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:




925,392,579✔





385



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




925,392,579✔





386



      break;




925,429,351✔





387



    case QUERY_NODE_VIRTUAL_TABLE:




7,299,935✔





388



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




7,299,935✔





389



      break;




7,299,935✔





390



    case QUERY_NODE_TEMP_TABLE:




60,946,963✔





391



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




60,946,963✔





392



      break;




60,947,135✔





393



    case QUERY_NODE_PLACE_HOLDER_TABLE:




148,420✔





394



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




148,420✔





395



      break;




148,420✔





396



    case QUERY_NODE_TIME_RANGE:




4,334,281✔





397



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




4,334,281✔





398



      break;




4,334,281✔





399



    case QUERY_NODE_STREAM:




541,022✔





400



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




541,022✔





401



      break;




541,022✔





402



    case QUERY_NODE_STREAM_OUT_TABLE:




475,292✔





403



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




475,292✔





404



      break;




475,292✔





405



    case QUERY_NODE_JOIN_TABLE:




45,896,069✔





406



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




45,896,069✔





407



      break;




45,897,814✔





408



    case QUERY_NODE_GROUPING_SET:




213,710,303✔





409



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




213,710,303✔





410



      break;




213,725,024✔





411



    case QUERY_NODE_ORDER_BY_EXPR:




808,585,219✔





412



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




808,585,219✔





413



      break;




808,646,434✔





414



    case QUERY_NODE_LIMIT:




142,287,013✔





415



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




142,287,013✔





416



      break;




142,289,778✔





417



    case QUERY_NODE_STATE_WINDOW:




5,886,730✔





418



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




5,886,730✔





419



      break;




5,887,214✔





420



    case QUERY_NODE_SESSION_WINDOW:




14,761,269✔





421



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




14,761,269✔





422



      break;




14,762,137✔





423



    case QUERY_NODE_INTERVAL_WINDOW:




43,652,409✔





424



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




43,652,409✔





425



      break;




43,656,174✔





426



    case QUERY_NODE_SLIDING_WINDOW:




212,385✔





427



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




212,385✔





428



      break;




212,385✔





429



    case QUERY_NODE_PERIOD_WINDOW:




59,213✔





430



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




59,213✔





431



      break;




59,213✔





432



    case QUERY_NODE_STREAM_TRIGGER:




636,213✔





433



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




636,213✔





434



      break;




636,213✔





435



    case QUERY_NODE_STREAM_CALC_RANGE:




12,080✔





436



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




12,080✔





437



      break;




12,080✔





438



    case QUERY_NODE_STREAM_TAG_DEF:




299,729✔





439



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




299,729✔





440



      break;




299,729✔





441



    case QUERY_NODE_NODE_LIST:




1,111,139,978✔





442



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




1,111,139,978✔





443



      break;




1,111,185,281✔





444



    case QUERY_NODE_SURROUND:




82,173✔





445



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




82,173✔





446



      break;




82,173✔





447



    case QUERY_NODE_FILL:




4,376,720✔





448



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




4,376,720✔





449



      break;




4,380,520✔





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:




442,234,248✔





463



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




442,234,248✔





464



      break;




442,234,248✔





465



    case QUERY_NODE_DOWNSTREAM_SOURCE:




674,607,586✔





466



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




674,607,586✔





467



      break;




674,612,441✔





468



    case QUERY_NODE_DATABASE_OPTIONS:




1,939,855✔





469



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




1,939,855✔





470



      break;




1,939,855✔





471



    case QUERY_NODE_TABLE_OPTIONS:




52,867,243✔





472



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




52,867,243✔





473



      break;




52,870,233✔





474



    case QUERY_NODE_COLUMN_OPTIONS:




441,808,240✔





475



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




441,808,240✔





476



      break;




441,808,240✔





477



    case QUERY_NODE_INDEX_OPTIONS:




×







478



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




×







479



      break;




×







480



    case QUERY_NODE_EXPLAIN_OPTIONS:




102,814,476✔





481



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




102,814,476✔





482



      break;




102,818,511✔





483



    case QUERY_NODE_STREAM_TRIGGER_OPTIONS:




214,903✔





484



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




214,903✔





485



      break;




214,903✔





486



    case QUERY_NODE_LEFT_VALUE:




31,484,421✔





487



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




31,484,421✔





488



      break;




31,484,421✔





489



    case QUERY_NODE_COLUMN_REF:




213,265,829✔





490



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




213,265,829✔





491



      break;




213,265,829✔





492



    case QUERY_NODE_WHEN_THEN:




100,194,614✔





493



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




100,194,614✔





494



      break;




100,203,421✔





495



    case QUERY_NODE_CASE_WHEN:




98,723,913✔





496



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




98,723,913✔





497



      break;




98,740,191✔





498



    case QUERY_NODE_EVENT_WINDOW:




5,315,881✔





499



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




5,315,881✔





500



      break;




5,316,065✔





501



    case QUERY_NODE_COUNT_WINDOW:




4,977,388✔





502



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




4,977,388✔





503



      break;




4,978,358✔





504



    case QUERY_NODE_COUNT_WINDOW_ARGS:




4,974,262✔





505



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




4,974,262✔





506



      break;




4,975,114✔





507



    case QUERY_NODE_ANOMALY_WINDOW:




×







508



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




×







509



      break;




×







510



    case QUERY_NODE_EXTERNAL_WINDOW:




228,360✔





511



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




228,360✔





512



      break;




228,360✔





513



    case QUERY_NODE_HINT:




17,137,325✔





514



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




17,137,325✔





515



      break;




17,137,325✔





516



    case QUERY_NODE_VIEW:




393,638✔





517



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




393,638✔





518



      break;




393,638✔





519



    case QUERY_NODE_WINDOW_OFFSET:




2,014,083✔





520



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




2,014,083✔





521



      break;




2,014,083✔





522



    case QUERY_NODE_RANGE_AROUND:




1,571,484✔





523



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




1,571,484✔





524



      break;




1,570,975✔





525



    case QUERY_NODE_STREAM_NOTIFY_OPTIONS:




76,791✔





526



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




76,791✔





527



      break;




76,791✔





528



    case QUERY_NODE_REMOTE_VALUE:




729,885,063✔





529



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




729,885,063✔





530



      break;




729,972,347✔





531



    case QUERY_NODE_REMOTE_VALUE_LIST:




138,709,459✔





532



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




138,709,459✔





533



      break;




138,715,749✔





534



    case QUERY_NODE_REMOTE_ROW:




146,370,174✔





535



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




146,370,174✔





536



      break;




146,372,137✔





537



    case QUERY_NODE_REMOTE_ZERO_ROWS:




12,367,832✔





538



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




12,367,832✔





539



      break;




12,368,458✔






540



    case QUERY_NODE_REMOTE_TABLE:




986,982✔






541



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




986,982✔






542



      break;




986,982✔





543



    case QUERY_NODE_UPDATE_TAG_VALUE:




8,727,573✔





544



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




8,727,573✔





545



      break;




8,727,573✔





546



    case QUERY_NODE_ALTER_TABLE_UPDATE_TAG_VAL_CLAUSE:




8,611,515✔





547



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




8,611,515✔





548



      break;




8,611,515✔





549



    case QUERY_NODE_TRUE_FOR:




63,599✔





550



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




63,599✔





551



      break;




63,599✔





552



    case QUERY_NODE_SET_OPERATOR:




44,388,980✔





553



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




44,388,980✔





554



      break;




44,391,647✔





555



    case QUERY_NODE_SELECT_STMT:




769,697,752✔





556



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




769,697,752✔





557



      break;




769,721,203✔





558



    case QUERY_NODE_VNODE_MODIFY_STMT:




539,853,570✔





559



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




539,853,570✔





560



      break;




539,871,881✔





561



    case QUERY_NODE_CREATE_DATABASE_STMT:




1,595,912✔





562



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




1,595,912✔





563



      break;




1,595,912✔





564



    case QUERY_NODE_DROP_DATABASE_STMT:




1,319,008✔





565



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




1,319,008✔





566



      break;




1,319,008✔





567



    case QUERY_NODE_ALTER_DATABASE_STMT:




301,761✔





568



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




301,761✔





569



      break;




301,761✔





570



    case QUERY_NODE_FLUSH_DATABASE_STMT:




1,930,285✔





571



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




1,930,285✔





572



      break;




1,930,272✔





573



    case QUERY_NODE_TRIM_DATABASE_STMT:




14,189✔





574



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




14,189✔





575



      break;




14,189✔





576



    case QUERY_NODE_SSMIGRATE_DATABASE_STMT:




3,120✔





577



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




3,120✔





578



      break;




3,120✔





579



    case QUERY_NODE_CREATE_TABLE_STMT:




9,286,949✔





580



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




9,286,949✔





581



      break;




9,286,949✔





582



    case QUERY_NODE_CREATE_SUBTABLE_CLAUSE:




43,500,708✔





583



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




43,500,708✔





584



      break;




43,508,333✔





585



    case QUERY_NODE_CREATE_VIRTUAL_TABLE_STMT:




225,416✔





586



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




225,416✔





587



      break;




225,416✔





588



    case QUERY_NODE_CREATE_VIRTUAL_SUBTABLE_STMT:




398,549✔





589



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




398,549✔





590



      break;




398,549✔





591



    case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE:




1,429✔





592



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




1,429✔





593



      break;




1,429✔





594



    case QUERY_NODE_CREATE_MULTI_TABLES_STMT:




36,388,358✔





595



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




36,388,358✔





596



      break;




36,401,607✔





597



    case QUERY_NODE_DROP_TABLE_CLAUSE:




2,507,731✔





598



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




2,507,731✔





599



      break;




2,507,731✔





600



    case QUERY_NODE_DROP_TABLE_STMT:




2,393,875✔





601



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




2,393,875✔





602



      break;




2,393,875✔





603



    case QUERY_NODE_DROP_SUPER_TABLE_STMT:




94,076✔





604



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




94,076✔





605



      break;




94,076✔





606



    case QUERY_NODE_DROP_VIRTUAL_TABLE_STMT:




76,547✔





607



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




76,547✔





608



      break;




76,547✔





609



    case QUERY_NODE_ALTER_TABLE_STMT:




20,407,456✔





610



    case QUERY_NODE_ALTER_SUPER_TABLE_STMT:










611



    case QUERY_NODE_ALTER_VIRTUAL_TABLE_STMT:










612



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




20,407,456✔





613



      break;




20,407,456✔





614



    case QUERY_NODE_CREATE_MOUNT_STMT:




1,720✔





615



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




1,720✔





616



      break;




1,720✔





617



    case QUERY_NODE_DROP_MOUNT_STMT:




576✔





618



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




576✔





619



      break;




576✔





620



    case QUERY_NODE_CREATE_RSMA_STMT:




116,152✔





621



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




116,152✔





622



      break;




116,152✔





623



    case QUERY_NODE_DROP_RSMA_STMT:




10,664✔





624



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




10,664✔





625



      break;




10,664✔





626



    case QUERY_NODE_ALTER_RSMA_STMT:




21,552✔





627



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




21,552✔





628



      break;




21,552✔





629



    case QUERY_NODE_CREATE_USER_STMT:




108,156✔





630



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




108,156✔





631



      break;




108,156✔





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:




52,347✔





639



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




52,347✔





640



      break;




52,347✔





641



    case QUERY_NODE_DROP_USER_STMT:




52,353✔





642



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




52,353✔





643



      break;




52,353✔





644



    case QUERY_NODE_CREATE_ROLE_STMT:




2,063✔





645



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




2,063✔





646



      break;




2,063✔





647



    case QUERY_NODE_DROP_ROLE_STMT:




1,496✔





648



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




1,496✔





649



      break;




1,496✔





650



    case QUERY_NODE_ALTER_ROLE_STMT:




408✔





651



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




408✔





652



      break;




408✔





653



    case QUERY_NODE_USE_DATABASE_STMT:




92,667,076✔





654



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




92,667,076✔





655



      break;




92,667,116✔





656



    case QUERY_NODE_CREATE_DNODE_STMT:




181,354✔





657



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




181,354✔





658



      break;




181,354✔





659



    case QUERY_NODE_DROP_DNODE_STMT:




34,016✔





660



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




34,016✔





661



      break;




34,016✔





662



    case QUERY_NODE_ALTER_DNODE_STMT:




130,281✔





663



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




130,281✔





664



      break;




130,281✔





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,027✔





675



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




26,027✔





676



      break;




26,027✔





677



    case QUERY_NODE_DROP_BNODE_STMT:




30,835✔





678



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




30,835✔





679



      break;




30,835✔





680



    case QUERY_NODE_BNODE_OPTIONS:




26,027✔





681



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




26,027✔





682



      break;




26,027✔





683



    case QUERY_NODE_DATE_TIME_RANGE:




5,168✔





684



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




5,168✔





685



      break;




5,168✔





686



    case QUERY_NODE_IP_RANGE:




5,472✔





687



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




5,472✔





688



      break;




5,472✔





689



    case QUERY_NODE_USER_OPTIONS:




186,185✔





690



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




186,185✔





691



      break;




186,185✔





692



    case QUERY_NODE_TOKEN_OPTIONS:




27,703✔





693



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




27,703✔





694



      break;




27,703✔





695



    case QUERY_NODE_CREATE_INDEX_STMT:




22,604✔





696



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




22,604✔





697



      break;




22,604✔





698



    case QUERY_NODE_DROP_INDEX_STMT:




15,162✔





699



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




15,162✔





700



      break;




15,162✔





701



    case QUERY_NODE_CREATE_QNODE_STMT:




125,828✔





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




125,828✔





706



      break;




125,828✔





707



    case QUERY_NODE_DROP_QNODE_STMT:




73,246✔





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




73,246✔





712



      break;




73,246✔





713



    case QUERY_NODE_CREATE_TOPIC_STMT:




196,408✔





714



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




196,408✔





715



      break;




196,408✔





716



    case QUERY_NODE_DROP_TOPIC_STMT:




111,514✔





717



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




111,514✔





718



      break;




111,514✔





719



    case QUERY_NODE_DROP_CGROUP_STMT:




5,672✔





720



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




5,672✔





721



      break;




5,672✔





722



    case QUERY_NODE_ALTER_LOCAL_STMT:




465,751✔





723



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




465,751✔





724



      break;




465,751✔





725



    case QUERY_NODE_EXPLAIN_STMT:




94,427,844✔





726



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




94,427,844✔





727



      break;




94,439,183✔





728



    case QUERY_NODE_DESCRIBE_STMT:




554,691✔





729



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




554,691✔





730



      break;




554,722✔





731



    case QUERY_NODE_RESET_QUERY_CACHE_STMT:




2,153,388✔





732



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




2,153,388✔





733



      break;




2,153,388✔





734



    case QUERY_NODE_COMPACT_DATABASE_STMT:




41,233✔





735



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




41,233✔





736



      break;




41,233✔





737



    case QUERY_NODE_ROLLUP_DATABASE_STMT:




10,256✔





738



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




10,256✔





739



      break;




10,256✔





740



    case QUERY_NODE_SCAN_DATABASE_STMT:




780✔





741



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




780✔





742



      break;




780✔





743



    case QUERY_NODE_COMPACT_VGROUPS_STMT:




3,925✔





744



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




3,925✔





745



      break;




3,925✔





746



    case QUERY_NODE_ROLLUP_VGROUPS_STMT:




4,608✔





747



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




4,608✔





748



      break;




4,608✔





749



    case QUERY_NODE_SCAN_VGROUPS_STMT:




250✔





750



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




250✔





751



      break;




250✔





752



    case QUERY_NODE_CREATE_FUNCTION_STMT:




19,815✔





753



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




19,815✔





754



      break;




19,815✔





755



    case QUERY_NODE_DROP_FUNCTION_STMT:




8,942✔





756



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




8,942✔





757



      break;




8,942✔





758



    case QUERY_NODE_CREATE_STREAM_STMT:




627,011✔





759



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




627,011✔





760



      break;




627,011✔





761



    case QUERY_NODE_DROP_STREAM_STMT:




20,310✔





762



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




20,310✔





763



      break;




20,310✔





764



    case QUERY_NODE_PAUSE_STREAM_STMT:




3,026✔





765



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




3,026✔





766



      break;




3,026✔





767



    case QUERY_NODE_RESUME_STREAM_STMT:




2,658✔





768



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




2,658✔





769



      break;




2,658✔





770



    case QUERY_NODE_RECALCULATE_STREAM_STMT:




12,080✔





771



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




12,080✔





772



      break;




12,080✔





773












774



    case QUERY_NODE_BALANCE_VGROUP_STMT:




14,591✔





775



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




14,591✔





776



      break;




14,591✔





777



    case QUERY_NODE_ASSIGN_LEADER_STMT:




18✔





778



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




18✔





779



      break;




18✔





780



    case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT:




4,787✔





781



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




4,787✔





782



      break;




4,787✔





783



    case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT:




112✔





784



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




112✔





785



      break;




112✔





786



    case QUERY_NODE_SET_VGROUP_KEEP_VERSION_STMT:




1,711✔





787



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




1,711✔





788



      break;




1,711✔





789



    case QUERY_NODE_TRIM_DATABASE_WAL_STMT:




2,260✔





790



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




2,260✔





791



      break;




2,260✔





792



    case QUERY_NODE_CREATE_TOKEN_STMT:




22,457✔





793



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




22,457✔





794



      break;




22,457✔





795



    case QUERY_NODE_ALTER_TOKEN_STMT:




2,686✔





796



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




2,686✔





797



      break;




2,686✔





798



    case QUERY_NODE_DROP_TOKEN_STMT:




2,525✔





799



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




2,525✔





800



      break;




2,525✔





801



    case QUERY_NODE_CREATE_TOTP_SECRET_STMT:




17,481✔





802



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




17,481✔





803



      break;




17,481✔





804



    case QUERY_NODE_DROP_TOTP_SECRET_STMT:




6,720✔





805



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




6,720✔





806



      break;




6,720✔





807



    case QUERY_NODE_MERGE_VGROUP_STMT:




×







808



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




×







809



      break;




×







810



    case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:




47,664✔





811



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




47,664✔





812



      break;




47,664✔





813



    case QUERY_NODE_SPLIT_VGROUP_STMT:




24,090✔





814



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




24,090✔





815



      break;




24,090✔





816



    case QUERY_NODE_SYNCDB_STMT:




×







817



      break;




×







818



    case QUERY_NODE_GRANT_STMT:




913,436✔





819



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




913,436✔





820



      break;




913,436✔





821



    case QUERY_NODE_REVOKE_STMT:




492,597✔





822



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




492,597✔





823



      break;




492,597✔





824



    case QUERY_NODE_ALTER_CLUSTER_STMT:




954✔





825



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




954✔





826



      break;




954✔





827



    case QUERY_NODE_SHOW_DNODES_STMT:




3,326,151✔





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_DATABASES_STMT:










843



    case QUERY_NODE_SHOW_FUNCTIONS_STMT:










844



    case QUERY_NODE_SHOW_INDEXES_STMT:










845



    case QUERY_NODE_SHOW_STABLES_STMT:










846



    case QUERY_NODE_SHOW_STREAMS_STMT:










847



    case QUERY_NODE_SHOW_TABLES_STMT:










848



    case QUERY_NODE_SHOW_VTABLES_STMT:










849



    case QUERY_NODE_SHOW_USERS_STMT:










850



    case QUERY_NODE_SHOW_USERS_FULL_STMT:










851



    case QUERY_NODE_SHOW_ROLES_STMT:










852



    case QUERY_NODE_SHOW_LICENCES_STMT:










853



    case QUERY_NODE_SHOW_VGROUPS_STMT:










854



    case QUERY_NODE_SHOW_TOPICS_STMT:










855



    case QUERY_NODE_SHOW_CONSUMERS_STMT:










856



    case QUERY_NODE_SHOW_CONNECTIONS_STMT:










857



    case QUERY_NODE_SHOW_QUERIES_STMT:










858



    case QUERY_NODE_SHOW_VNODES_STMT:










859



    case QUERY_NODE_SHOW_APPS_STMT:










860



    case QUERY_NODE_SHOW_VARIABLES_STMT:










861



    case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:










862



    case QUERY_NODE_SHOW_TRANSACTIONS_STMT:










863



    case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:










864



    case QUERY_NODE_SHOW_TAGS_STMT:










865



    case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT:










866



    case QUERY_NODE_SHOW_ROLE_PRIVILEGES_STMT:










867



    case QUERY_NODE_SHOW_ROLE_COL_PRIVILEGES_STMT:










868



    case QUERY_NODE_SHOW_VIEWS_STMT:










869



    case QUERY_NODE_SHOW_GRANTS_FULL_STMT:










870



    case QUERY_NODE_SHOW_GRANTS_LOGS_STMT:










871



    case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT:










872



    case QUERY_NODE_SHOW_ENCRYPTIONS_STMT:










873



    case QUERY_NODE_SHOW_TSMAS_STMT:










874



    case QUERY_NODE_SHOW_USAGE_STMT:










875



    case QUERY_NODE_SHOW_MOUNTS_STMT:










876



    case QUERY_NODE_SHOW_RSMAS_STMT:










877



    case QUERY_NODE_SHOW_RETENTIONS_STMT:










878



    case QUERY_NODE_SHOW_INSTANCES_STMT:










879



    case QUERY_NODE_SHOW_ENCRYPT_ALGORITHMS_STMT:










880



    case QUERY_NODE_SHOW_ENCRYPT_STATUS_STMT:










881



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




3,326,151✔





882



      break;




3,326,151✔





883



    case QUERY_NODE_SHOW_TABLE_TAGS_STMT:




9,678✔





884



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




9,678✔





885



      break;




9,678✔





886



    case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:




40,262✔





887



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




40,262✔





888



      break;




40,262✔





889



    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:




60,850✔





890



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




60,850✔





891



      break;




60,850✔





892



    case QUERY_NODE_SHOW_DB_ALIVE_STMT:




5,059✔





893



    case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT:










894



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




5,059✔





895



      break;




5,059✔





896



    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:




100,384✔





897



    case QUERY_NODE_SHOW_CREATE_VTABLE_STMT:










898



    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:










899



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




100,384✔





900



      break;




100,384✔





901



    case QUERY_NODE_SHOW_CREATE_VIEW_STMT:




8,684✔





902



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




8,684✔





903



      break;




8,684✔





904



    case QUERY_NODE_SHOW_CREATE_RSMA_STMT:




3,256✔





905



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




3,256✔





906



      break;




3,256✔





907



    case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:




5,022✔





908



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




5,022✔





909



      break;




5,022✔





910



    case QUERY_NODE_SHOW_COMPACTS_STMT:




356,794✔





911



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




356,794✔





912



      break;




356,794✔





913



    case QUERY_NODE_SHOW_SCANS_STMT:




2,200✔





914



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




2,200✔





915



      break;




2,200✔





916



    case QUERY_NODE_SHOW_COMPACT_DETAILS_STMT:




31,584✔





917



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




31,584✔





918



      break;




31,584✔





919



    case QUERY_NODE_SHOW_RETENTION_DETAILS_STMT:




2,304✔





920



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




2,304✔





921



      break;




2,304✔





922



    case QUERY_NODE_SHOW_SCAN_DETAILS_STMT:




2,100✔





923



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




2,100✔





924



      break;




2,100✔





925



    case QUERY_NODE_SHOW_TRANSACTION_DETAILS_STMT:




297✔





926



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




297✔





927



      break;




297✔





928



    case QUERY_NODE_SHOW_SSMIGRATES_STMT:




92,160✔





929



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




92,160✔





930



      break;




92,160✔





931



    case QUERY_NODE_SHOW_TOKENS_STMT:




1,816✔





932



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




1,816✔





933



      break;




1,816✔





934



    case QUERY_NODE_KILL_QUERY_STMT:




178✔





935



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




178✔





936



      break;




178✔





937



    case QUERY_NODE_KILL_TRANSACTION_STMT:




2,678✔





938



    case QUERY_NODE_KILL_CONNECTION_STMT:










939



    case QUERY_NODE_KILL_COMPACT_STMT:










940



    case QUERY_NODE_KILL_RETENTION_STMT:










941



    case QUERY_NODE_KILL_SCAN_STMT:










942



    case QUERY_NODE_KILL_SSMIGRATE_STMT:










943



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




2,678✔





944



      break;




2,678✔





945



    case QUERY_NODE_DELETE_STMT:




1,877,798✔





946



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




1,877,798✔





947



      break;




1,877,798✔





948



    case QUERY_NODE_INSERT_STMT:




551,995✔





949



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




551,995✔





950



      break;




551,995✔





951



    case QUERY_NODE_QUERY:




932,209,225✔





952



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




932,209,225✔





953



      break;




932,228,429✔





954



    case QUERY_NODE_RESTORE_DNODE_STMT:




2,585✔





955



    case QUERY_NODE_RESTORE_QNODE_STMT:










956



    case QUERY_NODE_RESTORE_MNODE_STMT:










957



    case QUERY_NODE_RESTORE_VNODE_STMT:










958



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




2,585✔





959



      break;




2,585✔





960



    case QUERY_NODE_CREATE_VIEW_STMT:




223,057✔





961



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




223,057✔





962



      break;




223,057✔





963



    case QUERY_NODE_DROP_VIEW_STMT:




166,647✔





964



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




166,647✔





965



      break;




166,647✔





966



    case QUERY_NODE_CREATE_TSMA_STMT:




7,282✔





967



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




7,282✔





968



      break;




7,282✔





969



    case QUERY_NODE_DROP_TSMA_STMT:




3,483✔





970



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




3,483✔





971



      break;




3,483✔





972



    case QUERY_NODE_TSMA_OPTIONS:




8,143✔





973



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




8,143✔





974



      break;




8,143✔





975



    case QUERY_NODE_LOGIC_PLAN_SCAN:




1,060,142,297✔





976



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




1,060,142,297✔





977



      break;




1,060,225,315✔





978



    case QUERY_NODE_LOGIC_PLAN_JOIN:




51,357,115✔





979



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




51,357,115✔





980



      break;




51,358,367✔





981



    case QUERY_NODE_LOGIC_PLAN_AGG:




373,198,750✔





982



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




373,198,750✔





983



      break;




373,228,560✔





984



    case QUERY_NODE_LOGIC_PLAN_PROJECT:




760,754,276✔





985



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




760,754,276✔





986



      break;




760,846,848✔





987



    case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY:




1,101,759,269✔





988



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




1,101,759,269✔





989



      break;




1,101,802,833✔





990



    case QUERY_NODE_LOGIC_PLAN_EXCHANGE:




282,933,530✔





991



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




282,933,530✔





992



      break;




282,953,438✔





993



    case QUERY_NODE_LOGIC_PLAN_MERGE:




69,077,243✔





994



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




69,077,243✔





995



      break;




69,083,944✔





996



    case QUERY_NODE_LOGIC_PLAN_WINDOW:




84,655,775✔





997



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




84,655,775✔





998



      break;




84,678,216✔





999



    case QUERY_NODE_LOGIC_PLAN_FILL:




945,458✔





1000



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




945,458✔





1001



      break;




945,458✔





1002



    case QUERY_NODE_LOGIC_PLAN_SORT:




181,987,218✔





1003



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




181,987,218✔





1004



      break;




182,013,454✔





1005



    case QUERY_NODE_LOGIC_PLAN_PARTITION:




61,713,217✔





1006



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




61,713,217✔





1007



      break;




61,722,778✔





1008



    case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC:




11,609,319✔





1009



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




11,609,319✔





1010



      break;




11,609,319✔





1011



    case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC:




7,275,854✔





1012



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




7,275,854✔





1013



      break;




7,277,207✔





1014



    case QUERY_NODE_LOGIC_PLAN_FORECAST_FUNC:




×







1015



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




×







1016



      break;




×







1017



    case QUERY_NODE_LOGIC_PLAN_ANALYSIS_FUNC:




×







1018



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




×







1019



      break;




×







1020



    case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE:




3,935,418✔





1021



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




3,935,418✔





1022



      break;




3,935,418✔





1023



    case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL:




17,843,011✔





1024



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




17,843,011✔





1025



      break;




17,843,011✔





1026



    case QUERY_NODE_LOGIC_PLAN_VIRTUAL_TABLE_SCAN:




16,935,119✔





1027



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




16,935,119✔





1028



      break;




16,935,119✔





1029



    case QUERY_NODE_LOGIC_SUBPLAN:




2,147,483,647✔





1030



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




2,147,483,647✔





1031



      break;




2,147,483,647✔





1032



    case QUERY_NODE_LOGIC_PLAN:




902,494,065✔





1033



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




902,494,065✔





1034



      break;




902,624,626✔





1035



    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:




29,858,906✔





1036



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




29,858,906✔





1037



      break;




29,862,004✔





1038



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:




731,807,795✔





1039



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




731,807,795✔





1040



      break;




731,907,762✔





1041



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:




×







1042



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




×







1043



      break;




×







1044



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:




78,639,790✔





1045



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




78,639,790✔





1046



      break;




78,647,931✔





1047



    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:




442,844✔





1048



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




442,844✔





1049



      break;




443,138✔





1050



    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:




66,497,640✔





1051



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




66,497,640✔





1052



      break;




66,499,975✔





1053



    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:




13,221✔





1054



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




13,221✔





1055



      break;




13,221✔





1056



    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:




5,147,209✔





1057



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




5,147,209✔





1058



      break;




5,147,849✔





1059



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN:




80,469✔





1060



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




80,469✔





1061



      break;




80,469✔





1062



    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:




445,465,869✔





1063



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




445,465,869✔





1064



      break;




445,511,122✔





1065



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:




35,588,623✔





1066



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




35,588,623✔





1067



      break;




35,590,364✔





1068



    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN:




3,194,893✔





1069



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




3,194,893✔





1070



      break;




3,194,893✔





1071



    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:




332,553,039✔





1072



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




332,553,039✔





1073



      break;




332,577,172✔





1074



    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:




334,409,609✔





1075



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




334,409,609✔





1076



      break;




334,432,358✔





1077



    case QUERY_NODE_PHYSICAL_PLAN_MERGE:




48,618,786✔





1078



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




48,618,786✔





1079



      break;




48,625,163✔





1080



    case QUERY_NODE_PHYSICAL_PLAN_SORT:




117,817,763✔





1081



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




117,817,763✔





1082



      break;




117,835,770✔





1083



    case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT:




234,456✔





1084



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




234,456✔





1085



      break;




234,456✔





1086



    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:




28,209,564✔





1087



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




28,209,564✔





1088



      break;




28,214,986✔





1089



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL:




×







1090



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




×







1091



      break;




×







1092



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL:




4,278,239✔





1093



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




4,278,239✔





1094



      break;




4,279,396✔





1095



    case QUERY_NODE_PHYSICAL_PLAN_FILL:




1,014,632✔





1096



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




1,014,632✔





1097



      break;




1,015,033✔





1098



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:




5,846,776✔





1099



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




5,846,776✔





1100



      break;




5,849,361✔





1101



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:




5,400,739✔





1102



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




5,400,739✔





1103



      break;




5,402,420✔





1104



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:




4,272,532✔





1105



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




4,272,532✔





1106



      break;




4,273,914✔





1107



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT:




3,840,069✔





1108



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




3,840,069✔





1109



      break;




3,841,213✔





1110



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ANOMALY:




×







1111



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




×







1112



      break;




×







1113



    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:




22,199,791✔





1114



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




22,199,791✔





1115



      break;




22,204,367✔





1116



    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:




7,595,625✔





1117



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




7,595,625✔





1118



      break;




7,594,718✔





1119



    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:




7,157,140✔





1120



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




7,157,140✔





1121



      break;




7,157,986✔





1122



    case QUERY_NODE_PHYSICAL_PLAN_FORECAST_FUNC:




×







1123



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




×







1124



      break;




×







1125



    case QUERY_NODE_PHYSICAL_PLAN_ANALYSIS_FUNC:




×







1126



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




×







1127



      break;




×







1128



    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:




1,112,836,645✔





1129



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




1,112,836,645✔





1130



      break;




1,112,940,696✔





1131



    case QUERY_NODE_PHYSICAL_PLAN_INSERT:




558,091,536✔





1132



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




558,091,536✔





1133



      break;




558,148,132✔





1134



    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:




1,057,634✔





1135



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




1,057,634✔





1136



      break;




1,057,634✔





1137



    case QUERY_NODE_PHYSICAL_PLAN_DELETE:




3,629,478✔





1138



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




3,629,478✔





1139



      break;




3,629,478✔





1140



    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE:




3,193,279✔





1141



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




3,193,279✔





1142



      break;




3,193,279✔





1143



    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL:




10,624,085✔





1144



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




10,624,085✔





1145



      break;




10,624,085✔





1146



    case QUERY_NODE_PHYSICAL_SUBPLAN:




1,676,073,587✔





1147



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




1,676,073,587✔





1148



      break;




1,676,221,858✔





1149



    case QUERY_NODE_PHYSICAL_PLAN:




903,531,188✔





1150



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




903,531,188✔





1151



      break;




903,576,152✔





1152



    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN:




8,887,352✔





1153



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




8,887,352✔





1154



      break;




8,887,352✔





1155



    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:




3,620,876✔





1156



    case QUERY_NODE_PHYSICAL_PLAN_HASH_EXTERNAL:










1157



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_EXTERNAL:










1158



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




3,620,876✔





1159



      break;




3,621,098✔





1160



    case QUERY_NODE_SHOW_SCORES_STMT:




×







1161



      code = TSDB_CODE_OPS_NOT_SUPPORT;




×







1162



      break;




×







1163



    case QUERY_NODE_XNODE_TASK_OPTIONS:




18,900✔





1164



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




18,900✔





1165



      break;




18,900✔





1166



    case QUERY_NODE_XNODE_TASK_SOURCE_OPT:




4,410✔





1167



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




4,410✔





1168



      break;




4,410✔





1169



    case QUERY_NODE_XNODE_TASK_SINK_OPT:




4,536✔





1170



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




4,536✔





1171



      break;




4,536✔





1172



    case QUERY_NODE_CREATE_XNODE_STMT:




2,520✔





1173



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




2,520✔





1174



      break;




2,520✔





1175



    case QUERY_NODE_DROP_XNODE_STMT:




2,394✔





1176



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




2,394✔





1177



      break;




2,394✔





1178



    case QUERY_NODE_DRAIN_XNODE_STMT:




378✔





1179



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




378✔





1180



      break;




378✔





1181



    case QUERY_NODE_ALTER_XNODE_STMT:




882✔





1182



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




882✔





1183



      break;




882✔





1184



    case QUERY_NODE_CREATE_XNODE_TASK_STMT:




4,284✔





1185



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




4,284✔





1186



      break;




4,284✔





1187



    case QUERY_NODE_START_XNODE_TASK_STMT:




126✔





1188



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




126✔





1189



      break;




126✔





1190



    case QUERY_NODE_STOP_XNODE_TASK_STMT:




126✔





1191



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




126✔





1192



      break;




126✔





1193



    case QUERY_NODE_UPDATE_XNODE_TASK_STMT:




504✔





1194



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




504✔





1195



      break;




504✔





1196



    case QUERY_NODE_DROP_XNODE_TASK_STMT:




3,402✔





1197



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




3,402✔





1198



      break;




3,402✔





1199



    case QUERY_NODE_CREATE_XNODE_JOB_STMT:




10,962✔





1200



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




10,962✔





1201



      break;




10,962✔





1202



    case QUERY_NODE_ALTER_XNODE_JOB_STMT:




126✔





1203



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




126✔





1204



      break;




126✔





1205



    case QUERY_NODE_REBALANCE_XNODE_JOB_STMT:




252✔





1206



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




252✔





1207



      break;




252✔





1208



    case QUERY_NODE_REBALANCE_XNODE_JOB_WHERE_STMT:




756✔





1209



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




756✔





1210



      break;




756✔





1211



    case QUERY_NODE_DROP_XNODE_JOB_STMT:




20,664✔





1212



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




20,664✔





1213



      break;




20,664✔





1214



    case QUERY_NODE_CREATE_XNODE_AGENT_STMT:




2,394✔





1215



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




2,394✔





1216



      break;




2,394✔





1217



    case QUERY_NODE_ALTER_XNODE_AGENT_STMT:




378✔





1218



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




378✔





1219



      break;




378✔





1220



    case QUERY_NODE_DROP_XNODE_AGENT_STMT:




2,520✔





1221



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




2,520✔





1222



      break;




2,520✔





1223



    case QUERY_NODE_ALTER_DNODES_RELOAD_TLS_STMT:




×







1224



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




×







1225



      break;




×







1226



    case QUERY_NODE_ALTER_ENCRYPT_KEY_STMT:




296✔





1227



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




296✔





1228



      break;




296✔





1229



    case QUERY_NODE_ALTER_KEY_EXPIRATION_STMT:




×







1230



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




×







1231



      break;




×








UNCOV

1232



    case QUERY_NODE_SHOW_VALIDATE_VTABLE_STMT:




×








UNCOV

1233



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




×







1234



      break;




3,780✔






UNCOV

1235



    default:




×







1236













UNCOV

1237



      code = TSDB_CODE_OPS_NOT_SUPPORT;




×








UNCOV

1238



      break;




×







1239



  }










1240



  if (TSDB_CODE_SUCCESS != code) {




2,147,483,647✔





1241



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




×







1242



  } else










1243



    *ppNodeOut = pNode;




2,147,483,647✔





1244



  return code;




2,147,483,647✔





1245



}










1246












1247



static void destroyVgDataBlockArray(SArray* pArray) {




1,641,448,691✔





1248



  size_t size = taosArrayGetSize(pArray);




1,641,448,691✔





1249



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




2,147,483,647✔





1250



    SVgDataBlocks* pVg = taosArrayGetP(pArray, i);




558,096,480✔





1251



    taosMemoryFreeClear(pVg->pData);




558,132,188✔





1252



    taosMemoryFreeClear(pVg);




558,100,758✔





1253



  }










1254



  taosArrayDestroy(pArray);




1,641,501,166✔





1255



}




1,641,448,491✔





1256












1257



static void destroyLogicNode(SLogicNode* pNode) {




2,147,483,647✔





1258



  nodesDestroyList(pNode->pTargets);




2,147,483,647✔





1259



  nodesDestroyNode(pNode->pConditions);




2,147,483,647✔





1260



  nodesDestroyList(pNode->pChildren);




2,147,483,647✔





1261



  nodesDestroyNode(pNode->pLimit);




2,147,483,647✔





1262



  nodesDestroyNode(pNode->pSlimit);




2,147,483,647✔





1263



  nodesDestroyList(pNode->pHint);




2,147,483,647✔





1264



}




2,147,483,647✔





1265












1266



static void destroyPhysiNode(SPhysiNode* pNode) {




2,147,483,647✔





1267



  nodesDestroyList(pNode->pChildren);




2,147,483,647✔





1268



  nodesDestroyNode(pNode->pConditions);




2,147,483,647✔





1269



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




2,147,483,647✔





1270



  nodesDestroyNode(pNode->pLimit);




2,147,483,647✔





1271



  nodesDestroyNode(pNode->pSlimit);




2,147,483,647✔





1272



}




2,147,483,647✔





1273












1274



static void destroyWinodwPhysiNode(SWindowPhysiNode* pNode) {




55,490,858✔





1275



  destroyPhysiNode((SPhysiNode*)pNode);




55,490,858✔





1276



  nodesDestroyList(pNode->pExprs);




55,491,631✔





1277



  nodesDestroyList(pNode->pFuncs);




55,492,117✔





1278



  nodesDestroyNode(pNode->pTspk);




55,490,449✔





1279



  nodesDestroyNode(pNode->pTsEnd);




55,491,348✔





1280



  nodesDestroyList(pNode->pProjs);




55,491,431✔





1281



}




55,491,308✔





1282












1283



static void destroyPartitionPhysiNode(SPartitionPhysiNode* pNode) {




22,208,807✔





1284



  destroyPhysiNode((SPhysiNode*)pNode);




22,208,807✔





1285



  nodesDestroyList(pNode->pExprs);




22,208,154✔





1286



  nodesDestroyList(pNode->pPartitionKeys);




22,208,713✔





1287



  nodesDestroyList(pNode->pTargets);




22,207,494✔





1288



}




22,209,012✔





1289












1290



static void destroyScanPhysiNode(SScanPhysiNode* pNode) {




921,429,051✔





1291



  destroyPhysiNode((SPhysiNode*)pNode);




921,429,051✔





1292



  nodesDestroyList(pNode->pScanCols);




921,467,991✔





1293



  nodesDestroyList(pNode->pScanPseudoCols);




921,416,885✔





1294



}




921,451,316✔





1295












1296



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




1,675,724,961✔





1297












1298



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




2,147,483,647✔





1299












1300



static void destroyTableCfg(STableCfg* pCfg) {




104,164✔





1301



  if (NULL == pCfg) {




104,164✔





1302



    return;




15,103✔





1303



  }










1304



  taosArrayDestroy(pCfg->pFuncs);




89,061✔





1305



  taosMemoryFree(pCfg->pComment);




89,061✔





1306



  taosMemoryFree(pCfg->pSchemas);




89,061✔





1307



  taosMemoryFree(pCfg->pSchemaExt);




89,061✔





1308



  taosMemoryFree(pCfg->pColRefs);




89,061✔





1309



  taosMemoryFree(pCfg->pTagRefs);




89,061✔





1310



  taosMemoryFree(pCfg->pTags);




89,061✔





1311



  taosMemoryFree(pCfg);




89,061✔





1312



}










1313












1314



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




×







1315












1316



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




×







1317












1318



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




17,137,325✔





1319



  switch (option) {










1320



    default:










1321



      break;




17,137,325✔





1322



  }










1323












1324



  taosMemoryFree(value);




17,137,325✔





1325



}




17,137,325✔





1326













NEW


1327



void destroySSDataBlock(void* param) {




×








NEW


1328



  if (NULL == param) {




×








NEW


1329



    return;




×







1330



  }










1331













NEW


1332



  SSDataBlock* pBlock = (SSDataBlock*)param;




×








NEW


1333



  blockDataDestroy(pBlock);




×







1334



}










1335












1336



void nodesDestroyNode(SNode* pNode) {




2,147,483,647✔





1337



  if (NULL == pNode) {




2,147,483,647✔





1338



    return;




2,147,483,647✔





1339



  }










1340












1341



  switch (nodeType(pNode)) {




2,147,483,647✔





1342



    case QUERY_NODE_COLUMN:




2,147,483,647✔





1343



      destroyExprNode((SExprNode*)pNode);




2,147,483,647✔





1344



      break;




2,147,483,647✔





1345



    case QUERY_NODE_REMOTE_VALUE:




2,147,483,647✔





1346



    case QUERY_NODE_VALUE:










1347



    case QUERY_NODE_REMOTE_ROW:










1348



    case QUERY_NODE_REMOTE_ZERO_ROWS: {










1349



      SValueNode* pValue = (SValueNode*)pNode;




2,147,483,647✔





1350



      destroyExprNode((SExprNode*)pNode);




2,147,483,647✔





1351



      taosMemoryFreeClear(pValue->literal);




2,147,483,647✔





1352



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




2,147,483,647✔





1353



        taosMemoryFreeClear(pValue->datum.p);




569,961,679✔





1354



      }










1355



      break;




2,147,483,647✔





1356



    }










1357



    case QUERY_NODE_REMOTE_VALUE_LIST: {




138,924,833✔





1358



      SRemoteValueListNode* pRemote = (SRemoteValueListNode*)pNode;




138,924,833✔





1359



      destroyExprNode((SExprNode*)pNode);




138,924,833✔





1360



      if (pRemote->hashAllocated) {




138,927,372✔





1361



        taosHashCleanup(pRemote->pHashFilter);




10,704,634✔





1362



        taosHashCleanup(pRemote->pHashFilterOthers);




10,704,075✔





1363



      }










1364



      break;




138,928,118✔





1365



    }











1366



    case QUERY_NODE_REMOTE_TABLE: {




940,431✔






1367



      SRemoteTableNode* pRemote = (SRemoteTableNode*)pNode;




940,431✔






1368



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




940,431✔






NEW


1369



        taosArrayDestroyEx(pRemote->pResBlks, destroySSDataBlock);




×







1370



      }











1371



      pRemote->pResBlks = NULL;




940,431✔






1372



      break;




940,431✔





1373



    }










1374



    case QUERY_NODE_UPDATE_TAG_VALUE: {




8,727,573✔





1375



      SUpdateTagValueNode* pTagVal = (SUpdateTagValueNode*)pNode;




8,727,573✔





1376



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




8,727,573✔





1377



      taosMemoryFree(pTagVal->regexp);




8,727,573✔





1378



      taosMemoryFree(pTagVal->replacement);




8,727,573✔





1379



      break;




8,727,573✔





1380



    }










1381



    case QUERY_NODE_ALTER_TABLE_UPDATE_TAG_VAL_CLAUSE: {




8,611,515✔





1382



      SAlterTableUpdateTagValClause* pClause = (SAlterTableUpdateTagValClause*)pNode;




8,611,515✔





1383



      nodesDestroyList(pClause->pTagList);




8,611,515✔





1384



      break;




8,611,515✔





1385



    }










1386



    case QUERY_NODE_OPERATOR: {




2,147,483,647✔





1387



      SOperatorNode* pOp = (SOperatorNode*)pNode;




2,147,483,647✔





1388



      destroyExprNode((SExprNode*)pNode);




2,147,483,647✔





1389



      nodesDestroyNode(pOp->pLeft);




2,147,483,647✔





1390



      nodesDestroyNode(pOp->pRight);




2,147,483,647✔





1391



      break;




2,147,483,647✔





1392



    }










1393



    case QUERY_NODE_LOGIC_CONDITION:




598,724,534✔





1394



      destroyExprNode((SExprNode*)pNode);




598,724,534✔





1395



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




598,725,152✔





1396



      break;




598,728,241✔





1397



    case QUERY_NODE_FUNCTION:




2,147,483,647✔





1398



      destroyExprNode((SExprNode*)pNode);




2,147,483,647✔





1399



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




2,147,483,647✔





1400



      break;




2,147,483,647✔





1401



    case QUERY_NODE_REAL_TABLE: {




984,272,171✔





1402



      SRealTableNode* pReal = (SRealTableNode*)pNode;




984,272,171✔





1403



      taosMemoryFreeClear(pReal->pMeta);




984,272,171✔





1404



      taosMemoryFreeClear(pReal->pVgroupList);




984,289,151✔





1405



      taosArrayDestroyEx(pReal->pSmaIndexes, destroySmaIndex);




984,300,026✔





1406



      taosArrayDestroyP(pReal->tsmaTargetTbVgInfo, NULL);




984,258,123✔





1407



      taosArrayDestroy(pReal->tsmaTargetTbInfo);




984,268,042✔





1408



      break;




984,273,294✔





1409



    }










1410



    case QUERY_NODE_VIRTUAL_TABLE: {




7,299,351✔





1411



      SVirtualTableNode* pVirtual = (SVirtualTableNode*)pNode;




7,299,351✔





1412



      taosMemoryFreeClear(pVirtual->pMeta);




7,299,351✔





1413



      taosMemoryFreeClear(pVirtual->pVgroupList);




7,299,351✔





1414



      nodesDestroyList(pVirtual->refTables);




7,299,351✔





1415



      break;




7,299,351✔





1416



    }










1417



    case QUERY_NODE_TEMP_TABLE:




60,947,227✔





1418



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




60,947,227✔





1419



      break;




60,947,141✔





1420



    case QUERY_NODE_PLACE_HOLDER_TABLE: {




148,420✔





1421



      SPlaceHolderTableNode* pPlaceHolder = (SPlaceHolderTableNode*)pNode;




148,420✔





1422



      taosMemoryFreeClear(pPlaceHolder->pMeta);




148,420✔





1423



      taosMemoryFreeClear(pPlaceHolder->pVgroupList);




148,420✔





1424



      break;




148,420✔





1425



    }










1426



    case QUERY_NODE_TIME_RANGE: {




4,332,130✔





1427



      STimeRangeNode* pTimeRange = (STimeRangeNode*)pNode;




4,332,130✔





1428



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




4,332,130✔





1429



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




4,332,130✔





1430



      break;




4,332,130✔





1431



    }










1432



    case QUERY_NODE_STREAM: {




528,526✔





1433



      SStreamNode* pStream = (SStreamNode*)pNode;




528,526✔





1434



      destroyExprNode((SExprNode*)pNode);




528,526✔





1435



      break;




528,526✔





1436



    }










1437



    case QUERY_NODE_STREAM_OUT_TABLE: {




6,224✔





1438



      SStreamOutTableNode* pOut = (SStreamOutTableNode*)pNode;




6,224✔





1439



      nodesDestroyNode(pOut->pOutTable);




6,224✔





1440



      nodesDestroyNode(pOut->pSubtable);




6,224✔





1441



      nodesDestroyList(pOut->pTags);




6,224✔





1442



      nodesDestroyList(pOut->pCols);




6,224✔





1443



      break;




6,224✔





1444



    }










1445



    case QUERY_NODE_JOIN_TABLE: {




49,840,512✔





1446



      SJoinTableNode* pJoin = (SJoinTableNode*)pNode;




49,840,512✔





1447



      nodesDestroyNode(pJoin->pWindowOffset);




49,840,512✔





1448



      nodesDestroyNode(pJoin->pJLimit);




49,838,172✔





1449



      nodesDestroyNode(pJoin->addPrimCond);




49,840,575✔





1450



      nodesDestroyNode(pJoin->pLeft);




49,841,231✔





1451



      nodesDestroyNode(pJoin->pRight);




49,841,668✔





1452



      nodesDestroyNode(pJoin->pOnCond);




49,841,792✔





1453



      break;




49,841,374✔





1454



    }










1455



    case QUERY_NODE_GROUPING_SET:




213,725,011✔





1456



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




213,725,011✔





1457



      break;




213,726,564✔





1458



    case QUERY_NODE_ORDER_BY_EXPR:




808,619,430✔





1459



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




808,619,430✔





1460



      break;




808,658,926✔





1461



    case QUERY_NODE_LIMIT: {




142,288,018✔





1462



      SLimitNode* pLimit = (SLimitNode*)pNode;




142,288,018✔





1463



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




142,288,018✔





1464



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




142,288,390✔





1465



      break;




142,288,817✔





1466



    }










1467



    case QUERY_NODE_STATE_WINDOW: {




5,887,027✔





1468



      SStateWindowNode* pState = (SStateWindowNode*)pNode;




5,887,027✔





1469



      nodesDestroyNode(pState->pCol);




5,887,027✔





1470



      nodesDestroyNode(pState->pExpr);




5,887,027✔





1471



      nodesDestroyNode(pState->pTrueForLimit);




5,887,027✔





1472



      nodesDestroyNode(pState->pExtend);




5,887,027✔





1473



      nodesDestroyNode(pState->pZeroth);




5,887,027✔





1474



      break;




5,887,027✔





1475



    }










1476



    case QUERY_NODE_SESSION_WINDOW: {




17,577,097✔





1477



      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;




17,577,097✔





1478



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




17,577,097✔





1479



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




17,577,267✔





1480



      break;




17,578,715✔





1481



    }










1482



    case QUERY_NODE_INTERVAL_WINDOW: {




50,557,963✔





1483



      SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;




50,557,963✔





1484



      nodesDestroyNode(pInterval->pCol);




50,557,963✔





1485



      nodesDestroyNode(pInterval->pInterval);




50,558,051✔





1486



      nodesDestroyNode(pInterval->pOffset);




50,560,209✔





1487



      nodesDestroyNode(pInterval->pSliding);




50,556,989✔





1488



      nodesDestroyNode(pInterval->pSOffset);




50,558,146✔





1489



      nodesDestroyNode(pInterval->pFill);




50,559,358✔





1490



      break;




50,560,018✔





1491



    }










1492



    case QUERY_NODE_SLIDING_WINDOW: {




×







1493



      SSlidingWindowNode* pSliding = (SSlidingWindowNode*)pNode;




×







1494



      nodesDestroyNode(pSliding->pSlidingVal);




×







1495



      nodesDestroyNode(pSliding->pOffset);




×







1496



      break;




×







1497



    }










1498



    case QUERY_NODE_PERIOD_WINDOW: {




59,213✔





1499



      SPeriodWindowNode* pPeriod = (SPeriodWindowNode*)pNode;




59,213✔





1500



      nodesDestroyNode(pPeriod->pPeroid);




59,213✔





1501



      nodesDestroyNode(pPeriod->pOffset);




59,213✔





1502



      break;




59,213✔





1503



    }










1504



    case QUERY_NODE_NODE_LIST:




1,110,710,296✔





1505



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




1,110,710,296✔





1506



      break;




1,110,683,026✔





1507



    case QUERY_NODE_SURROUND: {




82,173✔





1508



      SSurroundNode* pSurround = (SSurroundNode*)pNode;




82,173✔





1509



      nodesDestroyNode(pSurround->pSurroundingTime);




82,173✔





1510



      nodesDestroyNode(pSurround->pValues);




82,173✔





1511



      break;




82,173✔





1512



    }










1513



    case QUERY_NODE_FILL: {




4,380,520✔





1514



      SFillNode* pFill = (SFillNode*)pNode;




4,380,520✔





1515



      nodesDestroyNode(pFill->pValues);




4,380,520✔





1516



      nodesDestroyNode(pFill->pWStartTs);




4,380,520✔





1517



      nodesDestroyNode(pFill->pTimeRange);




4,380,520✔





1518



      nodesDestroyNode(pFill->pSurroundingTime);




4,380,520✔





1519



      break;




4,380,520✔





1520



    }










1521



    case QUERY_NODE_RAW_EXPR:




2,147,483,647✔





1522



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




2,147,483,647✔





1523



      break;




2,147,483,647✔





1524



    case QUERY_NODE_STREAM_TAG_DEF:




299,729✔





1525



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




299,729✔





1526



      break;




299,729✔





1527



    case QUERY_NODE_TARGET:




2,147,483,647✔





1528



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




2,147,483,647✔





1529



      break;




2,147,483,647✔





1530



    case QUERY_NODE_DATABLOCK_DESC:




2,147,483,647✔





1531



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




2,147,483,647✔





1532



      break;




2,147,483,647✔





1533



    case QUERY_NODE_SLOT_DESC:  // no pointer field




2,147,483,647✔





1534



      break;




2,147,483,647✔





1535



    case QUERY_NODE_COLUMN_DEF:




442,234,248✔





1536



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




442,234,248✔





1537



      break;




442,234,248✔





1538



    case QUERY_NODE_DOWNSTREAM_SOURCE:  // no pointer field




674,542,276✔





1539



      break;




674,542,276✔





1540



    case QUERY_NODE_DATABASE_OPTIONS: {




1,939,855✔





1541



      SDatabaseOptions* pOptions = (SDatabaseOptions*)pNode;




1,939,855✔





1542



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




1,939,855✔





1543



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




1,939,855✔





1544



      nodesDestroyList(pOptions->pKeep);




1,939,855✔





1545



      nodesDestroyList(pOptions->pRetentions);




1,939,855✔





1546



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




1,939,855✔





1547



      nodesDestroyList(pOptions->pCompactTimeRangeList);




1,939,855✔





1548



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




1,939,855✔





1549



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




1,939,855✔





1550



      break;




1,939,855✔





1551



    }










1552



    case QUERY_NODE_TABLE_OPTIONS: {




52,859,740✔





1553



      STableOptions* pOptions = (STableOptions*)pNode;




52,859,740✔





1554



      nodesDestroyList(pOptions->pMaxDelay);




52,859,740✔





1555



      nodesDestroyList(pOptions->pWatermark);




52,859,318✔





1556



      nodesDestroyList(pOptions->pRollupFuncs);




52,853,471✔





1557



      nodesDestroyList(pOptions->pSma);




52,852,551✔





1558



      nodesDestroyList(pOptions->pDeleteMark);




52,847,615✔





1559



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




52,839,786✔





1560



      break;




52,838,198✔





1561



    }










1562



    case QUERY_NODE_COLUMN_OPTIONS: {




435,124,505✔





1563



      SColumnOptions* pOptions = (SColumnOptions*)pNode;




435,124,505✔





1564



      break;




435,124,505✔





1565



    }










1566



    case QUERY_NODE_INDEX_OPTIONS: {




×







1567



      SIndexOptions* pOptions = (SIndexOptions*)pNode;




×







1568



      nodesDestroyList(pOptions->pFuncs);




×







1569



      nodesDestroyNode(pOptions->pInterval);




×







1570



      nodesDestroyNode(pOptions->pOffset);




×







1571



      nodesDestroyNode(pOptions->pSliding);




×







1572



      nodesDestroyNode(pOptions->pStreamOptions);




×







1573



      break;




×







1574



    }










1575



    case QUERY_NODE_EXPLAIN_OPTIONS:  // no pointer field




102,796,839✔





1576



      break;




102,796,839✔





1577



    case QUERY_NODE_STREAM_TRIGGER: {




636,213✔





1578



      SStreamTriggerNode* pTrigger = (SStreamTriggerNode*)pNode;




636,213✔





1579



      nodesDestroyNode(pTrigger->pTriggerWindow);




636,213✔





1580



      nodesDestroyNode(pTrigger->pTrigerTable);




636,213✔





1581



      nodesDestroyNode(pTrigger->pOptions);




636,213✔





1582



      nodesDestroyNode(pTrigger->pNotify);




636,213✔





1583



      nodesDestroyList(pTrigger->pPartitionList);




636,213✔





1584



      break;




636,213✔





1585



    }










1586



    case QUERY_NODE_STREAM_CALC_RANGE: {




12,080✔





1587



      SStreamCalcRangeNode* pRange = (SStreamCalcRangeNode*)pNode;




12,080✔





1588



      nodesDestroyNode(pRange->pStart);




12,080✔





1589



      nodesDestroyNode(pRange->pEnd);




12,080✔





1590



      break;




12,080✔





1591



    }










1592



    case QUERY_NODE_STREAM_TRIGGER_OPTIONS: {




214,903✔





1593



      SStreamTriggerOptions* pOptions = (SStreamTriggerOptions*)pNode;




214,903✔





1594



      nodesDestroyNode(pOptions->pPreFilter);




214,903✔





1595



      nodesDestroyNode(pOptions->pMaxDelay);




214,903✔





1596



      nodesDestroyNode(pOptions->pWaterMark);




214,903✔





1597



      nodesDestroyNode(pOptions->pExpiredTime);




214,903✔





1598



      nodesDestroyNode(pOptions->pFillHisStartTime);




214,903✔





1599



      nodesDestroyNode(pOptions->pIdleTimeout);




214,903✔





1600



      break;




214,903✔





1601



    }










1602



    case QUERY_NODE_TSMA_OPTIONS: {




8,143✔





1603



      STSMAOptions* pOptions = (STSMAOptions*)pNode;




8,143✔





1604



      nodesDestroyList(pOptions->pFuncs);




8,143✔





1605



      nodesDestroyNode(pOptions->pInterval);




8,143✔





1606



      break;




8,143✔





1607



    }










1608



    case QUERY_NODE_LEFT_VALUE:  // no pointer field




90,380,676✔





1609



    case QUERY_NODE_COLUMN_REF:  // no pointer field










1610



      break;




90,380,676✔





1611



    case QUERY_NODE_WHEN_THEN: {




100,196,773✔





1612



      SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;




100,196,773✔





1613



      destroyExprNode((SExprNode*)pNode);




100,196,773✔





1614



      nodesDestroyNode(pWhenThen->pWhen);




100,195,495✔





1615



      nodesDestroyNode(pWhenThen->pThen);




100,206,141✔





1616



      break;




100,205,458✔





1617



    }










1618



    case QUERY_NODE_CASE_WHEN: {




98,727,214✔





1619



      SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;




98,727,214✔





1620



      destroyExprNode((SExprNode*)pNode);




98,727,214✔





1621



      nodesDestroyNode(pCaseWhen->pCase);




98,729,849✔





1622



      nodesDestroyNode(pCaseWhen->pElse);




98,739,429✔





1623



      nodesDestroyList(pCaseWhen->pWhenThenList);




98,744,416✔





1624



      break;




98,744,666✔





1625



    }










1626



    case QUERY_NODE_EVENT_WINDOW: {




5,316,473✔





1627



      SEventWindowNode* pEvent = (SEventWindowNode*)pNode;




5,316,473✔





1628



      nodesDestroyNode(pEvent->pCol);




5,316,473✔





1629



      nodesDestroyNode(pEvent->pStartCond);




5,316,473✔





1630



      nodesDestroyNode(pEvent->pEndCond);




5,316,380✔





1631



      nodesDestroyNode(pEvent->pTrueForLimit);




5,316,297✔





1632



      break;




5,315,976✔





1633



    }










1634



    case QUERY_NODE_COUNT_WINDOW: {




4,978,372✔





1635



      SCountWindowNode* pEvent = (SCountWindowNode*)pNode;




4,978,372✔





1636



      nodesDestroyNode(pEvent->pCol);




4,978,372✔





1637



      nodesDestroyList(pEvent->pColList);




4,978,372✔





1638



      break;




4,978,451✔





1639



    }










1640



    case QUERY_NODE_COUNT_WINDOW_ARGS: {




4,974,382✔





1641



      SCountWindowArgs* pEvent = (SCountWindowArgs*)pNode;




4,974,382✔





1642



      nodesDestroyList(pEvent->pColList);




4,974,382✔





1643



      break;




4,974,418✔





1644



    }










1645



    case QUERY_NODE_ANOMALY_WINDOW: {




×







1646



      SAnomalyWindowNode* pAnomaly = (SAnomalyWindowNode*)pNode;




×







1647



      nodesDestroyNode(pAnomaly->pCol);




×







1648



      nodesDestroyList(pAnomaly->pExpr);




×







1649



      break;




×







1650



    }










1651



    case QUERY_NODE_EXTERNAL_WINDOW: {




228,360✔





1652



      SExternalWindowNode* pExternal = (SExternalWindowNode*)pNode;




228,360✔





1653



      nodesDestroyList(pExternal->pAggFuncList);




228,360✔





1654



      nodesDestroyList(pExternal->pProjectionList);




228,360✔





1655



      nodesDestroyNode(pExternal->pTimeRange);




228,360✔





1656



      taosMemoryFreeClear(pExternal->timezone);




228,360✔






1657



      nodesDestroyNode(pExternal->pCol);




228,360✔






1658



      nodesDestroyNode(pExternal->pSubquery);




228,360✔






1659



      nodesDestroyNode(pExternal->pFill);




228,360✔






1660



      break;




228,360✔





1661



    }










1662



    case QUERY_NODE_HINT: {




17,137,325✔





1663



      SHintNode* pHint = (SHintNode*)pNode;




17,137,325✔





1664



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




17,137,325✔





1665



      break;




17,137,325✔





1666



    }










1667



    case QUERY_NODE_VIEW: {




393,638✔





1668



      SViewNode* pView = (SViewNode*)pNode;




393,638✔





1669



      taosMemoryFreeClear(pView->pMeta);




393,638✔





1670



      taosMemoryFreeClear(pView->pVgroupList);




393,638✔





1671



      taosArrayDestroyEx(pView->pSmaIndexes, destroySmaIndex);




393,638✔





1672



      break;




393,638✔





1673



    }










1674



    case QUERY_NODE_WINDOW_OFFSET: {




2,014,083✔





1675



      SWindowOffsetNode* pWin = (SWindowOffsetNode*)pNode;




2,014,083✔





1676



      nodesDestroyNode(pWin->pStartOffset);




2,014,083✔





1677



      nodesDestroyNode(pWin->pEndOffset);




2,014,083✔





1678



      break;




2,014,083✔





1679



    }










1680



    case QUERY_NODE_RANGE_AROUND: {




1,571,906✔





1681



      SRangeAroundNode* pAround = (SRangeAroundNode*)pNode;




1,571,906✔





1682



      nodesDestroyNode(pAround->pInterval);




1,571,906✔





1683



      nodesDestroyNode(pAround->pRange);




1,571,906✔





1684



      break;




1,571,906✔





1685



    }










1686



    case QUERY_NODE_STREAM_NOTIFY_OPTIONS: {




76,791✔





1687



      SStreamNotifyOptions* pNotifyOptions = (SStreamNotifyOptions*)pNode;




76,791✔





1688



      nodesDestroyList(pNotifyOptions->pAddrUrls);




76,791✔





1689



      nodesDestroyNode(pNotifyOptions->pWhere);




76,791✔





1690



      break;




76,791✔





1691



    }










1692



    case QUERY_NODE_TRUE_FOR: {




63,599✔





1693



      STrueForNode* pTrueFor = (STrueForNode*)pNode;




63,599✔





1694



      nodesDestroyNode(pTrueFor->pDuration);




63,599✔





1695



      break;




63,599✔





1696



    }










1697



    case QUERY_NODE_SET_OPERATOR: {




44,481,082✔





1698



      SSetOperator* pStmt = (SSetOperator*)pNode;




44,481,082✔





1699



      nodesDestroyList(pStmt->pSubQueries);




44,481,082✔





1700



      nodesDestroyList(pStmt->pProjectionList);




44,482,000✔





1701



      nodesDestroyNode(pStmt->pLeft);




44,483,422✔





1702



      nodesDestroyNode(pStmt->pRight);




44,483,624✔





1703



      nodesDestroyList(pStmt->pOrderByList);




44,483,420✔





1704



      nodesDestroyNode(pStmt->pLimit);




44,483,459✔





1705



      break;




44,483,393✔





1706



    }










1707



    case QUERY_NODE_SELECT_STMT: {




825,540,521✔





1708



      SSelectStmt* pStmt = (SSelectStmt*)pNode;




825,540,521✔





1709



      nodesDestroyList(pStmt->pSubQueries);




825,540,521✔





1710



      nodesDestroyNode(pStmt->pTimeRange);




825,550,985✔





1711



      nodesDestroyList(pStmt->pProjectionList);




825,566,754✔





1712



      nodesDestroyList(pStmt->pProjectionBindList);




825,565,472✔





1713



      nodesDestroyNode(pStmt->pFromTable);




825,579,096✔





1714



      nodesDestroyNode(pStmt->pWhere);




825,590,539✔





1715



      nodesDestroyList(pStmt->pPartitionByList);




825,588,123✔





1716



      nodesDestroyNode(pStmt->pWindow);




825,572,189✔





1717



      nodesDestroyList(pStmt->pGroupByList);




825,577,018✔





1718



      nodesDestroyNode(pStmt->pHaving);




825,575,306✔





1719



      nodesDestroyNode(pStmt->pRange);




825,575,949✔





1720



      nodesDestroyNode(pStmt->pRangeAround);




825,572,035✔





1721



      nodesDestroyNode(pStmt->pEvery);




825,571,882✔





1722



      nodesDestroyNode(pStmt->pFill);




825,576,937✔





1723



      nodesDestroyList(pStmt->pOrderByList);




825,577,706✔





1724



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




825,573,136✔





1725



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




825,575,620✔





1726



      nodesDestroyList(pStmt->pHint);




825,582,204✔





1727



      break;




825,583,848✔





1728



    }










1729



    case QUERY_NODE_VNODE_MODIFY_STMT: {




539,740,142✔





1730



      SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)pNode;




539,740,142✔





1731



      destroyVgDataBlockArray(pStmt->pDataBlocks);




539,740,142✔





1732



      taosMemoryFreeClear(pStmt->pTableMeta);




539,741,697✔





1733



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




539,737,935✔





1734



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




539,741,863✔





1735



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




539,743,645✔





1736



      taosHashCleanup(pStmt->pVgroupsHashObj);




539,745,199✔





1737



      taosHashCleanup(pStmt->pSubTableHashObj);




539,739,906✔





1738



      taosHashCleanup(pStmt->pSuperTableHashObj);




539,742,716✔





1739



      taosHashCleanup(pStmt->pTableNameHashObj);




539,742,002✔





1740



      taosHashCleanup(pStmt->pDbFNameHashObj);




539,738,915✔





1741



      taosHashCleanup(pStmt->pTableCxtHashObj);




539,738,628✔





1742



      if (pStmt->freeHashFunc) {




539,738,324✔





1743



        pStmt->freeHashFunc(pStmt->pTableBlockHashObj);




479,564,011✔





1744



      }










1745



      if (pStmt->freeArrayFunc) {




539,737,886✔





1746



        pStmt->freeArrayFunc(pStmt->pVgDataBlocks);




479,562,361✔





1747



      }










1748



      tdDestroySVCreateTbReq(pStmt->pCreateTblReq);




539,741,711✔





1749



      taosMemoryFreeClear(pStmt->pCreateTblReq);




539,745,979✔





1750



      if (pStmt->freeStbRowsCxtFunc) {




539,746,297✔





1751



        pStmt->freeStbRowsCxtFunc(pStmt->pStbRowsCxt);




479,001,365✔





1752



      }










1753



      taosMemoryFreeClear(pStmt->pStbRowsCxt);




539,737,895✔





1754












1755



      taosMemoryFreeClear(pStmt->pCreateTbInfo);




539,738,220✔





1756












1757



      if (pStmt->destroyParseFileCxt) {




539,745,908✔





1758



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




1,429✔





1759



      }










1760












1761



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




539,742,924✔





1762



      if (TSDB_CODE_SUCCESS != code) {




539,735,425✔





1763



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




×







1764



      }










1765



      break;




539,740,487✔





1766



    }










1767



    case QUERY_NODE_CREATE_DATABASE_STMT: {




1,595,912✔





1768



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




1,595,912✔





1769



      taosMemoryFreeClear(pOptions->pDbCfg);




1,595,912✔





1770



      nodesDestroyNode((SNode*)pOptions);




1,595,912✔





1771



      break;




1,595,912✔





1772



    }










1773



    case QUERY_NODE_DROP_DATABASE_STMT:  // no pointer field




1,319,008✔





1774



      break;




1,319,008✔





1775



    case QUERY_NODE_ALTER_DATABASE_STMT: {




301,761✔





1776



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




301,761✔





1777



      taosMemoryFreeClear(pOptions->pDbCfg);




301,761✔





1778



      nodesDestroyNode((SNode*)pOptions);




301,761✔





1779



      break;




301,761✔





1780



    }










1781



    case QUERY_NODE_FLUSH_DATABASE_STMT:  // no pointer field




1,944,474✔





1782



    case QUERY_NODE_TRIM_DATABASE_STMT:   // no pointer field










1783



      break;




1,944,474✔





1784



    case QUERY_NODE_SSMIGRATE_DATABASE_STMT:  // no pointer field




3,120✔





1785



      break;




3,120✔





1786



    case QUERY_NODE_CREATE_TABLE_STMT: {




9,286,949✔





1787



      SCreateTableStmt* pStmt = (SCreateTableStmt*)pNode;




9,286,949✔





1788



      nodesDestroyList(pStmt->pCols);




9,286,949✔





1789



      nodesDestroyList(pStmt->pTags);




9,286,949✔





1790



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




9,286,949✔





1791



      break;




9,286,949✔





1792



    }










1793



    case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: {




43,490,789✔





1794



      SCreateSubTableClause* pStmt = (SCreateSubTableClause*)pNode;




43,490,789✔





1795



      nodesDestroyList(pStmt->pSpecificTags);




43,490,789✔





1796



      nodesDestroyList(pStmt->pValsOfTags);




43,474,740✔





1797



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




43,502,388✔





1798



      break;




43,468,949✔





1799



    }










1800



    case QUERY_NODE_CREATE_VIRTUAL_TABLE_STMT: {




225,416✔





1801



      SCreateVTableStmt* pStmt = (SCreateVTableStmt*)pNode;




225,416✔





1802



      nodesDestroyList(pStmt->pCols);




225,416✔





1803



      break;




225,416✔





1804



    }










1805



    case QUERY_NODE_CREATE_VIRTUAL_SUBTABLE_STMT: {




398,549✔





1806



      SCreateVSubTableStmt* pStmt = (SCreateVSubTableStmt*)pNode;




398,549✔





1807



      nodesDestroyList(pStmt->pSpecificColRefs);




398,549✔





1808



      nodesDestroyList(pStmt->pColRefs);




398,549✔





1809



      nodesDestroyList(pStmt->pSpecificTags);




398,549✔





1810



      nodesDestroyList(pStmt->pValsOfTags);




398,549✔





1811



      nodesDestroyList(pStmt->pSpecificTagRefs);




398,549✔





1812



      nodesDestroyList(pStmt->pTagRefs);




398,549✔





1813



      break;




398,549✔





1814



    }










1815



    case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE: {




1,429✔





1816



      SCreateSubTableFromFileClause* pStmt = (SCreateSubTableFromFileClause*)pNode;




1,429✔





1817



      nodesDestroyList(pStmt->pSpecificTags);




1,429✔





1818



      break;




1,429✔





1819



    }










1820



    case QUERY_NODE_CREATE_MULTI_TABLES_STMT:




36,386,295✔





1821



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




36,386,295✔





1822



      break;




36,367,662✔





1823



    case QUERY_NODE_DROP_TABLE_CLAUSE:  // no pointer field




2,507,536✔





1824



      break;




2,507,536✔





1825



    case QUERY_NODE_DROP_TABLE_STMT:




2,393,680✔





1826



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




2,393,680✔





1827



      break;




2,393,680✔





1828



    case QUERY_NODE_DROP_SUPER_TABLE_STMT:




170,623✔





1829



    case QUERY_NODE_DROP_VIRTUAL_TABLE_STMT:  // no pointer field










1830



      break;




170,623✔





1831



    case QUERY_NODE_ALTER_TABLE_STMT:




20,407,456✔





1832



    case QUERY_NODE_ALTER_SUPER_TABLE_STMT:










1833



    case QUERY_NODE_ALTER_VIRTUAL_TABLE_STMT: {










1834



      SAlterTableStmt* pStmt = (SAlterTableStmt*)pNode;




20,407,456✔





1835



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




20,407,456✔





1836



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




20,407,456✔





1837



      nodesDestroyNode(pStmt->pWhere);




20,407,456✔





1838



      nodesDestroyList(pStmt->pList);




20,407,456✔





1839



      break;




20,407,456✔





1840



    }










1841



    case QUERY_NODE_CREATE_MOUNT_STMT:  // no pointer field




1,720✔





1842



      break;




1,720✔





1843



    case QUERY_NODE_DROP_MOUNT_STMT:  // no pointer field




576✔





1844



      break;




576✔





1845



    case QUERY_NODE_CREATE_RSMA_STMT: {




116,152✔





1846



      SCreateRsmaStmt* pStmt = (SCreateRsmaStmt*)pNode;




116,152✔





1847



      nodesDestroyList(pStmt->pFuncs);




116,152✔





1848



      nodesDestroyList(pStmt->pIntervals);




116,152✔





1849



      break;




116,152✔





1850



    }










1851



    case QUERY_NODE_ALTER_RSMA_STMT: {




21,552✔





1852



      SAlterRsmaStmt* pStmt = (SAlterRsmaStmt*)pNode;




21,552✔





1853



      nodesDestroyList(pStmt->pFuncs);




21,552✔





1854



      break;




21,552✔





1855



    }










1856



    case QUERY_NODE_CREATE_USER_STMT: {




108,156✔





1857



      SCreateUserStmt* pStmt = (SCreateUserStmt*)pNode;




108,156✔





1858



      taosMemoryFree(pStmt->pIpRanges);




108,156✔





1859



      taosMemoryFree(pStmt->pTimeRanges);




108,156✔





1860



      break;




108,156✔





1861



    }










1862



    case QUERY_NODE_CREATE_ENCRYPT_ALGORITHMS_STMT: {




×







1863



      break;




×







1864



    }










1865



    case QUERY_NODE_ALTER_USER_STMT: {




52,347✔





1866



      SAlterUserStmt* pStmt = (SAlterUserStmt*)pNode;




52,347✔





1867



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




52,347✔





1868



      break;




52,347✔





1869



    }










1870



    case QUERY_NODE_ALTER_TOKEN_STMT: {




2,686✔





1871



      SAlterTokenStmt* pStmt = (SAlterTokenStmt*)pNode;




2,686✔





1872



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




2,686✔





1873



      break;




2,686✔





1874



    }










1875



    case QUERY_NODE_DROP_USER_STMT:     // no pointer field




93,098,296✔





1876



    case QUERY_NODE_USE_DATABASE_STMT:  // no pointer field










1877



    case QUERY_NODE_CREATE_DNODE_STMT:  // no pointer field










1878



    case QUERY_NODE_DROP_DNODE_STMT:    // no pointer field










1879



    case QUERY_NODE_ALTER_DNODE_STMT:   // no pointer field










1880



    case QUERY_NODE_ALTER_DNODES_RELOAD_TLS_STMT:  // no pointer field










1881



    case QUERY_NODE_CREATE_ANODE_STMT:  // no pointer field










1882



    case QUERY_NODE_UPDATE_ANODE_STMT:  // no pointer field










1883



    case QUERY_NODE_DROP_ANODE_STMT:    // no pointer field










1884



    case QUERY_NODE_DROP_BNODE_STMT:    // no pointer field










1885



    case QUERY_NODE_DROP_ENCRYPT_ALGR_STMT:     // no pointer field










1886



      break;




93,098,296✔





1887



    case QUERY_NODE_CREATE_BNODE_STMT: {




26,027✔





1888



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




26,027✔





1889



      nodesDestroyNode((SNode*)pOptions);




26,027✔





1890



      break;




26,027✔





1891



    }










1892



    case QUERY_NODE_BNODE_OPTIONS: {




26,027✔





1893



      SBnodeOptions* pOptions = (SBnodeOptions*)pNode;




26,027✔





1894



      // nodesDestroyList(pOptions->pProtocol);










1895



      break;




26,027✔





1896



    }










1897



    case QUERY_NODE_DATE_TIME_RANGE:  // no pointer field




38,343✔





1898



    case QUERY_NODE_IP_RANGE:         // no pointer field










1899



    case QUERY_NODE_TOKEN_OPTIONS:    // no pointer field










1900



      break;




38,343✔





1901



    case QUERY_NODE_USER_OPTIONS: {




186,185✔





1902



      SUserOptions* opts = (SUserOptions*)pNode;




186,185✔





1903



      nodesDestroyList(opts->pIpRanges);




186,185✔





1904



      nodesDestroyList(opts->pDropIpRanges);




186,185✔





1905



      nodesDestroyList(opts->pTimeRanges);




186,185✔





1906



      nodesDestroyList(opts->pDropTimeRanges);




186,185✔





1907



      break;




186,185✔





1908



    }










1909



    case QUERY_NODE_CREATE_INDEX_STMT: {




22,604✔





1910



      SCreateIndexStmt* pStmt = (SCreateIndexStmt*)pNode;




22,604✔





1911



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




22,604✔





1912



      nodesDestroyList(pStmt->pCols);




22,604✔





1913



      break;




22,604✔





1914



    }










1915



    case QUERY_NODE_DROP_INDEX_STMT:          // no pointer field




214,236✔





1916



    case QUERY_NODE_CREATE_QNODE_STMT:        // no pointer field










1917



    case QUERY_NODE_DROP_QNODE_STMT:          // no pointer field










1918



    case QUERY_NODE_CREATE_BACKUP_NODE_STMT:  // no pointer field










1919



    case QUERY_NODE_DROP_BACKUP_NODE_STMT:    // no pointer field










1920



    case QUERY_NODE_CREATE_SNODE_STMT:        // no pointer field










1921



    case QUERY_NODE_DROP_SNODE_STMT:          // no pointer field










1922



    case QUERY_NODE_CREATE_MNODE_STMT:        // no pointer field










1923



    case QUERY_NODE_DROP_MNODE_STMT:          // no pointer field










1924



      break;




214,236✔





1925



    case QUERY_NODE_CREATE_TOPIC_STMT:




196,408✔





1926



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




196,408✔





1927



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




196,408✔





1928



      break;




196,408✔





1929



    case QUERY_NODE_DROP_TOPIC_STMT:   // no pointer field




582,937✔





1930



    case QUERY_NODE_DROP_CGROUP_STMT:  // no pointer field










1931



    case QUERY_NODE_ALTER_LOCAL_STMT:  // no pointer field










1932



      break;




582,937✔





1933



    case QUERY_NODE_EXPLAIN_STMT: {




94,424,420✔





1934



      SExplainStmt* pStmt = (SExplainStmt*)pNode;




94,424,420✔





1935



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




94,424,420✔





1936



      nodesDestroyNode(pStmt->pQuery);




94,426,968✔





1937



      break;




94,448,020✔





1938



    }










1939



    case QUERY_NODE_DESCRIBE_STMT:




554,660✔





1940



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




554,660✔





1941



      break;




554,653✔





1942



    case QUERY_NODE_RESET_QUERY_CACHE_STMT:  // no pointer field




2,153,388✔





1943



      break;




2,153,388✔





1944



    case QUERY_NODE_COMPACT_DATABASE_STMT: {




41,233✔





1945



      SCompactDatabaseStmt* pStmt = (SCompactDatabaseStmt*)pNode;




41,233✔





1946



      nodesDestroyNode(pStmt->pStart);




41,233✔





1947



      nodesDestroyNode(pStmt->pEnd);




41,233✔





1948



      break;




41,233✔





1949



    }










1950



    case QUERY_NODE_ROLLUP_DATABASE_STMT: {




10,256✔





1951



      SRollupDatabaseStmt* pStmt = (SRollupDatabaseStmt*)pNode;




10,256✔





1952



      nodesDestroyNode(pStmt->pStart);




10,256✔





1953



      nodesDestroyNode(pStmt->pEnd);




10,256✔





1954



      break;




10,256✔





1955



    }










1956



    case QUERY_NODE_SCAN_DATABASE_STMT: {




780✔





1957



      SScanDatabaseStmt* pStmt = (SScanDatabaseStmt*)pNode;




780✔





1958



      nodesDestroyNode(pStmt->pStart);




780✔





1959



      nodesDestroyNode(pStmt->pEnd);




780✔





1960



      break;




780✔





1961



    }










1962



    case QUERY_NODE_COMPACT_VGROUPS_STMT: {




3,925✔





1963



      SCompactVgroupsStmt* pStmt = (SCompactVgroupsStmt*)pNode;




3,925✔





1964



      nodesDestroyNode(pStmt->pDbName);




3,925✔





1965



      nodesDestroyList(pStmt->vgidList);




3,925✔





1966



      nodesDestroyNode(pStmt->pStart);




3,925✔





1967



      nodesDestroyNode(pStmt->pEnd);




3,925✔





1968



      break;




3,925✔





1969



    }










1970



    case QUERY_NODE_ROLLUP_VGROUPS_STMT: {




4,608✔





1971



      SRollupVgroupsStmt* pStmt = (SRollupVgroupsStmt*)pNode;




4,608✔





1972



      nodesDestroyNode(pStmt->pDbName);




4,608✔





1973



      nodesDestroyList(pStmt->vgidList);




4,608✔





1974



      nodesDestroyNode(pStmt->pStart);




4,608✔





1975



      nodesDestroyNode(pStmt->pEnd);




4,608✔





1976



      break;




4,608✔





1977



    }










1978



    case QUERY_NODE_SCAN_VGROUPS_STMT: {




250✔





1979



      SScanVgroupsStmt* pStmt = (SScanVgroupsStmt*)pNode;




250✔





1980



      nodesDestroyNode(pStmt->pDbName);




250✔





1981



      nodesDestroyList(pStmt->vgidList);




250✔





1982



      nodesDestroyNode(pStmt->pStart);




250✔





1983



      nodesDestroyNode(pStmt->pEnd);




250✔





1984



      break;




250✔





1985



    }










1986



    case QUERY_NODE_CREATE_FUNCTION_STMT:  // no pointer field




28,757✔





1987



    case QUERY_NODE_DROP_FUNCTION_STMT:    // no pointer field










1988



      break;




28,757✔





1989



    case QUERY_NODE_CREATE_STREAM_STMT: {




627,011✔





1990



      SCreateStreamStmt* pStmt = (SCreateStreamStmt*)pNode;




627,011✔





1991



      ;










1992



      nodesDestroyNode(pStmt->pQuery);




627,011✔





1993



      nodesDestroyList(pStmt->pTags);




627,011✔





1994



      nodesDestroyList(pStmt->pCols);




627,011✔





1995



      nodesDestroyNode(pStmt->pSubtable);




627,011✔





1996



      nodesDestroyNode(pStmt->pTrigger);




627,011✔





1997



      break;




627,011✔





1998



    }










1999



    case QUERY_NODE_DROP_STREAM_STMT:




20,310✔





2000



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




20,310✔





2001



      break;




20,310✔





2002



    case QUERY_NODE_PAUSE_STREAM_STMT:                    // no pointer field




78,346✔





2003



    case QUERY_NODE_RESUME_STREAM_STMT:                   // no pointer field










2004



    case QUERY_NODE_BALANCE_VGROUP_STMT:                  // no pointer field










2005



    case QUERY_NODE_ASSIGN_LEADER_STMT:                   // no pointer field










2006



    case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT:           // no pointer field










2007



    case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT:  // no pointer field










2008



    case QUERY_NODE_SET_VGROUP_KEEP_VERSION_STMT:         // no pointer field










2009



    case QUERY_NODE_TRIM_DATABASE_WAL_STMT:               // no pointer field










2010



    case QUERY_NODE_CREATE_TOKEN_STMT:                    // no pointer field










2011



    case QUERY_NODE_DROP_TOKEN_STMT:                      // no pointer field










2012



    case QUERY_NODE_CREATE_TOTP_SECRET_STMT:              // no pointer field










2013



    case QUERY_NODE_DROP_TOTP_SECRET_STMT:                // no pointer field










2014



    case QUERY_NODE_MERGE_VGROUP_STMT:                    // no pointer field










2015



      break;




78,346✔





2016



    case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:




47,664✔





2017



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




47,664✔





2018



      break;




47,664✔





2019



    case QUERY_NODE_SPLIT_VGROUP_STMT:  // no pointer field




24,090✔





2020



    case QUERY_NODE_SYNCDB_STMT:        // no pointer field










2021



      break;




24,090✔





2022



    case QUERY_NODE_GRANT_STMT:




913,436✔





2023



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




913,436✔





2024



      break;




913,436✔





2025



    case QUERY_NODE_REVOKE_STMT:




492,597✔





2026



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




492,597✔





2027



      break;




492,597✔





2028



    case QUERY_NODE_ALTER_CLUSTER_STMT:  // no pointer field




954✔





2029



      break;




954✔





2030



    case QUERY_NODE_SHOW_DNODES_STMT:




3,265,742✔





2031



    case QUERY_NODE_SHOW_MNODES_STMT:










2032



    case QUERY_NODE_SHOW_MODULES_STMT:










2033



    case QUERY_NODE_SHOW_QNODES_STMT:










2034



    case QUERY_NODE_SHOW_ANODES_STMT:










2035



    case QUERY_NODE_SHOW_ANODES_FULL_STMT:










2036



    case QUERY_NODE_SHOW_XNODES_STMT:










2037



    case QUERY_NODE_SHOW_XNODE_TASKS_STMT:










2038



    case QUERY_NODE_SHOW_XNODE_AGENTS_STMT:










2039



    case QUERY_NODE_SHOW_XNODE_JOBS_STMT:










2040



    case QUERY_NODE_SHOW_SNODES_STMT:










2041



    case QUERY_NODE_SHOW_BACKUP_NODES_STMT:










2042



    case QUERY_NODE_SHOW_ARBGROUPS_STMT:










2043



    case QUERY_NODE_SHOW_CLUSTER_STMT:










2044



    case QUERY_NODE_SHOW_DATABASES_STMT:










2045



    case QUERY_NODE_SHOW_FUNCTIONS_STMT:










2046



    case QUERY_NODE_SHOW_INDEXES_STMT:










2047



    case QUERY_NODE_SHOW_STABLES_STMT:










2048



    case QUERY_NODE_SHOW_STREAMS_STMT:










2049



    case QUERY_NODE_SHOW_TABLES_STMT:










2050



    case QUERY_NODE_SHOW_VTABLES_STMT:










2051



    case QUERY_NODE_SHOW_USERS_STMT:










2052



    case QUERY_NODE_SHOW_USERS_FULL_STMT:










2053



    case QUERY_NODE_SHOW_ROLES_STMT:










2054



    case QUERY_NODE_SHOW_LICENCES_STMT:










2055



    case QUERY_NODE_SHOW_VGROUPS_STMT:










2056



    case QUERY_NODE_SHOW_TOPICS_STMT:










2057



    case QUERY_NODE_SHOW_CONSUMERS_STMT:










2058



    case QUERY_NODE_SHOW_CONNECTIONS_STMT:










2059



    case QUERY_NODE_SHOW_QUERIES_STMT:










2060



    case QUERY_NODE_SHOW_VNODES_STMT:










2061



    case QUERY_NODE_SHOW_APPS_STMT:










2062



    case QUERY_NODE_SHOW_SCORES_STMT:










2063



    case QUERY_NODE_SHOW_VARIABLES_STMT:










2064



    case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:










2065



    case QUERY_NODE_SHOW_TRANSACTIONS_STMT:










2066



    case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:










2067



    case QUERY_NODE_SHOW_TAGS_STMT:










2068



    case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT:










2069



    case QUERY_NODE_SHOW_ROLE_PRIVILEGES_STMT:










2070



    case QUERY_NODE_SHOW_ROLE_COL_PRIVILEGES_STMT:










2071



    case QUERY_NODE_SHOW_VIEWS_STMT:










2072



    case QUERY_NODE_SHOW_GRANTS_FULL_STMT:










2073



    case QUERY_NODE_SHOW_GRANTS_LOGS_STMT:










2074



    case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT:










2075



    case QUERY_NODE_SHOW_ENCRYPTIONS_STMT:










2076



    case QUERY_NODE_SHOW_ENCRYPT_ALGORITHMS_STMT:










2077



    case QUERY_NODE_SHOW_ENCRYPT_STATUS_STMT:










2078



    case QUERY_NODE_SHOW_TSMAS_STMT:










2079



    case QUERY_NODE_SHOW_USAGE_STMT:










2080



    case QUERY_NODE_SHOW_MOUNTS_STMT:










2081



    case QUERY_NODE_SHOW_RSMAS_STMT:










2082



    case QUERY_NODE_SHOW_RETENTIONS_STMT:










2083



    case QUERY_NODE_SHOW_INSTANCES_STMT: {










2084



      SShowStmt* pStmt = (SShowStmt*)pNode;




3,265,742✔





2085



      nodesDestroyNode(pStmt->pDbName);




3,265,742✔





2086



      nodesDestroyNode(pStmt->pTbName);




3,265,742✔





2087



      nodesDestroyNode(pStmt->pWhere);




3,265,742✔





2088



      break;




3,265,742✔





2089



    }










2090



    case QUERY_NODE_SHOW_TABLE_TAGS_STMT: {




9,678✔





2091



      SShowTableTagsStmt* pStmt = (SShowTableTagsStmt*)pNode;




9,678✔





2092



      nodesDestroyNode(pStmt->pDbName);




9,678✔





2093



      nodesDestroyNode(pStmt->pTbName);




9,678✔





2094



      nodesDestroyList(pStmt->pTags);




9,678✔





2095



      break;




9,678✔





2096



    }










2097



    case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:




40,262✔





2098



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




40,262✔





2099



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




40,262✔





2100



      break;




40,262✔





2101



    case QUERY_NODE_SHOW_COMPACTS_STMT:




358,994✔





2102



    case QUERY_NODE_SHOW_SCANS_STMT:










2103



      break;




358,994✔





2104



    case QUERY_NODE_SHOW_COMPACT_DETAILS_STMT:




33,888✔





2105



    case QUERY_NODE_SHOW_RETENTION_DETAILS_STMT: {










2106



      SShowCompactDetailsStmt* pStmt = (SShowCompactDetailsStmt*)pNode;




33,888✔





2107



      nodesDestroyNode(pStmt->pId);




33,888✔





2108



      break;




33,888✔





2109



    }










2110



    case QUERY_NODE_SHOW_SCAN_DETAILS_STMT: {




2,100✔





2111



      SShowScanDetailsStmt* pStmt = (SShowScanDetailsStmt*)pNode;




2,100✔





2112



      nodesDestroyNode(pStmt->pScanId);




2,100✔





2113



      break;




2,100✔





2114



    }










2115



    case QUERY_NODE_SHOW_SSMIGRATES_STMT:




92,160✔





2116



      break;




92,160✔





2117



    case QUERY_NODE_SHOW_TOKENS_STMT:




1,816✔





2118



      break;




1,816✔





2119



    case QUERY_NODE_SHOW_TRANSACTION_DETAILS_STMT: {




297✔





2120



      SShowTransactionDetailsStmt* pStmt = (SShowTransactionDetailsStmt*)pNode;




297✔





2121



      nodesDestroyNode(pStmt->pTransactionId);




297✔





2122



      break;




297✔





2123



    }










2124



    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:




60,850✔





2125



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




60,850✔





2126



      break;




60,850✔





2127



    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:




100,384✔





2128



    case QUERY_NODE_SHOW_CREATE_VTABLE_STMT:










2129



    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:










2130



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




100,384✔





2131



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




100,384✔





2132



      break;




100,384✔





2133



    case QUERY_NODE_SHOW_CREATE_VIEW_STMT:        // no pointer field




16,562✔





2134



    case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:  // no pointer field










2135



    case QUERY_NODE_KILL_CONNECTION_STMT:         // no pointer field










2136



    case QUERY_NODE_KILL_QUERY_STMT:              // no pointer field










2137



    case QUERY_NODE_KILL_TRANSACTION_STMT:        // no pointer field










2138



    case QUERY_NODE_KILL_COMPACT_STMT:            // no pointer field










2139



    case QUERY_NODE_KILL_RETENTION_STMT:          // no pointer field










2140



    case QUERY_NODE_KILL_SCAN_STMT:










2141



    case QUERY_NODE_KILL_SSMIGRATE_STMT:          // no pointer field










2142



      break;




16,562✔





2143



    case QUERY_NODE_SHOW_VALIDATE_VTABLE_STMT:




3,780✔





2144



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




3,780✔





2145



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




3,780✔





2146



      break;




3,780✔





2147



    case QUERY_NODE_SHOW_CREATE_RSMA_STMT: {




3,256✔





2148



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




3,256✔





2149



      if (pMeta != NULL) {




3,256✔





2150



        tFreeRsmaInfoRsp(pMeta, true);




2,488✔





2151



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




2,488✔





2152



      }










2153



      break;




3,256✔





2154



    }










2155



    case QUERY_NODE_DELETE_STMT: {




1,877,798✔





2156



      SDeleteStmt* pStmt = (SDeleteStmt*)pNode;




1,877,798✔





2157



      nodesDestroyNode(pStmt->pFromTable);




1,877,798✔





2158



      nodesDestroyNode(pStmt->pWhere);




1,877,785✔





2159



      nodesDestroyNode(pStmt->pCountFunc);




1,877,785✔





2160



      nodesDestroyNode(pStmt->pFirstFunc);




1,877,798✔





2161



      nodesDestroyNode(pStmt->pLastFunc);




1,877,798✔





2162



      nodesDestroyNode(pStmt->pTagCond);




1,877,798✔





2163



      break;




1,877,798✔





2164



    }










2165



    case QUERY_NODE_INSERT_STMT: {




551,995✔





2166



      SInsertStmt* pStmt = (SInsertStmt*)pNode;




551,995✔





2167



      nodesDestroyNode(pStmt->pTable);




551,995✔





2168



      nodesDestroyList(pStmt->pCols);




551,995✔





2169



      nodesDestroyNode(pStmt->pQuery);




551,995✔





2170



      break;




551,995✔





2171



    }










2172



    case QUERY_NODE_QUERY: {




932,080,881✔





2173



      SQuery* pQuery = (SQuery*)pNode;




932,080,881✔





2174



      nodesDestroyNode(pQuery->pPrevRoot);




932,080,881✔





2175



      nodesDestroyNode(pQuery->pRoot);




932,074,049✔





2176



      nodesDestroyNode(pQuery->pPostRoot);




932,100,464✔





2177



      taosMemoryFreeClear(pQuery->pResSchema);




932,104,303✔





2178



      if (NULL != pQuery->pCmdMsg) {




932,104,396✔





2179



        taosMemoryFreeClear(pQuery->pCmdMsg->pMsg);




107,489,562✔





2180



        taosMemoryFreeClear(pQuery->pCmdMsg);




107,489,478✔





2181



      }










2182



      taosMemoryFreeClear(pQuery->pResExtSchema);




932,108,948✔





2183



      taosArrayDestroy(pQuery->pDbList);




932,112,817✔





2184



      taosArrayDestroy(pQuery->pTableList);




932,105,881✔





2185



      taosArrayDestroy(pQuery->pTargetTableList);




932,101,102✔





2186



      taosArrayDestroy(pQuery->pPlaceholderValues);




932,099,725✔





2187



      nodesDestroyNode(pQuery->pPrepareRoot);




932,094,281✔





2188



      break;




932,095,659✔





2189



    }










2190



    case QUERY_NODE_RESTORE_DNODE_STMT:  // no pointer field




2,585✔





2191



    case QUERY_NODE_RESTORE_QNODE_STMT:  // no pointer field










2192



    case QUERY_NODE_RESTORE_MNODE_STMT:  // no pointer field










2193



    case QUERY_NODE_RESTORE_VNODE_STMT:  // no pointer field










2194



      break;




2,585✔





2195



    case QUERY_NODE_CREATE_VIEW_STMT: {




223,057✔





2196



      SCreateViewStmt* pStmt = (SCreateViewStmt*)pNode;




223,057✔





2197



      taosMemoryFree(pStmt->pQuerySql);




223,057✔





2198



      tFreeSCMCreateViewReq(&pStmt->createReq);




223,057✔





2199



      nodesDestroyNode(pStmt->pQuery);




223,057✔





2200



      break;




223,057✔





2201



    }










2202



    case QUERY_NODE_DROP_VIEW_STMT:




166,647✔





2203



      break;




166,647✔





2204



    case QUERY_NODE_CREATE_TSMA_STMT: {




7,282✔





2205



      SCreateTSMAStmt* pStmt = (SCreateTSMAStmt*)pNode;




7,282✔





2206



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




7,282✔





2207



      break;




7,282✔





2208



    }










2209



    case QUERY_NODE_RECALCULATE_STREAM_STMT: {




12,080✔





2210



      SRecalcStreamStmt* pStmt = (SRecalcStreamStmt*)pNode;




12,080✔





2211



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




12,080✔





2212



      break;




12,080✔





2213



    }










2214



    case QUERY_NODE_LOGIC_PLAN_SCAN: {




1,060,260,180✔





2215



      SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode;




1,060,260,180✔





2216



      destroyLogicNode((SLogicNode*)pLogicNode);




1,060,260,180✔





2217



      nodesDestroyList(pLogicNode->pScanCols);




1,060,269,156✔





2218



      nodesDestroyList(pLogicNode->pScanPseudoCols);




1,060,266,026✔





2219



      taosMemoryFreeClear(pLogicNode->pVgroupList);




1,060,277,319✔





2220



      nodesDestroyList(pLogicNode->pDynamicScanFuncs);




1,060,289,923✔





2221



      nodesDestroyNode(pLogicNode->pTagCond);




1,060,299,131✔





2222



      nodesDestroyNode(pLogicNode->pTagIndexCond);




1,060,278,919✔





2223



      taosArrayDestroyEx(pLogicNode->pSmaIndexes, destroySmaIndex);




1,060,290,814✔





2224



      nodesDestroyList(pLogicNode->pGroupTags);




1,060,295,112✔





2225



      taosArrayDestroyEx(pLogicNode->pFuncTypes, destroyFuncParam);




1,060,295,046✔





2226



      taosArrayDestroyP(pLogicNode->pTsmaTargetTbVgInfo, NULL);




1,060,286,124✔





2227



      taosArrayDestroy(pLogicNode->pTsmaTargetTbInfo);




1,060,267,220✔





2228



      taosMemoryFreeClear(pLogicNode->pExtScanRange);




1,060,283,070✔





2229



      nodesDestroyNode(pLogicNode->pTimeRange);




1,060,283,193✔





2230



      nodesDestroyNode(pLogicNode->pExtTimeRange);




1,060,251,611✔





2231



      nodesDestroyNode(pLogicNode->pPrimaryCond);




1,060,282,308✔





2232



      break;




1,060,296,036✔





2233



    }










2234



    case QUERY_NODE_LOGIC_PLAN_JOIN: {




51,360,364✔





2235



      SJoinLogicNode* pLogicNode = (SJoinLogicNode*)pNode;




51,360,364✔





2236



      destroyLogicNode((SLogicNode*)pLogicNode);




51,360,364✔





2237



      nodesDestroyNode(pLogicNode->pWindowOffset);




51,360,683✔





2238



      nodesDestroyNode(pLogicNode->pJLimit);




51,359,251✔





2239



      nodesDestroyNode(pLogicNode->addPrimEqCond);




51,359,476✔





2240



      nodesDestroyNode(pLogicNode->pPrimKeyEqCond);




51,360,131✔





2241



      nodesDestroyNode(pLogicNode->pColEqCond);




51,360,586✔





2242



      nodesDestroyNode(pLogicNode->pColOnCond);




51,360,587✔





2243



      nodesDestroyNode(pLogicNode->pTagEqCond);




51,360,586✔





2244



      nodesDestroyNode(pLogicNode->pTagOnCond);




51,360,583✔





2245



      nodesDestroyNode(pLogicNode->pFullOnCond);




51,360,586✔





2246



      nodesDestroyList(pLogicNode->pLeftEqNodes);




51,358,511✔





2247



      nodesDestroyList(pLogicNode->pRightEqNodes);




51,360,266✔





2248



      nodesDestroyNode(pLogicNode->pLeftOnCond);




51,360,147✔





2249



      nodesDestroyNode(pLogicNode->pRightOnCond);




51,360,343✔





2250



      break;




51,360,251✔





2251



    }










2252



    case QUERY_NODE_LOGIC_PLAN_VIRTUAL_TABLE_SCAN: {




15,340,192✔





2253



      SVirtualScanLogicNode* pLogicNode = (SVirtualScanLogicNode*)pNode;




15,340,192✔





2254



      destroyLogicNode((SLogicNode*)pLogicNode);




15,340,192✔





2255



      nodesDestroyList(pLogicNode->pScanCols);




15,340,192✔





2256



      nodesDestroyList(pLogicNode->pScanPseudoCols);




15,340,192✔





2257



      taosMemoryFreeClear(pLogicNode->pVgroupList);




15,340,192✔





2258



      break;




15,340,192✔





2259



    }










2260



    case QUERY_NODE_LOGIC_PLAN_AGG: {




373,226,777✔





2261



      SAggLogicNode* pLogicNode = (SAggLogicNode*)pNode;




373,226,777✔





2262



      destroyLogicNode((SLogicNode*)pLogicNode);




373,226,777✔





2263



      nodesDestroyList(pLogicNode->pAggFuncs);




373,238,219✔





2264



      nodesDestroyList(pLogicNode->pGroupKeys);




373,242,375✔





2265



      break;




373,243,499✔





2266



    }










2267



    case QUERY_NODE_LOGIC_PLAN_PROJECT: {




760,780,910✔





2268



      SProjectLogicNode* pLogicNode = (SProjectLogicNode*)pNode;




760,780,910✔





2269



      destroyLogicNode((SLogicNode*)pLogicNode);




760,780,910✔





2270



      nodesDestroyList(pLogicNode->pProjections);




760,847,048✔





2271



      break;




760,863,679✔





2272



    }










2273



    case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: {




1,101,745,778✔





2274



      SVnodeModifyLogicNode* pLogicNode = (SVnodeModifyLogicNode*)pNode;




1,101,745,778✔





2275



      destroyLogicNode((SLogicNode*)pLogicNode);




1,101,745,778✔





2276



      destroyVgDataBlockArray(pLogicNode->pDataBlocks);




1,101,695,061✔





2277



      // pVgDataBlocks is weak reference










2278



      nodesDestroyNode(pLogicNode->pAffectedRows);




1,101,733,142✔





2279



      nodesDestroyNode(pLogicNode->pStartTs);




1,101,746,581✔





2280



      nodesDestroyNode(pLogicNode->pEndTs);




1,101,736,353✔





2281



      taosMemoryFreeClear(pLogicNode->pVgroupList);




1,101,751,232✔





2282



      nodesDestroyList(pLogicNode->pInsertCols);




1,101,754,198✔





2283



      break;




1,101,753,286✔





2284



    }










2285



    case QUERY_NODE_LOGIC_PLAN_EXCHANGE:




282,955,636✔





2286



      destroyLogicNode((SLogicNode*)pNode);




282,955,636✔





2287



      break;




282,959,740✔





2288



    case QUERY_NODE_LOGIC_PLAN_MERGE: {




69,083,628✔





2289



      SMergeLogicNode* pLogicNode = (SMergeLogicNode*)pNode;




69,083,628✔





2290



      destroyLogicNode((SLogicNode*)pLogicNode);




69,083,628✔





2291



      nodesDestroyList(pLogicNode->pMergeKeys);




69,084,293✔





2292



      nodesDestroyList(pLogicNode->pInputs);




69,082,857✔





2293



      break;




69,082,183✔





2294



    }










2295



    case QUERY_NODE_LOGIC_PLAN_WINDOW: {




84,673,832✔





2296



      SWindowLogicNode* pLogicNode = (SWindowLogicNode*)pNode;




84,673,832✔





2297



      destroyLogicNode((SLogicNode*)pLogicNode);




84,673,832✔





2298



      nodesDestroyList(pLogicNode->pFuncs);




84,684,165✔





2299



      nodesDestroyNode(pLogicNode->pTspk);




84,685,989✔





2300



      nodesDestroyNode(pLogicNode->pTimeRange);




84,686,878✔





2301



      nodesDestroyNode(pLogicNode->pTsEnd);




84,686,504✔





2302



      nodesDestroyNode(pLogicNode->pStateExpr);




84,687,188✔





2303



      nodesDestroyNode(pLogicNode->pStartCond);




84,687,306✔





2304



      nodesDestroyNode(pLogicNode->pEndCond);




84,687,380✔





2305



      nodesDestroyList(pLogicNode->pColList);




84,682,625✔





2306



      nodesDestroyList(pLogicNode->pProjs);




84,686,042✔





2307



      break;




84,686,384✔





2308



    }










2309



    case QUERY_NODE_LOGIC_PLAN_FILL: {




945,458✔





2310



      SFillLogicNode* pLogicNode = (SFillLogicNode*)pNode;




945,458✔





2311



      destroyLogicNode((SLogicNode*)pLogicNode);




945,458✔





2312



      nodesDestroyNode(pLogicNode->pWStartTs);




945,458✔





2313



      nodesDestroyNode(pLogicNode->pValues);




945,458✔





2314



      nodesDestroyNode(pLogicNode->pTimeRange);




945,458✔





2315



      nodesDestroyNode(pLogicNode->pSurroundingTime);




945,458✔





2316



      nodesDestroyList(pLogicNode->pFillExprs);




945,458✔





2317



      nodesDestroyList(pLogicNode->pNotFillExprs);




945,458✔





2318



      nodesDestroyList(pLogicNode->pFillNullExprs);




945,458✔





2319



      break;




945,458✔





2320



    }










2321



    case QUERY_NODE_LOGIC_PLAN_SORT: {




182,009,095✔





2322



      SSortLogicNode* pLogicNode = (SSortLogicNode*)pNode;




182,009,095✔





2323



      destroyLogicNode((SLogicNode*)pLogicNode);




182,009,095✔





2324



      nodesDestroyList(pLogicNode->pSortKeys);




182,019,065✔





2325



      break;




182,021,117✔





2326



    }










2327



    case QUERY_NODE_LOGIC_PLAN_PARTITION: {




61,721,574✔





2328



      SPartitionLogicNode* pLogicNode = (SPartitionLogicNode*)pNode;




61,721,574✔





2329



      destroyLogicNode((SLogicNode*)pLogicNode);




61,721,574✔





2330



      nodesDestroyList(pLogicNode->pPartitionKeys);




61,726,026✔





2331



      nodesDestroyList(pLogicNode->pTags);




61,729,664✔





2332



      nodesDestroyNode(pLogicNode->pSubtable);




61,730,008✔





2333



      nodesDestroyList(pLogicNode->pAggFuncs);




61,723,550✔





2334



      break;




61,727,683✔





2335



    }










2336



    case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: {




11,609,319✔





2337



      SIndefRowsFuncLogicNode* pLogicNode = (SIndefRowsFuncLogicNode*)pNode;




11,609,319✔





2338



      destroyLogicNode((SLogicNode*)pLogicNode);




11,609,319✔





2339



      nodesDestroyList(pLogicNode->pFuncs);




11,609,319✔





2340



      break;




11,609,319✔





2341



    }










2342



    case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: {




7,278,138✔





2343



      SInterpFuncLogicNode* pLogicNode = (SInterpFuncLogicNode*)pNode;




7,278,138✔





2344



      destroyLogicNode((SLogicNode*)pLogicNode);




7,278,138✔





2345



      nodesDestroyList(pLogicNode->pFuncs);




7,278,138✔





2346



      nodesDestroyNode(pLogicNode->pTimeRange);




7,278,138✔





2347



      nodesDestroyNode(pLogicNode->pFillValues);




7,278,138✔





2348



      nodesDestroyNode(pLogicNode->pTimeSeries);




7,278,138✔





2349



      break;




7,278,138✔





2350



    }










2351



    case QUERY_NODE_LOGIC_PLAN_FORECAST_FUNC: {




×







2352



      SForecastFuncLogicNode* pLogicNode = (SForecastFuncLogicNode*)pNode;




×







2353



      destroyLogicNode((SLogicNode*)pLogicNode);




×







2354



      nodesDestroyList(pLogicNode->pFuncs);




×







2355



      break;




×







2356



    }










2357



    case QUERY_NODE_LOGIC_PLAN_ANALYSIS_FUNC: {




×







2358



      SGenericAnalysisLogicNode* pLogicNode = (SGenericAnalysisLogicNode*)pNode;




×







2359



      destroyLogicNode((SLogicNode*)pLogicNode);




×







2360



      nodesDestroyList(pLogicNode->pFuncs);




×







2361



      break;




×







2362



    }










2363



    case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: {




3,935,418✔





2364



      SGroupCacheLogicNode* pLogicNode = (SGroupCacheLogicNode*)pNode;




3,935,418✔





2365



      destroyLogicNode((SLogicNode*)pLogicNode);




3,935,418✔





2366



      nodesDestroyList(pLogicNode->pGroupCols);




3,935,418✔





2367



      break;




3,935,418✔





2368



    }










2369



    case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: {




17,843,011✔





2370



      SDynQueryCtrlLogicNode* pLogicNode = (SDynQueryCtrlLogicNode*)pNode;




17,843,011✔





2371



      destroyLogicNode((SLogicNode*)pLogicNode);




17,843,011✔





2372



      if (pLogicNode->qType == DYN_QTYPE_VTB_SCAN ||




17,843,011✔





2373



          pLogicNode->qType == DYN_QTYPE_VTB_AGG ||




10,701,206✔





2374



          pLogicNode->qType == DYN_QTYPE_VTB_INTERVAL ||




5,543,300✔





2375



          pLogicNode->qType == DYN_QTYPE_VTB_WINDOW ||




5,457,174✔





2376



          pLogicNode->qType == DYN_QTYPE_VTB_TS_SCAN) {




4,074,818✔





2377



        taosMemoryFreeClear(pLogicNode->vtbScan.pVgroupList);




13,907,593✔





2378



        nodesDestroyList(pLogicNode->vtbScan.pOrgVgIds);




13,907,593✔





2379



      }










2380



      break;




17,843,011✔





2381



    }










2382



    case QUERY_NODE_LOGIC_SUBPLAN: {




2,147,483,647✔





2383



      SLogicSubplan* pSubplan = (SLogicSubplan*)pNode;




2,147,483,647✔





2384



      nodesDestroyList(pSubplan->pChildren);




2,147,483,647✔





2385



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




2,147,483,647✔





2386



      nodesClearList(pSubplan->pParents);




2,147,483,647✔





2387



      taosMemoryFreeClear(pSubplan->pVgroupList);




2,147,483,647✔





2388



      break;




2,147,483,647✔





2389



    }










2390



    case QUERY_NODE_LOGIC_PLAN:




902,594,327✔





2391



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




902,594,327✔





2392



      break;




902,626,638✔





2393



    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:




96,352,217✔





2394



    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:










2395



    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:










2396



      destroyScanPhysiNode((SScanPhysiNode*)pNode);




96,352,217✔





2397



      break;




96,362,880✔





2398



    case QUERY_NODE_PHYSICAL_PLAN_VIRTUAL_TABLE_SCAN: {




8,887,352✔





2399



      SVirtualScanPhysiNode* pPhyNode = (SVirtualScanPhysiNode*)pNode;




8,887,352✔





2400



      destroyScanPhysiNode((SScanPhysiNode*)pNode);




8,887,352✔





2401



      nodesDestroyList(pPhyNode->pGroupTags);




8,887,352✔





2402



      nodesDestroyList(pPhyNode->pTargets);




8,887,352✔





2403



      nodesDestroyList(pPhyNode->pTags);




8,887,352✔





2404



      nodesDestroyNode(pPhyNode->pSubtable);




8,887,352✔





2405



      break;




8,887,352✔





2406



    }










2407



    case QUERY_NODE_PHYSICAL_PLAN_EXTERNAL_WINDOW:




3,621,098✔





2408



    case QUERY_NODE_PHYSICAL_PLAN_HASH_EXTERNAL:










2409



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_EXTERNAL: {










2410



      SExternalWindowPhysiNode* pPhyNode = (SExternalWindowPhysiNode*)pNode;




3,621,098✔






2411



      nodesDestroyNode(pPhyNode->pSubquery);




3,621,098✔





2412



      nodesDestroyNode(pPhyNode->pTimeRange);




3,621,098✔





2413



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




3,621,098✔





2414



      break;




3,621,098✔





2415



    }










2416



    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:




5,223,629✔





2417



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: {










2418



      SLastRowScanPhysiNode* pPhyNode = (SLastRowScanPhysiNode*)pNode;




5,223,629✔





2419



      destroyScanPhysiNode((SScanPhysiNode*)pNode);




5,223,629✔





2420



      nodesDestroyList(pPhyNode->pGroupTags);




5,223,916✔





2421



      nodesDestroyList(pPhyNode->pTargets);




5,224,370✔





2422



      taosArrayDestroy(pPhyNode->pFuncTypes);




5,224,385✔





2423



      break;




5,224,398✔





2424



    }










2425



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:




810,948,279✔





2426



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:










2427



    case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:










2428



    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: {










2429



      STableScanPhysiNode* pPhyNode = (STableScanPhysiNode*)pNode;




810,948,279✔





2430



      destroyScanPhysiNode((SScanPhysiNode*)pNode);




810,948,279✔





2431



      nodesDestroyList(pPhyNode->pDynamicScanFuncs);




810,938,035✔





2432



      nodesDestroyList(pPhyNode->pGroupTags);




810,987,737✔





2433



      nodesDestroyList(pPhyNode->pTags);




810,953,342✔





2434



      nodesDestroyNode(pPhyNode->pSubtable);




810,968,719✔





2435



      taosMemoryFreeClear(pPhyNode->pExtScanRange);




810,951,610✔





2436



      nodesDestroyNode(pPhyNode->pTimeRange);




810,981,283✔





2437



      nodesDestroyNode(pPhyNode->pExtTimeRange);




810,960,734✔





2438



      nodesDestroyNode(pPhyNode->pPrimaryCond);




810,976,648✔





2439



      break;




810,928,488✔





2440



    }










2441



    case QUERY_NODE_PHYSICAL_PLAN_PROJECT: {




445,507,550✔





2442



      SProjectPhysiNode* pPhyNode = (SProjectPhysiNode*)pNode;




445,507,550✔





2443



      destroyPhysiNode((SPhysiNode*)pPhyNode);




445,507,550✔





2444



      nodesDestroyList(pPhyNode->pProjections);




445,502,918✔





2445



      break;




445,504,890✔





2446



    }










2447



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: {




35,591,195✔





2448



      SSortMergeJoinPhysiNode* pPhyNode = (SSortMergeJoinPhysiNode*)pNode;




35,591,195✔





2449



      destroyPhysiNode((SPhysiNode*)pPhyNode);




35,591,195✔





2450



      nodesDestroyNode(pPhyNode->pWindowOffset);




35,591,195✔





2451



      nodesDestroyNode(pPhyNode->pJLimit);




35,591,195✔





2452



      nodesDestroyNode(pPhyNode->leftPrimExpr);




35,591,195✔





2453



      nodesDestroyNode(pPhyNode->rightPrimExpr);




35,591,195✔





2454



      nodesDestroyList(pPhyNode->pEqLeft);




35,590,693✔





2455



      nodesDestroyList(pPhyNode->pEqRight);




35,591,102✔





2456



      nodesDestroyNode(pPhyNode->pPrimKeyCond);




35,591,102✔





2457



      nodesDestroyNode(pPhyNode->pFullOnCond);




35,591,023✔





2458



      nodesDestroyList(pPhyNode->pTargets);




35,590,362✔





2459



      nodesDestroyNode(pPhyNode->pColEqCond);




35,591,116✔





2460



      nodesDestroyNode(pPhyNode->pColOnCond);




35,591,116✔





2461



      break;




35,591,116✔





2462



    }










2463



    case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: {




3,194,893✔





2464



      SHashJoinPhysiNode* pPhyNode = (SHashJoinPhysiNode*)pNode;




3,194,893✔





2465



      destroyPhysiNode((SPhysiNode*)pPhyNode);




3,194,893✔





2466



      nodesDestroyNode(pPhyNode->pWindowOffset);




3,194,893✔





2467



      nodesDestroyNode(pPhyNode->pJLimit);




3,194,893✔





2468



      nodesDestroyList(pPhyNode->pOnLeft);




3,194,893✔





2469



      nodesDestroyList(pPhyNode->pOnRight);




3,194,893✔





2470



      nodesDestroyNode(pPhyNode->leftPrimExpr);




3,194,893✔





2471



      nodesDestroyNode(pPhyNode->rightPrimExpr);




3,194,893✔





2472



      nodesDestroyNode(pPhyNode->pLeftOnCond);




3,194,893✔





2473



      nodesDestroyNode(pPhyNode->pRightOnCond);




3,194,893✔





2474



      nodesDestroyNode(pPhyNode->pFullOnCond);




3,194,893✔





2475



      nodesDestroyList(pPhyNode->pTargets);




3,194,893✔





2476












2477



      nodesDestroyNode(pPhyNode->pPrimKeyCond);




3,194,893✔





2478



      nodesDestroyNode(pPhyNode->pColEqCond);




3,194,893✔





2479



      nodesDestroyNode(pPhyNode->pTagEqCond);




3,194,893✔





2480












2481



      break;




3,194,893✔





2482



    }










2483



    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: {




332,572,821✔





2484



      SAggPhysiNode* pPhyNode = (SAggPhysiNode*)pNode;




332,572,821✔





2485



      destroyPhysiNode((SPhysiNode*)pPhyNode);




332,572,821✔





2486



      nodesDestroyList(pPhyNode->pExprs);




332,569,194✔





2487



      nodesDestroyList(pPhyNode->pAggFuncs);




332,575,056✔





2488



      nodesDestroyList(pPhyNode->pGroupKeys);




332,572,930✔





2489



      break;




332,573,055✔





2490



    }










2491



    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: {




334,106,528✔





2492



      SExchangePhysiNode* pPhyNode = (SExchangePhysiNode*)pNode;




334,106,528✔





2493



      destroyPhysiNode((SPhysiNode*)pPhyNode);




334,106,528✔





2494



      nodesDestroyList(pPhyNode->pSrcEndPoints);




334,103,543✔





2495



      taosArrayDestroy(pPhyNode->childrenVgIds);




334,104,933✔





2496



      break;




334,104,489✔





2497



    }










2498



    case QUERY_NODE_PHYSICAL_PLAN_MERGE: {




48,626,881✔





2499



      SMergePhysiNode* pPhyNode = (SMergePhysiNode*)pNode;




48,626,881✔





2500



      destroyPhysiNode((SPhysiNode*)pPhyNode);




48,626,881✔





2501



      nodesDestroyList(pPhyNode->pMergeKeys);




48,626,509✔





2502



      nodesDestroyList(pPhyNode->pTargets);




48,627,238✔





2503



      break;




48,626,908✔





2504



    }










2505



    case QUERY_NODE_PHYSICAL_PLAN_SORT:




118,077,549✔





2506



    case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: {










2507



      SSortPhysiNode* pPhyNode = (SSortPhysiNode*)pNode;




118,077,549✔





2508



      destroyPhysiNode((SPhysiNode*)pPhyNode);




118,077,549✔





2509



      nodesDestroyList(pPhyNode->pExprs);




118,073,985✔





2510



      nodesDestroyList(pPhyNode->pSortKeys);




118,077,076✔





2511



      nodesDestroyList(pPhyNode->pTargets);




118,077,779✔





2512



      break;




118,077,416✔





2513



    }










2514



    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:




32,497,212✔





2515



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL:










2516



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL:










2517



      destroyWinodwPhysiNode((SWindowPhysiNode*)pNode);




32,497,212✔





2518



      break;




32,495,751✔





2519



    case QUERY_NODE_PHYSICAL_PLAN_FILL: {




1,014,641✔





2520



      SFillPhysiNode* pPhyNode = (SFillPhysiNode*)pNode;




1,014,641✔





2521



      destroyPhysiNode((SPhysiNode*)pPhyNode);




1,014,641✔





2522



      nodesDestroyList(pPhyNode->pFillExprs);




1,014,641✔





2523



      nodesDestroyList(pPhyNode->pNotFillExprs);




1,014,641✔





2524



      nodesDestroyNode(pPhyNode->pWStartTs);




1,014,641✔





2525



      nodesDestroyNode(pPhyNode->pValues);




1,014,641✔





2526



      nodesDestroyList(pPhyNode->pFillNullExprs);




1,014,641✔





2527



      nodesDestroyNode(pPhyNode->pTimeRange);




1,014,641✔





2528



      nodesDestroyNode(pPhyNode->pSurroundingTime);




1,014,641✔





2529



      break;




1,014,641✔





2530



    }










2531



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:




5,851,500✔





2532



      destroyWinodwPhysiNode((SWindowPhysiNode*)pNode);




5,851,500✔





2533



      break;




5,851,435✔





2534



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: {




5,404,254✔





2535



      SStateWindowPhysiNode* pPhyNode = (SStateWindowPhysiNode*)pNode;




5,404,254✔





2536



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




5,404,254✔





2537



      nodesDestroyNode(pPhyNode->pStateKey);




5,404,268✔





2538



      break;




5,404,268✔





2539



    }










2540



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: {




4,275,153✔





2541



      SEventWinodwPhysiNode* pPhyNode = (SEventWinodwPhysiNode*)pNode;




4,275,153✔





2542



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




4,275,153✔





2543



      nodesDestroyNode(pPhyNode->pStartCond);




4,275,060✔





2544



      nodesDestroyNode(pPhyNode->pEndCond);




4,274,967✔





2545



      break;




4,275,060✔





2546



    }










2547



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT: {




3,842,992✔





2548



      SCountWindowPhysiNode* pPhyNode = (SCountWindowPhysiNode*)pNode;




3,842,992✔





2549



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




3,842,992✔





2550



      break;




3,843,009✔





2551



    }










2552



    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ANOMALY: {




×







2553



      SAnomalyWindowPhysiNode* pPhyNode = (SAnomalyWindowPhysiNode*)pNode;




×







2554



      destroyWinodwPhysiNode((SWindowPhysiNode*)pPhyNode);




×







2555



      nodesDestroyList(pPhyNode->pAnomalyKeys);




×







2556



      break;




×







2557



    }










2558



    case QUERY_NODE_PHYSICAL_PLAN_PARTITION: {




22,206,339✔





2559



      destroyPartitionPhysiNode((SPartitionPhysiNode*)pNode);




22,206,339✔





2560



      break;




22,209,015✔





2561



    }










2562



    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: {




7,595,625✔





2563



      SIndefRowsFuncPhysiNode* pPhyNode = (SIndefRowsFuncPhysiNode*)pNode;




7,595,625✔





2564



      destroyPhysiNode((SPhysiNode*)pPhyNode);




7,595,625✔





2565



      nodesDestroyList(pPhyNode->pExprs);




7,595,248✔





2566



      nodesDestroyList(pPhyNode->pFuncs);




7,595,625✔





2567



      break;




7,595,625✔





2568



    }










2569



    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: {




7,158,495✔





2570



      SInterpFuncPhysiNode* pPhyNode = (SInterpFuncPhysiNode*)pNode;




7,158,495✔





2571



      destroyPhysiNode((SPhysiNode*)pPhyNode);




7,158,495✔





2572



      nodesDestroyList(pPhyNode->pExprs);




7,158,495✔





2573



      nodesDestroyList(pPhyNode->pFuncs);




7,158,495✔





2574



      nodesDestroyNode(pPhyNode->pTimeRange);




7,158,495✔





2575



      nodesDestroyNode(pPhyNode->pFillValues);




7,158,495✔





2576



      nodesDestroyNode(pPhyNode->pTimeSeries);




7,158,495✔





2577



      break;




7,158,495✔





2578



    }










2579



    case QUERY_NODE_PHYSICAL_PLAN_ANALYSIS_FUNC:




×







2580



    case QUERY_NODE_PHYSICAL_PLAN_FORECAST_FUNC: {










2581



      SForecastFuncPhysiNode* pPhyNode = (SForecastFuncPhysiNode*)pNode;




×







2582



      destroyPhysiNode((SPhysiNode*)pPhyNode);




×







2583



      nodesDestroyList(pPhyNode->pExprs);




×







2584



      nodesDestroyList(pPhyNode->pFuncs);




×







2585



      break;




×







2586



    }










2587



    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:




1,112,878,092✔





2588



      destroyDataSinkNode((SDataSinkNode*)pNode);




1,112,878,092✔





2589



      break;




1,112,848,239✔





2590



    case QUERY_NODE_PHYSICAL_PLAN_INSERT: {




558,152,564✔





2591



      SDataInserterNode* pSink = (SDataInserterNode*)pNode;




558,152,564✔





2592



      destroyDataSinkNode((SDataSinkNode*)pSink);




558,152,564✔





2593



      taosMemFreeClear(pSink->pData);




558,150,963✔





2594



      break;




558,160,905✔





2595



    }










2596



    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: {




1,057,634✔





2597



      SQueryInserterNode* pSink = (SQueryInserterNode*)pNode;




1,057,634✔





2598



      destroyDataSinkNode((SDataSinkNode*)pSink);




1,057,634✔





2599



      nodesDestroyList(pSink->pCols);




1,057,634✔





2600



      break;




1,057,634✔





2601



    }










2602



    case QUERY_NODE_PHYSICAL_PLAN_DELETE: {




3,629,478✔





2603



      SDataDeleterNode* pSink = (SDataDeleterNode*)pNode;




3,629,478✔





2604



      destroyDataSinkNode((SDataSinkNode*)pSink);




3,629,478✔





2605



      nodesDestroyNode(pSink->pAffectedRows);




3,629,465✔





2606



      nodesDestroyNode(pSink->pStartTs);




3,629,478✔





2607



      nodesDestroyNode(pSink->pEndTs);




3,629,478✔





2608



      break;




3,629,478✔





2609



    }










2610



    case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: {




3,193,279✔





2611



      SGroupCachePhysiNode* pPhyNode = (SGroupCachePhysiNode*)pNode;




3,193,279✔





2612



      destroyPhysiNode((SPhysiNode*)pPhyNode);




3,193,279✔





2613



      nodesDestroyList(pPhyNode->pGroupCols);




3,193,279✔





2614



      break;




3,193,279✔





2615



    }










2616



    case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: {




10,624,085✔





2617



      SDynQueryCtrlPhysiNode* pPhyNode = (SDynQueryCtrlPhysiNode*)pNode;




10,624,085✔





2618



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




10,624,085✔





2619



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




6,778,144✔





2620



          pPhyNode->qType == DYN_QTYPE_VTB_WINDOW) {




4,497,952✔





2621



        nodesDestroyList(pPhyNode->vtbScan.pScanCols);




7,430,806✔





2622



        nodesDestroyList(pPhyNode->vtbScan.pOrgVgIds);




7,430,806✔





2623



      }










2624



      if (pPhyNode->qType == DYN_QTYPE_VTB_WINDOW) {




10,624,085✔





2625



        nodesDestroyList(pPhyNode->vtbWindow.pTargets);




1,304,673✔





2626



      }










2627



      destroyPhysiNode((SPhysiNode*)pPhyNode);




10,624,085✔





2628



      break;




10,624,085✔





2629



    }










2630



    case QUERY_NODE_PHYSICAL_SUBPLAN: {




1,676,160,510✔





2631



      SSubplan* pSubplan = (SSubplan*)pNode;




1,676,160,510✔





2632



      SNode*    pTmp = NULL;




1,676,160,510✔





2633



      WHERE_EACH(pTmp, pSubplan->pChildren) {




2,048,622,748✔





2634



        if (QUERY_NODE_VALUE == nodeType(pTmp)) {




372,453,601✔





2635



          ERASE_NODE(pSubplan->pChildren);




1,626,970✔





2636



          continue;




1,626,970✔





2637



        }










2638



        WHERE_NEXT;




370,826,631✔





2639



      }










2640



      nodesClearList(pSubplan->pChildren);




1,676,148,745✔





2641



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




1,676,051,709✔





2642



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




1,676,129,741✔





2643



      nodesDestroyList(pSubplan->pSubQ);




1,676,122,123✔





2644



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




1,676,149,291✔





2645



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




1,676,122,799✔





2646



      tSimpleHashCleanup(pSubplan->pVTables);




1,676,087,363✔





2647



      nodesClearList(pSubplan->pParents);




1,676,086,741✔





2648



      break;




1,676,101,363✔





2649



    }










2650



    case QUERY_NODE_PHYSICAL_PLAN:




903,615,514✔





2651



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




903,615,514✔





2652



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




903,595,669✔





2653



      break;




903,600,728✔





2654



    case QUERY_NODE_XNODE_TASK_SOURCE_OPT:




4,410✔





2655



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




4,410✔





2656



      break;




4,410✔





2657



    case QUERY_NODE_XNODE_TASK_SINK_OPT:




4,536✔





2658



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




4,536✔





2659



      break;




4,536✔





2660



    case QUERY_NODE_XNODE_TASK_OPTIONS: {




19,026✔





2661



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










2662



      SXnodeTaskOptions* pOptions = (SXnodeTaskOptions*)pNode;




19,026✔





2663



      taosMemFreeClear(pOptions->parser);




19,026✔





2664



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




58,968✔





2665



        taosMemFreeClear(pOptions->options[i]);




39,942✔





2666



      }










2667



      break;




19,026✔





2668



    }










2669



    case QUERY_NODE_ALTER_XNODE_STMT: {




882✔





2670



      SAlterXnodeStmt* pStmt = (SAlterXnodeStmt*)pNode;




882✔





2671



      xFreeCowStr(&pStmt->url);




882✔





2672



      xFreeCowStr(&pStmt->token);




882✔





2673



      xFreeCowStr(&pStmt->user);




882✔





2674



      xFreeCowStr(&pStmt->pass);




882✔





2675



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




882✔





2676



      break;




882✔





2677



    }










2678



    case QUERY_NODE_CREATE_XNODE_TASK_STMT: {




4,284✔





2679



      SCreateXnodeTaskStmt* pStmt = (SCreateXnodeTaskStmt*)pNode;




4,284✔





2680



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




4,284✔





2681



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




4,284✔





2682



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




4,284✔





2683



      break;




4,284✔





2684



    }










2685



    case QUERY_NODE_START_XNODE_TASK_STMT: {




126✔





2686



      SStartXnodeTaskStmt* pStmt = (SStartXnodeTaskStmt*)pNode;




126✔





2687



      xFreeCowStr(&pStmt->name);




126✔





2688



      break;




126✔





2689



    }










2690



    case QUERY_NODE_STOP_XNODE_TASK_STMT: {




126✔





2691



      SStopXnodeTaskStmt* pStmt = (SStopXnodeTaskStmt*)pNode;




126✔





2692



      xFreeCowStr(&pStmt->name);




126✔





2693



      break;




126✔





2694



    }










2695



    case QUERY_NODE_DROP_XNODE_TASK_STMT: {




3,402✔





2696



      SDropXnodeTaskStmt* pStmt = (SDropXnodeTaskStmt*)pNode;




3,402✔





2697



      taosMemFreeClear(pStmt->name);




3,402✔





2698



      break;




3,402✔





2699



    }










2700



    case QUERY_NODE_CREATE_XNODE_JOB_STMT: {




10,962✔





2701



      SCreateXnodeJobStmt* pStmt = (SCreateXnodeJobStmt*)pNode;




10,962✔





2702



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




10,962✔





2703



      break;




10,962✔





2704



    }










2705



    case QUERY_NODE_ALTER_XNODE_JOB_STMT: {




126✔





2706



      SAlterXnodeJobStmt* pStmt = (SAlterXnodeJobStmt*)pNode;




126✔





2707



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




126✔





2708



      break;




126✔





2709



    }










2710



    case QUERY_NODE_UPDATE_XNODE_TASK_STMT: {




504✔





2711



      SUpdateXnodeTaskStmt* pStmt = (SUpdateXnodeTaskStmt*)pNode;




504✔





2712



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




504✔





2713



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




504✔





2714



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




504✔





2715



      xFreeCowStr(&pStmt->name);




504✔





2716



      break;




504✔





2717



    }










2718



    case QUERY_NODE_REBALANCE_XNODE_JOB_STMT: {




252✔





2719



      SRebalanceXnodeJobStmt* pStmt = (SRebalanceXnodeJobStmt*)pNode;




252✔





2720



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




252✔





2721



      break;




252✔





2722



    }










2723



    case QUERY_NODE_REBALANCE_XNODE_JOB_WHERE_STMT: {




756✔





2724



      SRebalanceXnodeJobWhereStmt* pStmt = (SRebalanceXnodeJobWhereStmt*)pNode;




756✔





2725



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




756✔





2726



      break;




756✔





2727



    }










2728



    case QUERY_NODE_DROP_XNODE_JOB_STMT: {




20,664✔





2729



      SDropXnodeJobStmt* pStmt = (SDropXnodeJobStmt*)pNode;




20,664✔





2730



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




20,664✔





2731



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




20,664✔





2732



      break;




20,664✔





2733



    }










2734



    case QUERY_NODE_CREATE_XNODE_AGENT_STMT: {




2,394✔





2735



      SCreateXnodeAgentStmt* pStmt = (SCreateXnodeAgentStmt*)pNode;




2,394✔





2736



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




2,394✔





2737



      break;




2,394✔





2738



    }










2739



    case QUERY_NODE_ALTER_XNODE_AGENT_STMT: {




378✔





2740



      SAlterXnodeAgentStmt* pStmt = (SAlterXnodeAgentStmt*)pNode;




378✔





2741



      xFreeCowStr(&pStmt->name);




378✔





2742



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




378✔





2743



      break;




378✔





2744



    }










2745



    case QUERY_NODE_DROP_XNODE_AGENT_STMT: {




24✔





2746



      SDropXnodeAgentStmt* pStmt = (SDropXnodeAgentStmt*)pNode;




24✔





2747



      taosMemFreeClear(pStmt->name);




24✔





2748



      break;




2,520✔





2749



    }










2750



    default:




89,171✔





2751



      break;




89,171✔





2752



  }










2753



  nodesFree(pNode);




2,147,483,647✔





2754



  return;




2,147,483,647✔





2755



}










2756












2757



int32_t nodesMakeList(SNodeList** ppListOut) {




2,147,483,647✔





2758



  SNodeList* p = NULL;




2,147,483,647✔





2759



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




2,147,483,647✔





2760



  if (TSDB_CODE_SUCCESS == code) {




2,147,483,647✔





2761



    *ppListOut = p;




2,147,483,647✔





2762



  }










2763



  return code;




2,147,483,647✔





2764



}










2765












2766



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




2,147,483,647✔





2767



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




2,147,483,647✔





2768



    return TSDB_CODE_INVALID_PARA;




×







2769



  }










2770



  SListCell* p = NULL;




2,147,483,647✔





2771



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




2,147,483,647✔





2772



  if (TSDB_CODE_SUCCESS != code) {




2,147,483,647✔





2773



    return code;




×







2774



  }










2775



  p->pNode = pNode;




2,147,483,647✔





2776



  if (NULL == pList->pHead) {




2,147,483,647✔





2777



    pList->pHead = p;




2,147,483,647✔





2778



  }










2779



  if (NULL != pList->pTail) {




2,147,483,647✔





2780



    pList->pTail->pNext = p;




2,147,483,647✔





2781



  }










2782



  p->pPrev = pList->pTail;




2,147,483,647✔





2783



  pList->pTail = p;




2,147,483,647✔





2784



  ++(pList->length);




2,147,483,647✔





2785



  return TSDB_CODE_SUCCESS;




2,147,483,647✔





2786



}










2787












2788



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




2,147,483,647✔





2789



  if (NULL == pNode) {




2,147,483,647✔





2790



    return TSDB_CODE_INVALID_PARA;




×







2791



  }










2792



  int32_t code = nodesListAppend(pList, pNode);




2,147,483,647✔





2793



  if (TSDB_CODE_SUCCESS != code) {




2,147,483,647✔





2794



    nodesDestroyNode(pNode);




×







2795



  }










2796



  return code;




2,147,483,647✔





2797



}










2798












2799



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




2,147,483,647✔





2800



  if (NULL == *pList) {




2,147,483,647✔





2801



    int32_t code = nodesMakeList(pList);




1,485,079,496✔





2802



    if (NULL == *pList) {




1,485,100,355✔





2803



      return code;




×







2804



    }










2805



  }










2806



  return nodesListAppend(*pList, pNode);




2,147,483,647✔





2807



}










2808












2809



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




2,147,483,647✔





2810



  if (NULL == *pList) {




2,147,483,647✔





2811



    int32_t code = nodesMakeList(pList);




2,147,483,647✔





2812



    if (NULL == *pList) {




2,147,483,647✔





2813



      nodesDestroyNode(pNode);




×







2814



      return code;




×







2815



    }










2816



  }










2817



  return nodesListStrictAppend(*pList, pNode);




2,147,483,647✔





2818



}










2819












2820



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




32,428,072✔





2821



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




32,428,072✔





2822



    return TSDB_CODE_FAILED;




×







2823



  }










2824












2825



  if (NULL == pTarget->pHead) {




32,428,072✔





2826



    pTarget->pHead = pSrc->pHead;




27,424,418✔





2827



  } else {










2828



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




5,003,654✔





2829



    if (NULL != pSrc->pHead) {




5,003,654✔





2830



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




5,003,654✔





2831



    }










2832



  }










2833



  pTarget->pTail = pSrc->pTail;




32,428,072✔





2834



  pTarget->length += pSrc->length;




32,428,072✔





2835



  nodesFree(pSrc);




32,428,072✔





2836












2837



  return TSDB_CODE_SUCCESS;




32,428,072✔





2838



}










2839












2840



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




2,209,223✔





2841



  if (NULL == pSrc) {




2,209,223✔





2842



    return TSDB_CODE_OUT_OF_MEMORY;




×







2843



  }










2844



  int32_t code = nodesListAppendList(pTarget, pSrc);




2,209,223✔





2845



  if (TSDB_CODE_SUCCESS != code) {




2,209,223✔





2846



    nodesDestroyList(pSrc);




×







2847



  }










2848



  return code;




2,209,223✔





2849



}










2850












2851



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




241,514✔





2852



  if (NULL == *pTarget) {




241,514✔





2853



    int32_t code = nodesMakeList(pTarget);




185,269✔





2854



    if (NULL == *pTarget) {




185,269✔





2855



      return code;




×







2856



    }










2857



  }










2858



  return nodesListStrictAppendList(*pTarget, pSrc);




241,514✔





2859



}










2860












2861



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




5,038,402✔





2862



  if (*pList == NULL) {




5,038,402✔





2863



    int32_t code = nodesMakeList(pList);




4,608,662✔





2864



    if (*pList == NULL) {




4,609,283✔





2865



      return code;




×







2866



    }










2867



  }










2868



  return nodesListPushFront(*pList, pNode);




5,039,023✔





2869



}










2870












2871



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




5,441,903✔





2872



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




5,441,903✔





2873



    return TSDB_CODE_FAILED;




×







2874



  }










2875



  SListCell* p = NULL;




5,442,563✔





2876



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




5,442,563✔





2877



  if (TSDB_CODE_SUCCESS != code) {




5,442,940✔





2878



    return code;




×







2879



  }










2880



  p->pNode = pNode;




5,442,940✔





2881



  if (NULL != pList->pHead) {




5,442,940✔





2882



    pList->pHead->pPrev = p;




433,877✔





2883



    p->pNext = pList->pHead;




433,877✔





2884



  }










2885



  pList->pHead = p;




5,442,940✔





2886



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




5,442,940✔





2887



  ++(pList->length);




5,442,940✔





2888



  return TSDB_CODE_SUCCESS;




5,442,940✔





2889



}










2890












2891



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










2892



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




2,147,483,647✔





2893



  if (NULL == pCell->pPrev) {




2,147,483,647✔





2894



    pList->pHead = pCell->pNext;




2,147,483,647✔





2895



  } else {










2896



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




238,798,892✔





2897



  }










2898



  if (NULL == pCell->pNext) {




2,147,483,647✔





2899



    pList->pTail = pCell->pPrev;




2,147,483,647✔





2900



  } else {










2901



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




2,147,483,647✔





2902



  }










2903



  SListCell* pNext = pCell->pNext;




2,147,483,647✔





2904



  nodesDestroyNode(pCell->pNode);




2,147,483,647✔





2905



  nodesFree(pCell);




2,147,483,647✔





2906



  --(pList->length);




2,147,483,647✔





2907



  return pNext;




2,147,483,647✔





2908



}










2909












2910



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




55,995,730✔





2911



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




55,995,730✔





2912



    return;




14,798✔





2913



  }










2914












2915



  if (NULL == pPos->pPrev) {




55,984,015✔





2916



    pTarget->pHead = pSrc->pHead;




48,734,631✔





2917



  } else {










2918



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




7,249,375✔





2919



  }










2920



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




55,983,984✔





2921



  pSrc->pTail->pNext = pPos;




55,983,997✔





2922



  pPos->pPrev = pSrc->pTail;




55,984,000✔





2923












2924



  pTarget->length += pSrc->length;




55,983,963✔





2925



  nodesFree(pSrc);




55,983,951✔





2926



}










2927












2928



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




4,348✔





2929



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




4,348✔





2930



    return;




×







2931



  }










2932












2933



  if (NULL == pPos->pNext) {




4,348✔





2934



    pTarget->pTail = pSrc->pHead;




4,348✔





2935



  } else {










2936



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




×







2937



  }










2938












2939



  pSrc->pHead->pPrev = pPos;




4,348✔





2940



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




4,348✔





2941












2942



  pPos->pNext = pSrc->pHead;




4,348✔





2943












2944



  pTarget->length += pSrc->length;




4,348✔





2945



  nodesFree(pSrc);




4,348✔





2946



}










2947












2948



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




2,147,483,647✔





2949



  SNode* node;










2950



  FOREACH(node, pList) {




2,147,483,647✔





2951



    if (0 == index--) {




2,147,483,647✔





2952



      return node;




2,147,483,647✔





2953



    }










2954



  }










2955



  return NULL;




184,762,145✔





2956



}










2957












2958












2959



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




30,068,066✔





2960



  SNode* node;










2961



  FOREACH(node, pList) {




857,497,150✔





2962



    if (0 == index--) {




857,496,728✔





2963



      return cell;




30,067,644✔





2964



    }










2965



  }










2966



  return NULL;




×







2967



}










2968












2969



void nodesDestroyList(SNodeList* pList) {




2,147,483,647✔





2970



  if (NULL == pList) {




2,147,483,647✔





2971



    return;




2,147,483,647✔





2972



  }










2973












2974



  SListCell* pNext = pList->pHead;




2,147,483,647✔





2975



  while (NULL != pNext) {




2,147,483,647✔





2976



    pNext = nodesListErase(pList, pNext);




2,147,483,647✔





2977



  }










2978



  nodesFree(pList);




2,147,483,647✔





2979



}










2980












2981



void nodesClearList(SNodeList* pList) {




2,147,483,647✔





2982



  if (NULL == pList) {




2,147,483,647✔





2983



    return;




2,147,483,647✔





2984



  }










2985












2986



  SListCell* pNext = pList->pHead;




2,147,483,647✔





2987



  while (NULL != pNext) {




2,147,483,647✔





2988



    SListCell* tmp = pNext;




2,147,483,647✔





2989



    pNext = pNext->pNext;




2,147,483,647✔





2990



    nodesFree(tmp);




2,147,483,647✔





2991



  }










2992



  nodesFree(pList);




2,147,483,647✔





2993



}










2994












2995



void* nodesGetValueFromNode(SValueNode* pNode) {




1,255,108,434✔





2996



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




1,255,108,434✔





2997



    case TSDB_DATA_TYPE_BOOL:




1,162,901,634✔





2998



    case TSDB_DATA_TYPE_TINYINT:










2999



    case TSDB_DATA_TYPE_SMALLINT:










3000



    case TSDB_DATA_TYPE_INT:










3001



    case TSDB_DATA_TYPE_BIGINT:










3002



    case TSDB_DATA_TYPE_TIMESTAMP:










3003



    case TSDB_DATA_TYPE_UTINYINT:










3004



    case TSDB_DATA_TYPE_USMALLINT:










3005



    case TSDB_DATA_TYPE_UINT:










3006



    case TSDB_DATA_TYPE_UBIGINT:










3007



    case TSDB_DATA_TYPE_FLOAT:










3008



    case TSDB_DATA_TYPE_DOUBLE:










3009



    case TSDB_DATA_TYPE_DECIMAL64:










3010



      return (void*)&pNode->typeData;




1,162,901,634✔





3011



    case TSDB_DATA_TYPE_NCHAR:




92,305,280✔





3012



    case TSDB_DATA_TYPE_VARCHAR:










3013



    case TSDB_DATA_TYPE_VARBINARY:










3014



    case TSDB_DATA_TYPE_BLOB:










3015



    case TSDB_DATA_TYPE_MEDIUMBLOB:










3016



    case TSDB_DATA_TYPE_JSON:










3017



    case TSDB_DATA_TYPE_GEOMETRY:










3018



    case TSDB_DATA_TYPE_DECIMAL:










3019



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




92,305,280✔





3020



    default:




51✔





3021



      break;




51✔





3022



  }










3023












3024



  return NULL;




51✔





3025



}










3026












3027



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




432,257,867✔





3028



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




432,257,867✔





3029



    case TSDB_DATA_TYPE_NULL:




2,024✔





3030



      break;




2,024✔





3031



    case TSDB_DATA_TYPE_BOOL:




18,041,133✔





3032



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




18,041,133✔





3033



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




18,041,762✔





3034



      break;




18,041,762✔





3035



    case TSDB_DATA_TYPE_TINYINT:




86,423✔





3036



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




86,423✔





3037



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




86,423✔





3038



      break;




86,423✔





3039



    case TSDB_DATA_TYPE_SMALLINT:




143,178✔





3040



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




143,178✔





3041



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




143,178✔





3042



      break;




143,301✔





3043



    case TSDB_DATA_TYPE_INT:




34,360,039✔





3044



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




34,360,039✔





3045



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




34,359,812✔





3046



      break;




34,358,379✔





3047



    case TSDB_DATA_TYPE_BIGINT:




12,329,973✔





3048



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




12,329,973✔





3049



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




12,329,734✔





3050



      break;




12,329,734✔





3051



    case TSDB_DATA_TYPE_TIMESTAMP:




364,436,830✔





3052



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




364,436,830✔





3053



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




364,506,900✔





3054



      break;




364,507,974✔





3055



    case TSDB_DATA_TYPE_UTINYINT:




34,241✔





3056



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




34,241✔





3057



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




34,241✔





3058



      break;




34,241✔





3059



    case TSDB_DATA_TYPE_USMALLINT:




17,783✔





3060



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




17,783✔





3061



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




17,783✔





3062



      break;




17,783✔





3063



    case TSDB_DATA_TYPE_UINT:




30,647✔





3064



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




30,647✔





3065



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




30,647✔





3066



      break;




30,647✔





3067



    case TSDB_DATA_TYPE_UBIGINT:




19,885✔





3068



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




19,885✔





3069



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




19,885✔





3070



      break;




19,885✔





3071



    case TSDB_DATA_TYPE_FLOAT:




151,252✔





3072



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




151,252✔





3073



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




151,252✔





3074



      break;




151,252✔





3075



    case TSDB_DATA_TYPE_DOUBLE:




2,594,355✔





3076



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




2,594,355✔





3077



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




2,594,355✔





3078



      break;




2,594,355✔





3079



    case TSDB_DATA_TYPE_NCHAR:




×







3080



    case TSDB_DATA_TYPE_VARCHAR:










3081



    case TSDB_DATA_TYPE_VARBINARY:










3082



    case TSDB_DATA_TYPE_JSON:










3083



    case TSDB_DATA_TYPE_BLOB:










3084



    case TSDB_DATA_TYPE_MEDIUMBLOB:










3085



    case TSDB_DATA_TYPE_GEOMETRY:










3086



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




×







3087



      break;




×







3088



    case TSDB_DATA_TYPE_DECIMAL64:




15,116✔





3089



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




15,116✔





3090



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




15,116✔





3091



      break;




15,116✔





3092



    case TSDB_DATA_TYPE_DECIMAL:




×







3093



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




×







3094



      break;




227✔





3095



    default:




×







3096



      return TSDB_CODE_APP_ERROR;




×







3097



  }










3098












3099



  return TSDB_CODE_SUCCESS;




432,303,075✔





3100



}










3101












3102












3103



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




13,833,709✔





3104



  *needFree = true;




13,833,709✔





3105












3106



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




13,833,709✔





3107



    case TSDB_DATA_TYPE_NULL:




×







3108



      break;




×







3109



    case TSDB_DATA_TYPE_BOOL:




625,248✔





3110



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




625,248✔





3111



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




625,248✔





3112



      break;




625,248✔





3113



    case TSDB_DATA_TYPE_TINYINT:




625,248✔





3114



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




625,248✔





3115



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




625,248✔





3116



      break;




625,248✔





3117



    case TSDB_DATA_TYPE_SMALLINT:




625,248✔





3118



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




625,248✔





3119



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




625,248✔





3120



      break;




625,248✔





3121



    case TSDB_DATA_TYPE_INT:




1,246,160✔





3122



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




1,246,160✔





3123



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




1,246,160✔





3124



      break;




1,246,160✔





3125



    case TSDB_DATA_TYPE_BIGINT:




2,828,275✔





3126



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




2,828,275✔





3127



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




2,828,275✔





3128



      break;




2,828,822✔





3129



    case TSDB_DATA_TYPE_TIMESTAMP:




1,314,014✔





3130



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




1,314,014✔





3131



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




1,314,014✔





3132



      break;




1,314,014✔





3133



    case TSDB_DATA_TYPE_UTINYINT:




625,248✔





3134



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




625,248✔





3135



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




625,248✔





3136



      break;




625,248✔





3137



    case TSDB_DATA_TYPE_USMALLINT:




625,248✔





3138



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




625,248✔





3139



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




625,248✔





3140



      break;




625,248✔





3141



    case TSDB_DATA_TYPE_UINT:




625,248✔





3142



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




625,248✔





3143



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




625,248✔





3144



      break;




625,248✔





3145



    case TSDB_DATA_TYPE_UBIGINT:




626,476✔





3146



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




626,476✔





3147



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




626,476✔





3148



      break;




626,476✔





3149



    case TSDB_DATA_TYPE_FLOAT:




625,248✔





3150



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




625,248✔





3151



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




625,248✔





3152



      break;




625,248✔





3153



    case TSDB_DATA_TYPE_DOUBLE:




941,056✔





3154



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




941,056✔





3155



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




941,056✔





3156



      break;




941,056✔





3157



    case TSDB_DATA_TYPE_NCHAR:




1,875,744✔





3158



    case TSDB_DATA_TYPE_VARCHAR:










3159



    case TSDB_DATA_TYPE_VARBINARY:










3160



    case TSDB_DATA_TYPE_JSON:










3161



    case TSDB_DATA_TYPE_BLOB:










3162



    case TSDB_DATA_TYPE_MEDIUMBLOB:










3163



    case TSDB_DATA_TYPE_GEOMETRY:










3164



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




1,875,744✔





3165



      *needFree = false;




1,875,744✔





3166



      break;




1,875,744✔





3167



    case TSDB_DATA_TYPE_DECIMAL64:




625,248✔





3168



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




625,248✔





3169



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




625,248✔





3170



      break;




625,248✔





3171



    case TSDB_DATA_TYPE_DECIMAL:




×







3172



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




×







3173



      *needFree = false;




×








UNCOV

3174



      break;




×







3175



    default:




×







3176



      return TSDB_CODE_APP_ERROR;




×







3177



  }










3178












3179



  return TSDB_CODE_SUCCESS;




13,834,256✔





3180



}










3181












3182












3183



char* nodesGetStrValueFromNode(SValueNode* pNode) {




5,264,949✔





3184



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




5,264,949✔





3185



    case TSDB_DATA_TYPE_NULL: {




2,192✔





3186



      return tstrdup("NULL");




2,192✔





3187



    }










3188



    case TSDB_DATA_TYPE_BOOL: {




10,121✔





3189



      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);




10,121✔





3190



      if (NULL == buf) {




10,121✔





3191



        return NULL;




×







3192



      }










3193












3194



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




10,121✔





3195



      return buf;




10,121✔





3196



    }










3197



    case TSDB_DATA_TYPE_TINYINT:




5,158,847✔





3198



    case TSDB_DATA_TYPE_SMALLINT:










3199



    case TSDB_DATA_TYPE_INT:










3200



    case TSDB_DATA_TYPE_BIGINT:










3201



    case TSDB_DATA_TYPE_TIMESTAMP: {










3202



      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);




5,158,847✔





3203



      if (NULL == buf) {




5,159,206✔





3204



        return NULL;




×







3205



      }










3206












3207



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




5,159,206✔





3208



      return buf;




5,159,206✔





3209



    }










3210



    case TSDB_DATA_TYPE_UTINYINT:




×







3211



    case TSDB_DATA_TYPE_USMALLINT:










3212



    case TSDB_DATA_TYPE_UINT:










3213



    case TSDB_DATA_TYPE_UBIGINT: {










3214



      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);




×







3215



      if (NULL == buf) {




×







3216



        return NULL;




×







3217



      }










3218












3219



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




×







3220



      return buf;




×







3221



    }










3222



    case TSDB_DATA_TYPE_FLOAT:




1,616✔





3223



    case TSDB_DATA_TYPE_DOUBLE: {










3224



      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);




1,616✔





3225



      if (NULL == buf) {




1,616✔





3226



        return NULL;




×







3227



      }










3228












3229



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




1,616✔





3230



      return buf;




1,616✔





3231



    }










3232



    case TSDB_DATA_TYPE_NCHAR:




92,094✔





3233



    case TSDB_DATA_TYPE_VARCHAR:










3234



    case TSDB_DATA_TYPE_VARBINARY:










3235



    case TSDB_DATA_TYPE_GEOMETRY: {










3236



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




92,094✔





3237



      void*   buf = taosMemoryMalloc(bufSize);




92,094✔





3238



      if (NULL == buf) {




92,094✔





3239



        return NULL;




×







3240



      }










3241












3242



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




92,094✔





3243



      return buf;




92,094✔





3244



    }










3245



    case TSDB_DATA_TYPE_BLOB: {




×







3246



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




×







3247



      void*   buf = taosMemoryMalloc(bufSize);




×







3248



      if (NULL == buf) {




×







3249



        return NULL;




×







3250



      }










3251












3252



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




×







3253



      return buf;




×







3254



    }










3255



    default:




79✔





3256



      break;




79✔





3257



  }










3258












3259



  return NULL;




79✔





3260



}










3261












3262



bool nodesIsExprNode(const SNode* pNode) {




2,147,483,647✔





3263



  ENodeType type = nodeType(pNode);




2,147,483,647✔





3264



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




2,147,483,647✔





3265



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




827,630,372✔





3266



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




558,391,051✔





3267



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




2,147,483,647✔





3268



}










3269












3270



bool nodesIsUnaryOp(const SOperatorNode* pOp) {




×







3271



  switch (pOp->opType) {




×







3272



    case OP_TYPE_MINUS:




×







3273



    case OP_TYPE_IS_NULL:










3274



    case OP_TYPE_IS_NOT_NULL:










3275



    case OP_TYPE_IS_TRUE:










3276



    case OP_TYPE_IS_FALSE:










3277



    case OP_TYPE_IS_UNKNOWN:










3278



    case OP_TYPE_IS_NOT_TRUE:










3279



    case OP_TYPE_IS_NOT_FALSE:










3280



    case OP_TYPE_IS_NOT_UNKNOWN:










3281



      return true;




×







3282



    default:




×







3283



      break;




×







3284



  }










3285



  return false;




×







3286



}










3287












3288



bool nodesIsArithmeticOp(const SOperatorNode* pOp) {




×







3289



  switch (pOp->opType) {




×







3290



    case OP_TYPE_ADD:




×







3291



    case OP_TYPE_SUB:










3292



    case OP_TYPE_MULTI:










3293



    case OP_TYPE_DIV:










3294



    case OP_TYPE_REM:










3295



      return true;




×







3296



    default:




×







3297



      break;




×







3298



  }










3299



  return false;




×







3300



}










3301












3302



bool nodesIsBasicArithmeticOp(const SOperatorNode* pOp) {




138,187,666✔





3303



  switch (pOp->opType) {




138,187,666✔





3304



    case OP_TYPE_ADD:




2,375,814✔





3305



    case OP_TYPE_SUB:










3306



    case OP_TYPE_MULTI:










3307



    case OP_TYPE_DIV:










3308



      return true;




2,375,814✔





3309



    default:




135,811,852✔





3310



      break;




135,811,852✔





3311



  }










3312



  return false;




135,811,852✔





3313



}










3314












3315



bool nodesIsComparisonOp(const SOperatorNode* pOp) {




258,437,123✔





3316



  switch (pOp->opType) {




258,437,123✔





3317



    case OP_TYPE_GREATER_THAN:




258,393,606✔





3318



    case OP_TYPE_GREATER_EQUAL:










3319



    case OP_TYPE_LOWER_THAN:










3320



    case OP_TYPE_LOWER_EQUAL:










3321



    case OP_TYPE_EQUAL:










3322



    case OP_TYPE_NOT_EQUAL:










3323



    case OP_TYPE_IN:










3324



    case OP_TYPE_NOT_IN:










3325



    case OP_TYPE_LIKE:










3326



    case OP_TYPE_NOT_LIKE:










3327



    case OP_TYPE_MATCH:










3328



    case OP_TYPE_NMATCH:










3329



    case OP_TYPE_JSON_CONTAINS:










3330



    case OP_TYPE_IS_NULL:










3331



    case OP_TYPE_IS_NOT_NULL:










3332



    case OP_TYPE_IS_TRUE:










3333



    case OP_TYPE_IS_FALSE:










3334



    case OP_TYPE_IS_UNKNOWN:










3335



    case OP_TYPE_IS_NOT_TRUE:










3336



    case OP_TYPE_IS_NOT_FALSE:










3337



    case OP_TYPE_IS_NOT_UNKNOWN:










3338



    case OP_TYPE_EXISTS:










3339



    case OP_TYPE_NOT_EXISTS:










3340



      return true;




258,393,606✔





3341



    default:




49,472✔





3342



      break;




49,472✔





3343



  }










3344



  return false;




49,472✔





3345



}










3346












3347



bool nodesIsJsonOp(const SOperatorNode* pOp) {




×







3348



  switch (pOp->opType) {




×







3349



    case OP_TYPE_JSON_GET_VALUE:




×







3350



    case OP_TYPE_JSON_CONTAINS:










3351



      return true;




×







3352



    default:




×







3353



      break;




×







3354



  }










3355



  return false;




×







3356



}










3357












3358



bool nodesIsRegularOp(const SOperatorNode* pOp) {




324,807,338✔





3359



  switch (pOp->opType) {




324,807,338✔





3360



    case OP_TYPE_LIKE:




11,858,893✔





3361



    case OP_TYPE_NOT_LIKE:










3362



    case OP_TYPE_MATCH:










3363



    case OP_TYPE_NMATCH:










3364



      return true;




11,858,893✔





3365



    default:




312,948,445✔





3366



      break;




312,948,445✔





3367



  }










3368



  return false;




312,948,445✔





3369



}










3370












3371



bool nodesIsMatchRegularOp(const SOperatorNode* pOp) {




11,823,741✔





3372



  switch (pOp->opType) {




11,823,741✔





3373



    case OP_TYPE_MATCH:




6,253,028✔





3374



    case OP_TYPE_NMATCH:










3375



      return true;




6,253,028✔





3376



    default:




5,570,713✔





3377



      break;




5,570,713✔





3378



  }










3379



  return false;




5,570,713✔





3380



}










3381












3382



bool nodesIsBitwiseOp(const SOperatorNode* pOp) {




×







3383



  switch (pOp->opType) {




×







3384



    case OP_TYPE_BIT_AND:




×







3385



    case OP_TYPE_BIT_OR:










3386



      return true;




×







3387



    default:




×







3388



      break;




×







3389



  }










3390



  return false;




×







3391



}










3392












3393



typedef struct SCollectColumnsCxt {










3394



  int32_t         errCode;










3395



  const char*     pTableAlias;










3396



  SSHashObj*      pMultiTableAlias;










3397



  ECollectColType collectType;










3398



  SNodeList*      pCols;










3399



  SHashObj*       pColHash;










3400



} SCollectColumnsCxt;










3401












3402



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




2,147,483,647✔





3403



  char    name[TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN];




2,030,029,714✔





3404



  int32_t len = 0;




2,147,483,647✔





3405



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




2,147,483,647✔





3406



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




83,743,542✔





3407



  } else {










3408



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




2,147,483,647✔





3409



  }










3410



  if (pCol->projRefIdx > 0) {




2,147,483,647✔





3411



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




4,655,439✔





3412



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




4,655,439✔





3413



  }










3414



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




2,147,483,647✔





3415



  if (pNodeFound == NULL) {




2,147,483,647✔





3416



    SNode* pNew = NULL;




1,811,119,840✔





3417



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




1,811,120,265✔





3418



    if (TSDB_CODE_SUCCESS == pCxt->errCode) {




1,811,202,353✔





3419



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




1,811,201,432✔





3420



    }










3421



    if (TSDB_CODE_SUCCESS == pCxt->errCode) {




1,811,227,580✔





3422



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










3423



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




1,811,224,950✔





3424



    } else {










3425



      nodesDestroyNode(pNew);




2,187✔





3426



    }










3427



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




1,811,234,934✔





3428



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




619,874,484✔





3429



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




619,864,786✔





3430



    if (pExistCol->appendByPrivCond == 1) {




619,864,782✔





3431



      pExistCol->appendByPrivCond = 0;




5,648✔





3432



    }










3433



  }










3434



  return DEAL_RES_CONTINUE;




619,874,354✔





3435



}










3436












3437



static bool isCollectType(ECollectColType collectType, EColumnType colType) {




2,147,483,647✔





3438



  return COLLECT_COL_TYPE_ALL == collectType










3439



             ? true










3440



             : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType




2,147,483,647✔





3441



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




1,698,203,034✔





3442



}










3443












3444



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




2,147,483,647✔





3445



  SCollectColumnsCxt* pCxt = (SCollectColumnsCxt*)pContext;




2,147,483,647✔





3446



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




2,147,483,647✔





3447



    SColumnNode* pCol = (SColumnNode*)pNode;




2,147,483,647✔





3448



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




2,147,483,647✔





3449



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




2,147,483,647✔





3450



      return doCollect(pCxt, pCol, pNode);




2,147,483,647✔





3451



    }










3452



  }










3453



  return DEAL_RES_CONTINUE;




2,147,483,647✔





3454



}










3455












3456



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




139,452,777✔





3457



  SCollectColumnsCxt* pCxt = (SCollectColumnsCxt*)pContext;




139,452,777✔





3458



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




139,452,777✔





3459



    SColumnNode* pCol = (SColumnNode*)pNode;




73,914,095✔





3460



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




73,914,095✔





3461



        (NULL == pCxt->pMultiTableAlias ||




73,914,596✔





3462



         NULL != (pCxt->pTableAlias =




73,915,014✔





3463



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




73,914,601✔





3464



      return doCollect(pCxt, pCol, pNode);




73,326,723✔





3465



    }










3466



  }










3467



  return DEAL_RES_CONTINUE;




66,126,490✔





3468



}










3469












3470



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




965,503,194✔





3471



                            SNodeList** pCols) {










3472



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




965,503,194✔





3473



    return TSDB_CODE_FAILED;




745✔





3474



  }










3475



  SNodeList* pList = NULL;




965,595,476✔





3476



  if (!*pCols) {




965,595,663✔





3477



    int32_t code = nodesMakeList(&pList);




965,615,944✔





3478



    if (TSDB_CODE_SUCCESS != code) {




965,585,809✔





3479



      return code;




×







3480



    }










3481



  }










3482



  SCollectColumnsCxt cxt = {




1,836,152,389✔





3483



      .errCode = TSDB_CODE_SUCCESS,










3484



      .pTableAlias = pTableAlias,










3485



      .collectType = type,










3486



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




965,566,155✔





3487



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




965,561,690✔





3488



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




965,659,275✔





3489



    return TSDB_CODE_OUT_OF_MEMORY;




×







3490



  }










3491



  *pCols = NULL;




965,659,275✔





3492



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




965,659,233✔





3493



  taosHashCleanup(cxt.pColHash);




965,664,962✔





3494



  if (TSDB_CODE_SUCCESS != cxt.errCode) {




965,642,494✔





3495



    nodesDestroyList(cxt.pCols);




×







3496



    return cxt.errCode;




×







3497



  }










3498



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




965,642,494✔





3499



    *pCols = cxt.pCols;




495,042,678✔





3500



  } else {










3501



    nodesDestroyList(cxt.pCols);




470,600,861✔





3502



  }










3503












3504



  return TSDB_CODE_SUCCESS;




965,646,394✔





3505



}










3506












3507



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




22,858,906✔





3508



                               ECollectColType type, SNodeList** pCols) {










3509



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




22,858,906✔





3510



    return TSDB_CODE_FAILED;




×







3511



  }










3512












3513



  SNodeList* pList = NULL;




22,860,595✔





3514



  if (!*pCols) {




22,860,595✔





3515



    int32_t code = nodesMakeList(&pList);




22,861,071✔





3516



    if (TSDB_CODE_SUCCESS != code) {




22,861,169✔





3517



      return code;




×







3518



    }










3519



  }










3520












3521



  SCollectColumnsCxt cxt = {




36,893,290✔





3522



      .errCode = TSDB_CODE_SUCCESS,










3523



      .pTableAlias = NULL,










3524



      .pMultiTableAlias = pMultiTableAlias,










3525



      .collectType = type,










3526



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




22,860,693✔





3527



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




22,860,693✔





3528



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




22,861,212✔





3529



    return TSDB_CODE_OUT_OF_MEMORY;




×







3530



  }










3531



  *pCols = NULL;




22,861,212✔





3532



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




22,861,212✔





3533



  taosHashCleanup(cxt.pColHash);




22,861,666✔





3534



  if (TSDB_CODE_SUCCESS != cxt.errCode) {




22,861,653✔





3535



    nodesDestroyList(cxt.pCols);




×







3536



    return cxt.errCode;




×







3537



  }










3538



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




22,861,653✔





3539



    *pCols = cxt.pCols;




21,549,061✔





3540



  } else {










3541



    nodesDestroyList(cxt.pCols);




1,312,592✔





3542



  }










3543












3544



  return TSDB_CODE_SUCCESS;




22,861,653✔





3545



}










3546












3547



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




511,862,763✔





3548



                                          ECollectColType type, SNodeList** pCols) {










3549



  if (NULL == pCols) {




511,862,763✔





3550



    return TSDB_CODE_FAILED;




×







3551



  }










3552



  SNodeList* pList = NULL;




511,862,763✔





3553



  if (!*pCols) {




511,862,763✔





3554



    int32_t code = nodesMakeList(&pList);




2,746,499✔





3555



    if (TSDB_CODE_SUCCESS != code) {




2,746,499✔





3556



      return code;




×







3557



    }










3558



  }










3559












3560



  SCollectColumnsCxt cxt = {




687,203,720✔





3561



      .errCode = TSDB_CODE_SUCCESS,










3562



      .pTableAlias = pTableAlias,










3563



      .collectType = type,










3564



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




511,863,123✔





3565



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




511,863,894✔





3566



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




511,893,331✔





3567



    return TSDB_CODE_OUT_OF_MEMORY;




×







3568



  }










3569



  *pCols = NULL;




511,893,331✔





3570












3571



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




1,023,788,137✔





3572



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




511,893,440✔





3573



    if (TSDB_CODE_SUCCESS != cxt.errCode) {




511,895,650✔





3574



      break;




×







3575



    }










3576



  }










3577












3578



  taosHashCleanup(cxt.pColHash);




511,894,697✔





3579



  if (TSDB_CODE_SUCCESS != cxt.errCode) {




511,891,841✔





3580



    nodesDestroyList(cxt.pCols);




×







3581



    return cxt.errCode;




×







3582



  }










3583



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




511,891,841✔





3584



    *pCols = cxt.pCols;




433,579,014✔





3585



  } else {










3586



    nodesDestroyList(cxt.pCols);




78,310,768✔





3587



  }










3588












3589



  return TSDB_CODE_SUCCESS;




511,889,042✔





3590



}










3591












3592



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




511,860,588✔





3593



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




511,860,588✔





3594



}










3595












3596



typedef struct SCollectFuncsCxt {










3597



  int32_t         errCode;










3598



  char*           tableAlias;










3599



  FFuncClassifier classifier;










3600



  SNodeList*      pFuncs;










3601



} SCollectFuncsCxt;










3602












3603



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




2,147,483,647✔





3604



  SCollectFuncsCxt* pCxt = (SCollectFuncsCxt*)pContext;




2,147,483,647✔





3605



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




2,147,483,647✔





3606



    SFunctionNode* pFunc = (SFunctionNode*)pNode;




537,227,611✔





3607



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




537,227,611✔





3608



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




74,409,417✔





3609



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




74,410,024✔





3610



        return DEAL_RES_CONTINUE;




89,929✔





3611



      }










3612



    }










3613












3614



    bool   bFound = false;




537,138,346✔





3615



    SNode* pn = NULL;




537,138,346✔





3616



    FOREACH(pn, pCxt->pFuncs) {




2,147,483,647✔





3617



      if (nodesEqualNode(pn, pNode)) {




2,005,735,730✔





3618



        bFound = true;




89,976,395✔





3619



        break;




89,976,395✔





3620



      }










3621



    }










3622



    if (!bFound) {




537,134,152✔





3623



      SNode* pNew = NULL;




447,152,020✔





3624



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




447,152,199✔





3625



      if (TSDB_CODE_SUCCESS == pCxt->errCode) {




447,176,273✔





3626



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




447,176,173✔





3627



      }










3628



    }










3629



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




537,168,785✔





3630



  }










3631



  return DEAL_RES_CONTINUE;




2,147,483,647✔





3632



}










3633












3634



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




×







3635



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




×







3636



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




×







3637



}










3638












3639



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




×







3640



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










3641



  //   return 1;










3642



  // }










3643



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




×







3644



}










3645












3646



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




11,851,940✔





3647



                                SNodeList* pFuncs) {










3648



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




11,851,940✔





3649



    return TSDB_CODE_FAILED;




×







3650



  }










3651












3652



  SCollectFuncsCxt cxt = {




11,852,970✔





3653



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










3654












3655



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




11,852,970✔





3656



  return cxt.errCode;




11,853,599✔





3657



}










3658












3659



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




639,292,746✔





3660



                          SNodeList** pFuncs) {










3661



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




639,292,746✔





3662



    return TSDB_CODE_FAILED;




×







3663



  }










3664



  SNodeList* pList = NULL;




639,326,791✔





3665



  if (!*pFuncs) {




639,326,954✔





3666



    int32_t code = nodesMakeList(&pList);




597,528,913✔





3667



    if (TSDB_CODE_SUCCESS != code) {




597,521,005✔





3668



      return code;




×







3669



    }










3670



  }










3671



  SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS,




917,167,145✔





3672



                          .classifier = classifier,










3673



                          .tableAlias = tableAlias,










3674



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




639,317,878✔





3675



  if (NULL == cxt.pFuncs) {




639,317,878✔





3676



    return TSDB_CODE_OUT_OF_MEMORY;




×







3677



  }










3678



  *pFuncs = NULL;




639,317,878✔





3679



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




639,317,818✔





3680



  if (TSDB_CODE_SUCCESS == cxt.errCode) {




639,361,948✔





3681



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




639,366,132✔





3682



      *pFuncs = cxt.pFuncs;




236,113,238✔





3683



    } else {










3684



      nodesDestroyList(cxt.pFuncs);




403,253,490✔





3685



    }










3686



  } else {










3687



    nodesDestroyList(cxt.pFuncs);




×







3688



  }










3689












3690



  return cxt.errCode;




639,353,709✔





3691



}










3692












3693



typedef struct SCollectSpecialNodesCxt {










3694



  int32_t    errCode;










3695



  ENodeType  type;










3696



  SNodeList* pNodes;










3697



} SCollectSpecialNodesCxt;










3698












3699



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




×







3700



  SCollectSpecialNodesCxt* pCxt = (SCollectSpecialNodesCxt*)pContext;




×







3701



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




×







3702



    SNode* pNew = NULL;




×







3703



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




×







3704



    if (TSDB_CODE_SUCCESS == pCxt->errCode) {




×







3705



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




×







3706



    }










3707



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




×







3708



  }










3709



  return DEAL_RES_CONTINUE;




×







3710



}










3711












3712



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




×







3713



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




×







3714



    return TSDB_CODE_FAILED;




×







3715



  }










3716



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




×







3717



  if (!*ppNodes) {




×







3718



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




×







3719



  } else {










3720



    cxt.pNodes = *ppNodes;




×







3721



  }










3722



  if (NULL == cxt.pNodes) {




×







3723



    return cxt.errCode;




×







3724



  }










3725



  *ppNodes = NULL;




×







3726



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




×







3727



  if (TSDB_CODE_SUCCESS != cxt.errCode) {




×







3728



    nodesDestroyList(cxt.pNodes);




×







3729



    return cxt.errCode;




×







3730



  }










3731



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




×







3732



    *ppNodes = cxt.pNodes;




×







3733



  } else {










3734



    nodesDestroyList(cxt.pNodes);




×







3735



  }










3736












3737



  return TSDB_CODE_SUCCESS;




×







3738



}










3739












3740



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




3,982,735✔





3741



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




3,982,735✔





3742



    *(bool*)pContext = true;




3,977,473✔





3743



    return DEAL_RES_END;




3,977,473✔





3744



  }










3745



  return DEAL_RES_CONTINUE;




5,262✔





3746



}










3747












3748



bool nodesExprHasColumn(SNode* pNode) {




3,982,735✔





3749



  bool hasCol = false;




3,982,735✔





3750



  nodesWalkExprPostOrder(pNode, hasColumn, &hasCol);




3,982,735✔





3751



  return hasCol;




3,982,735✔





3752



}










3753












3754



bool nodesExprsHasColumn(SNodeList* pList) {




×







3755



  bool hasCol = false;




×







3756



  nodesWalkExprsPostOrder(pList, hasColumn, &hasCol);




×







3757



  return hasCol;




×







3758



}










3759












3760



char* nodesGetFillModeString(EFillMode mode) {




181,504✔





3761



  switch (mode) {




181,504✔





3762



    case FILL_MODE_NONE:




×







3763



      return "none";




×







3764



    case FILL_MODE_VALUE:




25,184✔





3765



      return "value";




25,184✔





3766



    case FILL_MODE_VALUE_F:




16,056✔





3767



      return "value_f";




16,056✔





3768



    case FILL_MODE_PREV:




41,739✔





3769



      return "prev";




41,739✔





3770



    case FILL_MODE_NULL:




21,446✔





3771



      return "null";




21,446✔





3772



    case FILL_MODE_NULL_F:




×







3773



      return "null_f";




×







3774



    case FILL_MODE_LINEAR:




44,434✔





3775



      return "linear";




44,434✔





3776



    case FILL_MODE_NEXT:




32,645✔





3777



      return "next";




32,645✔





3778



    default:




×







3779



      return "unknown";




×







3780



  }










3781



}










3782












3783



char* nodesGetNameFromColumnNode(SNode* pNode) {




26,483,076✔





3784



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




26,483,076✔





3785



    return "NULL";




×







3786



  }










3787












3788



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




26,484,293✔





3789



}










3790












3791



int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots) {




191,357,977✔





3792



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




191,357,977✔





3793



    return 0;




716,145✔





3794



  }










3795












3796



  SNode*  pNode = NULL;




190,641,832✔





3797



  int32_t num = 0;




190,641,832✔





3798



  FOREACH(pNode, pSlots) {




520,047,990✔





3799



    if (QUERY_NODE_SLOT_DESC != pNode->type) {




329,406,158✔





3800



      continue;




×







3801



    }










3802












3803



    SSlotDescNode* descNode = (SSlotDescNode*)pNode;




329,406,158✔





3804



    if (descNode->output) {




329,406,158✔





3805



      ++num;




316,017,072✔





3806



    }










3807



  }










3808












3809



  return num;




190,641,832✔





3810



}










3811












3812



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




139,819,908✔





3813



  int32_t code = 0;




139,819,908✔





3814



  if (pNode->isNull) {




139,819,908✔





3815



    pVal->nType = TSDB_DATA_TYPE_NULL;




1,638,820✔





3816



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




1,638,820✔





3817



    return code;




1,639,379✔





3818



  }










3819



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




138,188,981✔





3820



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




138,173,550✔





3821



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




138,153,322✔





3822



    case TSDB_DATA_TYPE_NULL:




×







3823



      break;




×







3824



    case TSDB_DATA_TYPE_BOOL:




60,004✔





3825



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




60,004✔





3826



      break;




34,215✔





3827



    case TSDB_DATA_TYPE_TINYINT:




116,078,632✔





3828



    case TSDB_DATA_TYPE_SMALLINT:










3829



    case TSDB_DATA_TYPE_INT:










3830



    case TSDB_DATA_TYPE_BIGINT:










3831



    case TSDB_DATA_TYPE_TIMESTAMP:










3832



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




116,078,632✔





3833



      break;




116,102,897✔





3834



    case TSDB_DATA_TYPE_UTINYINT:




15,216✔





3835



    case TSDB_DATA_TYPE_USMALLINT:










3836



    case TSDB_DATA_TYPE_UINT:










3837



    case TSDB_DATA_TYPE_UBIGINT:










3838



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




15,216✔





3839



      break;




15,216✔





3840



    case TSDB_DATA_TYPE_FLOAT:




26,949✔





3841



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




26,949✔





3842



      break;




26,949✔





3843



    case TSDB_DATA_TYPE_DOUBLE:




3,241,643✔





3844



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




3,241,643✔





3845



      break;




3,239,357✔





3846



    case TSDB_DATA_TYPE_NCHAR:




18,750,740✔





3847



    case TSDB_DATA_TYPE_VARCHAR:










3848



    case TSDB_DATA_TYPE_VARBINARY:










3849



    case TSDB_DATA_TYPE_GEOMETRY:










3850



      pVal->nLen += VARSTR_HEADER_SIZE;




18,750,740✔





3851



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




18,754,503✔





3852



      if (pVal->pz) {




18,742,394✔





3853



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




18,741,428✔





3854



      } else {










3855



        code = terrno;




×







3856



      }










3857



      break;




18,752,027✔





3858



    case TSDB_DATA_TYPE_JSON:




1,485✔





3859



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




1,485✔





3860



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




1,485✔





3861



      if (pVal->pz) {




1,485✔





3862



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




1,485✔





3863



      } else {










3864



        code = terrno;




×







3865



      }










3866



      break;




1,485✔





3867



    case TSDB_DATA_TYPE_DECIMAL64:




×







3868



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




×







3869



      break;




×







3870



    case TSDB_DATA_TYPE_DECIMAL:




2,241✔





3871



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




2,241✔





3872



      if (!pVal->pz) {




2,241✔





3873



        code = terrno;




×







3874



        break;




×







3875



      }










3876



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




2,241✔





3877



      break;




2,241✔





3878



    case TSDB_DATA_TYPE_BLOB:




×







3879



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




×







3880



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




×







3881



      if (pVal->pz) {




×







3882



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




×







3883



      } else {










3884



        code = terrno;




×







3885



      }










3886



      break;




×







3887



    default:




×







3888



      break;




×







3889



  }










3890



  return code;




138,172,849✔





3891



}










3892












3893



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




422,519,778✔





3894



  if (NULL == *pSrc) {




422,519,778✔





3895



    return TSDB_CODE_SUCCESS;




321,289,473✔





3896



  }










3897












3898



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




101,230,762✔





3899



    *pDst = nodesListGetNode(*pSrc, 0);




32,569,084✔





3900



    nodesClearList(*pSrc);




32,568,768✔





3901



  } else {










3902



    SLogicConditionNode* pLogicCond = NULL;




68,663,103✔





3903



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




68,662,619✔





3904



    if (TSDB_CODE_SUCCESS != code) {




68,665,657✔





3905



      return code;




×







3906



    }










3907



    pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;




68,665,657✔





3908



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




68,665,148✔





3909



    pLogicCond->condType = LOGIC_COND_TYPE_AND;




68,665,657✔





3910



    pLogicCond->pParameterList = *pSrc;




68,665,620✔





3911



    *pDst = (SNode*)pLogicCond;




68,665,148✔





3912



  }










3913



  *pSrc = NULL;




101,233,734✔





3914












3915



  return TSDB_CODE_SUCCESS;




101,233,697✔





3916



}










3917












3918



const char* dataOrderStr(EDataOrderLevel order) {




×







3919



  switch (order) {




×







3920



    case DATA_ORDER_LEVEL_NONE:




×







3921



      return "no order required";




×







3922



    case DATA_ORDER_LEVEL_IN_BLOCK:




×







3923



      return "in-datablock order";




×







3924



    case DATA_ORDER_LEVEL_IN_GROUP:




×







3925



      return "in-group order";




×







3926



    case DATA_ORDER_LEVEL_GLOBAL:




×







3927



      return "global order";




×







3928



    default:




×







3929



      break;




×







3930



  }










3931



  return "unknown";




×







3932



}










3933












3934



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




3,496✔





3935



  int32_t     lenStr = strlen(literal);




3,496✔





3936



  SValueNode* pValNode = NULL;




3,496✔





3937



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




3,496✔





3938



  if (pValNode) {




3,496✔





3939



    pValNode->node.resType.type = TSDB_DATA_TYPE_BIGINT;




3,496✔





3940



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




3,496✔





3941



    pValNode->node.resType.precision = TSDB_TIME_PRECISION_MILLI;




3,496✔





3942



    pValNode->literal = tstrdup(literal);




3,496✔





3943



    pValNode->flag |= VALUE_FLAG_IS_DURATION;




3,496✔





3944



    pValNode->translate = false;




3,496✔





3945



    pValNode->isNull = false;




3,496✔





3946



    *ppValNode = pValNode;




3,496✔





3947



  }










3948



  return code;




3,496✔





3949



}










3950












3951



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




1,047,561✔





3952



  int32_t     lenStr = strlen(literal);




1,047,561✔





3953



  SValueNode* pValNode = NULL;




1,047,561✔





3954



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




1,047,561✔





3955



  if (pValNode) {




1,047,561✔





3956



    pValNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR;




1,047,561✔





3957



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




1,047,561✔





3958



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




1,047,561✔





3959



    if (p == NULL) {




1,047,561✔





3960



      return terrno;




×







3961



    }










3962



    varDataSetLen(p, lenStr);




1,047,561✔





3963



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




1,047,561✔





3964



    pValNode->datum.p = p;




1,047,561✔





3965



    pValNode->literal = tstrdup(literal);




1,047,561✔





3966



    pValNode->translate = true;




1,047,561✔





3967



    pValNode->isNull = false;




1,047,561✔





3968



    *ppValNode = pValNode;




1,047,561✔





3969



  }










3970



  return code;




1,047,561✔





3971



}










3972












3973



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




315,366✔





3974



  SValueNode* pValNode = NULL;




315,366✔





3975



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




315,366✔





3976



  if (TSDB_CODE_SUCCESS == code) {




315,366✔





3977



    pValNode->node.resType.type = TSDB_DATA_TYPE_BOOL;




315,366✔





3978



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




315,366✔





3979



    code = nodesSetValueNodeValue(pValNode, &b);




315,366✔





3980



    if (TSDB_CODE_SUCCESS == code) {




315,366✔





3981



      pValNode->translate = true;




315,366✔





3982



      pValNode->isNull = false;




315,366✔





3983



      *ppValNode = pValNode;




315,366✔





3984



    } else {










3985



      nodesDestroyNode((SNode*)pValNode);




×







3986



    }










3987



  }










3988



  return code;




315,366✔





3989



}










3990












3991



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




20,851,677✔





3992



  SValueNode* pValNode = NULL;




20,851,677✔





3993



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




20,851,677✔





3994



  if (TSDB_CODE_SUCCESS == code) {




20,851,853✔





3995



    pValNode->node.resType.type = TSDB_DATA_TYPE_INT;




20,851,853✔





3996



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




20,851,853✔





3997



    code = nodesSetValueNodeValue(pValNode, &value);




20,851,853✔





3998



    if (TSDB_CODE_SUCCESS == code) {




20,851,677✔





3999



      pValNode->translate = true;




20,851,677✔





4000



      pValNode->isNull = false;




20,851,677✔





4001



      *ppNode = (SNode*)pValNode;




20,851,677✔





4002



    } else {










4003



      nodesDestroyNode((SNode*)pValNode);




×







4004



    }










4005



  }










4006



  return code;




20,851,769✔





4007



}










4008












4009



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




3,548,570✔





4010



  SValueNode* pValNode = NULL;




3,548,570✔





4011



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




3,548,570✔





4012



  if (TSDB_CODE_SUCCESS == code) {




3,548,570✔





4013



    pValNode->node.resType.type = TSDB_DATA_TYPE_BIGINT;




3,548,570✔





4014



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




3,548,570✔





4015



    code = nodesSetValueNodeValue(pValNode, &value);




3,548,570✔





4016



    if (TSDB_CODE_SUCCESS == code) {




3,548,570✔





4017



      pValNode->translate = true;




3,548,570✔





4018



      pValNode->isNull = false;




3,548,570✔





4019



      *ppNode = (SNode*)pValNode;




3,548,570✔





4020



    } else {










4021



      nodesDestroyNode((SNode*)pValNode);




×







4022



    }










4023



  }










4024



  return code;




3,548,570✔





4025



}










4026












4027



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




916,261✔





4028



  SValueNode* pValNode = NULL;




916,261✔





4029



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




916,261✔





4030



  if (TSDB_CODE_SUCCESS == code) {




916,261✔





4031



    pValNode->node.resType.type = TSDB_DATA_TYPE_TIMESTAMP;




916,261✔





4032



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




916,261✔





4033



    code = nodesSetValueNodeValue(pValNode, &value);




916,261✔





4034



    if (TSDB_CODE_SUCCESS == code) {




916,261✔





4035



      pValNode->translate = true;




916,261✔





4036



      pValNode->isNull = false;




916,261✔





4037



      *ppNode = (SNode*)pValNode;




916,261✔





4038



    } else {










4039



      nodesDestroyNode((SNode*)pValNode);




×







4040



    }










4041



  }










4042



  return code;




916,261✔





4043



}










4044












4045



bool nodesIsStar(SNode* pNode) {




895,185,334✔





4046



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




952,771,390✔





4047



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




57,586,039✔





4048



}










4049












4050



bool nodesIsTableStar(SNode* pNode) {




829,808,357✔





4051



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




1,186,852,576✔





4052



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




357,044,275✔





4053



}










4054












4055



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




27,773✔





4056



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




27,773✔





4057












4058



  uint32_t   inSize = 1;




25,490✔





4059



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




25,490✔





4060



  while (1) {




37,418✔





4061



    SListCell* p = pHead;




62,908✔





4062



    pHead = NULL;




62,908✔





4063



    SListCell* pTail = NULL;




62,908✔





4064












4065



    uint32_t nMerges = 0;




62,908✔





4066



    while (p) {




185,689✔





4067



      ++nMerges;




122,781✔





4068



      SListCell* q = p;




122,781✔





4069



      uint32_t   pSize = 0;




122,781✔





4070



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




309,655✔





4071



        ++pSize;




209,318✔





4072



        q = q->pNext;




209,318✔





4073



        if (!q) {




209,318✔





4074



          break;




22,444✔





4075



        }










4076



      }










4077












4078



      uint32_t qSize = inSize;




122,781✔





4079












4080



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




470,111✔





4081



        SListCell* pCell;










4082



        if (pSize == 0) {




347,330✔





4083



          pCell = q;




127,610✔





4084



          q = q->pNext;




127,610✔





4085



          --qSize;




127,610✔





4086



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




219,720✔





4087



          pCell = p;




37,808✔





4088



          p = p->pNext;




37,808✔





4089



          --pSize;




37,808✔





4090



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




181,912✔





4091



          pCell = p;




171,510✔





4092



          p = p->pNext;




171,510✔





4093



          --pSize;




171,510✔





4094



        } else {










4095



          pCell = q;




10,402✔





4096



          q = q->pNext;




10,402✔





4097



          --qSize;




10,402✔





4098



        }










4099












4100



        if (pTail) {




347,330✔





4101



          pTail->pNext = pCell;




284,422✔





4102



          pCell->pPrev = pTail;




284,422✔





4103



        } else {










4104



          pHead = pCell;




62,908✔





4105



          pHead->pPrev = NULL;




62,908✔





4106



        }










4107



        pTail = pCell;




347,330✔





4108



      }










4109



      p = q;




122,781✔





4110



    }










4111



    pTail->pNext = NULL;




62,908✔





4112












4113



    if (nMerges <= 1) {




62,908✔





4114



      (*pList)->pHead = pHead;




25,490✔





4115



      (*pList)->pTail = pTail;




25,490✔





4116



      return;




25,490✔





4117



    }










4118



    inSize *= 2;




37,418✔





4119



  }










4120



}










4121












4122



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




238,757✔





4123



  SNode* pFound = NULL;




238,757✔





4124



  FOREACH(pFound, pList) {




529,565✔





4125



    if (nodesEqualNode(pFound, pNode)) {




303,180✔





4126



      break;




12,372✔





4127



    }










4128



  }










4129



  return pFound;




238,757✔





4130



}










4131












4132



int32_t nodesListDeduplicate(SNodeList** ppList) {




33,157,798✔





4133



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




33,157,798✔





4134



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




3,477,526✔





4135



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




3,409,719✔





4136



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




3,409,883✔





4137



    if (nodesEqualNode(pNode1, pNode2)) {




3,409,693✔






UNCOV

4138



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




×








UNCOV

4139



      (void)nodesListErase(*ppList, pCell);




×







4140



    }










4141



    return TSDB_CODE_SUCCESS;




3,409,199✔





4142



  }










4143



  SNodeList* pTmp = NULL;




67,817✔





4144



  int32_t    code = nodesMakeList(&pTmp);




67,817✔





4145



  if (TSDB_CODE_SUCCESS == code) {




67,751✔





4146



    SNode* pNode = NULL;




67,751✔





4147



    FOREACH(pNode, *ppList) {




306,508✔





4148



      SNode* pFound = nodesListFindNode(pTmp, pNode);




238,757✔





4149



      if (NULL == pFound) {




238,757✔





4150



        code = nodesCloneNode(pNode, &pFound);




226,385✔





4151



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




226,385✔





4152



        if (TSDB_CODE_SUCCESS != code) break;




226,385✔





4153



      }










4154



    }










4155



  }










4156



  if (TSDB_CODE_SUCCESS == code) {




67,751✔





4157



    nodesDestroyList(*ppList);




67,751✔





4158



    *ppList = pTmp;




67,751✔





4159



  } else {










4160



    nodesDestroyList(pTmp);




×







4161



  }










4162



  return code;




67,751✔





4163



}










4164












4165



void rewriteExprAliasName(SExprNode* pNode, int64_t num) {




1,135,683,948✔





4166



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




1,135,683,948✔





4167



  return;




1,135,709,811✔





4168



}










4169












4170



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




527,033,326✔





4171












4172



typedef struct SContainsColCxt {










4173



  bool containsCol;










4174



} SContainsColCxt;










4175












4176



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




18,781,962✔





4177



  SContainsColCxt* pCxt = pContext;




18,781,962✔





4178



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




18,781,962✔





4179



    pCxt->containsCol = true;




18,739,839✔





4180



    return DEAL_RES_END;




18,739,839✔





4181



  }










4182












4183



  return DEAL_RES_CONTINUE;




42,123✔





4184



}










4185












4186



bool nodesContainsColumn(SNode* pNode) {




18,764,482✔





4187



  if (NULL == pNode) {




18,764,482✔





4188



    return false;




×







4189



  }










4190












4191



  SContainsColCxt cxt = {0};




18,764,482✔





4192



  nodesWalkExpr(pNode, nodeContainsCol, &cxt);




18,764,482✔





4193












4194



  return cxt.containsCol;




18,764,482✔





4195



}










4196












4197



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




11,172,431✔





4198



  SLogicConditionNode* pLogicCond = NULL;




11,172,431✔





4199



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




11,172,431✔





4200



  if (NULL == pLogicCond) {




11,172,431✔





4201



    return code;




×







4202



  }










4203



  pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;




11,172,431✔





4204



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




11,172,431✔





4205



  pLogicCond->condType = LOGIC_COND_TYPE_AND;




11,172,431✔





4206



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




11,172,431✔





4207



  if (TSDB_CODE_SUCCESS == code) {




11,172,431✔





4208



    *pSrc = NULL;




11,172,431✔





4209



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




11,172,431✔





4210



  }










4211



  if (TSDB_CODE_SUCCESS == code) {




11,172,431✔





4212



    *pDst = (SNode*)pLogicCond;




11,172,431✔





4213



  } else {










4214



    nodesDestroyNode((SNode*)pLogicCond);




×







4215



  }










4216



  return code;




11,172,431✔





4217



}










4218












4219



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




58,441,519✔





4220



  if (NULL == *pCond) {




58,441,519✔





4221



    TSWAP(*pCond, *pAdditionalCond);




45,473,946✔





4222



    return TSDB_CODE_SUCCESS;




45,473,946✔





4223



  }










4224












4225



  int32_t code = TSDB_CODE_SUCCESS;




12,967,573✔





4226



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




12,967,573✔





4227



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




1,797,954✔





4228



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




1,797,954✔





4229



    if (TSDB_CODE_SUCCESS == code) {




1,797,954✔





4230



      *pAdditionalCond = NULL;




1,797,954✔





4231



    }










4232



  } else {










4233



    code = mergeNodeToLogic(pCond, pAdditionalCond);




11,169,619✔





4234



  }










4235












4236



  return code;




12,970,385✔





4237



}










4238












4239



void tFreeStreamVtbColName(void* param) {




×







4240



  if (NULL == param) {




×







4241



    return;




×







4242



  }










4243












4244



  SColIdName* pColId = (SColIdName*)param;




×







4245












4246



  taosMemoryFreeClear(pColId->colName);




×







4247



}










4248












4249



void tFreeStreamVtbOtbInfo(void* param) {




×







4250



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




×







4251



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




×







4252



    return;




×







4253



  }










4254












4255



  taosArrayDestroyEx(*ppArray, tFreeStreamVtbColName);




×







4256



}










4257












4258



void tFreeStreamVtbVtbInfo(void* param) {




×







4259



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




×







4260



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




×







4261



    return;




×







4262



  }










4263












4264



  tSimpleHashCleanup(*ppHash);




×







4265



}










4266












4267



void tFreeStreamVtbDbVgInfo(void* param) {




×







4268



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




×







4269



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




×







4270



    return;




×







4271



  }










4272












4273



  tSimpleHashCleanup(*ppHash);




×







4274



}










4275












4276












4277



bool nodesIsScalarSubQuery(SNode* pNode) {




×







4278



  switch (nodeType(pNode)) {




×







4279



    case QUERY_NODE_SELECT_STMT: {




×







4280



      SSelectStmt* pSelect = (SSelectStmt*)pNode;




×







4281



      return pSelect->subQType == E_SUB_QUERY_SCALAR;




×







4282



    }










4283



    case QUERY_NODE_SET_OPERATOR: {




×







4284



      SSetOperator* pSet = (SSetOperator*)pNode;




×







4285



      return pSet->subQType == E_SUB_QUERY_SCALAR;




×







4286



    }










4287



    default:




×







4288



      break;




×







4289



  }










4290












4291



  return false;




×







4292



}










4293












4294



char* nodesGetSubSql(SNode* pNode) {




164,916,501✔





4295



  switch (nodeType(pNode)) {




164,916,501✔





4296



    case QUERY_NODE_SELECT_STMT: {




149,294,756✔





4297



      SSelectStmt* pSelect = (SSelectStmt*)pNode;




149,294,756✔





4298



      return pSelect->node.userAlias;




149,294,756✔





4299



    }










4300



    case QUERY_NODE_SET_OPERATOR: {




15,623,395✔





4301



      SSetOperator* pSet = (SSetOperator*)pNode;




15,623,395✔





4302



      return pSet->node.userAlias;




15,623,395✔





4303



    }










4304



    default:




32✔





4305



      break;




32✔





4306



  }










4307












4308



  return NULL;




32✔





4309



}










4310












4311



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




164,927,548✔





4312



  switch (nodeType(pNode)) {




164,927,548✔





4313



    case QUERY_NODE_SELECT_STMT: {




149,320,095✔





4314



      SSelectStmt* pSelect = (SSelectStmt*)pNode;




149,320,095✔





4315



      *pType = pSelect->subQType;




149,320,095✔





4316



      break;




149,320,095✔





4317



    }










4318



    case QUERY_NODE_SET_OPERATOR: {




15,622,720✔





4319



      SSetOperator* pSet = (SSetOperator*)pNode;




15,622,720✔





4320



      *pType = pSet->subQType;




15,622,720✔





4321



      break;




15,622,720✔





4322



    }










4323



    default:




×







4324



      *pType = E_SUB_QUERY_NOT_SET;




×







4325



      break;




×







4326



  }










4327












4328



  return;




164,927,548✔





4329



}










4330












4331



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




1,138,506,814✔





4332



  SColumnNode* pCol = NULL;




1,138,506,814✔





4333



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




1,138,507,394✔





4334



  if (NULL == pCol) {




1,138,537,242✔





4335



    return NULL;




×







4336



  }










4337



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




1,138,537,242✔





4338



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




1,138,535,644✔





4339



  if (NULL != pStmtName) {




1,138,534,532✔





4340



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




1,138,561,812✔





4341



  }










4342



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




1,138,536,500✔





4343



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




1,138,535,606✔





4344



  return pCol;




1,138,534,283✔





4345



}










4346












4347


























    

  • 

    •