taosdata / TDengine / #4917

coverage: 65.42% (+0.02%) from 65.402%
#4917

push

travis-ci

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

31 of 34 new or added lines in 2 files covered. (91.18%)

819 existing lines in 129 files now uncovered.

202679 of 309814 relevant lines covered (65.42%)

116724351.99 hits per line

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

93.62
/source/libs/nodes/src/nodesTraverseFuncs.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 "plannodes.h"










17



#include "querynodes.h"










18



#include "tmsg.h"










19












20



typedef enum ETraversalOrder {










21



  TRAVERSAL_PREORDER = 1,










22



  TRAVERSAL_INORDER,










23



  TRAVERSAL_POSTORDER,










24



} ETraversalOrder;










25












26



typedef EDealRes (*FNodeDispatcher)(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);










27












28



static EDealRes walkExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);










29



static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);










30



static EDealRes walkPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);










31



static EDealRes walkPhysiPlans(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);










32












33



static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext,




2,147,483,647✔





34



                         FNodeDispatcher dispatcher) {










35



  if (NULL == pNode) {




2,147,483,647✔





36



    return DEAL_RES_CONTINUE;




2,147,483,647✔





37



  }










38












39



  EDealRes res = DEAL_RES_CONTINUE;




2,147,483,647✔





40












41



  if (TRAVERSAL_PREORDER == order) {




2,147,483,647✔





42



    res = walker(pNode, pContext);




2,147,483,647✔





43



    if (DEAL_RES_CONTINUE != res) {




2,147,483,647✔





44



      return res;




2,147,483,647✔





45



    }










46



  }










47












48



  res = dispatcher(pNode, order, walker, pContext);




2,147,483,647✔





49












50



  if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {




2,147,483,647✔





51



    res = walker(pNode, pContext);




2,147,483,647✔





52



  }










53












54



  return res;




2,147,483,647✔





55



}










56












57



static EDealRes dispatchExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {




2,147,483,647✔





58



  EDealRes res = DEAL_RES_CONTINUE;




2,147,483,647✔





59












60



  switch (nodeType(pNode)) {




2,147,483,647✔





61



    case QUERY_NODE_COLUMN:




2,147,483,647✔





62



    case QUERY_NODE_VALUE:










63



    case QUERY_NODE_LIMIT:










64



      // these node types with no subnodes










65



      break;




2,147,483,647✔





66



    case QUERY_NODE_OPERATOR: {




2,147,483,647✔





67



      SOperatorNode* pOpNode = (SOperatorNode*)pNode;




2,147,483,647✔





68



      res = walkExpr(pOpNode->pLeft, order, walker, pContext);




2,147,483,647✔





69



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




2,147,483,647✔





70



        res = walkExpr(pOpNode->pRight, order, walker, pContext);




2,147,483,647✔





71



      }










72



      break;




2,147,483,647✔





73



    }










74



    case QUERY_NODE_LOGIC_CONDITION:




544,389,569✔





75



      res = walkExprs(((SLogicConditionNode*)pNode)->pParameterList, order, walker, pContext);




544,389,569✔





76



      break;




544,414,284✔





77



    case QUERY_NODE_FUNCTION:




2,147,483,647✔





78



      res = walkExprs(((SFunctionNode*)pNode)->pParameterList, order, walker, pContext);




2,147,483,647✔





79



      break;




2,147,483,647✔





80



    case QUERY_NODE_REAL_TABLE:




2,147,483,647✔





81



    case QUERY_NODE_TEMP_TABLE:










82



    case QUERY_NODE_VIRTUAL_TABLE:










83



      break;  // todo




2,147,483,647✔





84



    case QUERY_NODE_JOIN_TABLE: {




208,034,544✔





85



      SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;




208,034,544✔





86



      res = walkExpr(pJoinTableNode->pLeft, order, walker, pContext);




208,034,544✔





87



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




208,034,544✔





88



        res = walkExpr(pJoinTableNode->pRight, order, walker, pContext);




208,034,544✔





89



      }










90



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




208,034,544✔





91



        res = walkExpr(pJoinTableNode->pOnCond, order, walker, pContext);




208,034,544✔





92



      }










93



      break;




208,034,544✔





94



    }










95



    case QUERY_NODE_GROUPING_SET:




453,122,458✔





96



      res = walkExprs(((SGroupingSetNode*)pNode)->pParameterList, order, walker, pContext);




453,122,458✔





97



      break;




453,122,458✔





98



    case QUERY_NODE_ORDER_BY_EXPR:




889,612,876✔





99



      res = walkExpr(((SOrderByExprNode*)pNode)->pExpr, order, walker, pContext);




889,612,876✔





100



      break;




889,612,876✔





101



    case QUERY_NODE_STATE_WINDOW: {




17,739,132✔





102



      SStateWindowNode* pState = (SStateWindowNode*)pNode;




17,739,132✔





103



      res = walkExpr(pState->pExpr, order, walker, pContext);




17,739,132✔





104



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




17,739,132✔





105



        res = walkExpr(pState->pCol, order, walker, pContext);




17,739,132✔





106



      }










107



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




17,739,132✔





108



        res = walkExpr(pState->pTrueForLimit, order, walker, pContext);




17,739,132✔





109



      }










110



      break;




17,739,132✔





111



    }










112



    case QUERY_NODE_SESSION_WINDOW: {




34,692,063✔





113



      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;




34,692,063✔





114



      res = walkExpr((SNode*)pSession->pCol, order, walker, pContext);




34,692,063✔





115



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




34,692,063✔





116



        res = walkExpr((SNode*)pSession->pGap, order, walker, pContext);




34,692,063✔





117



      }










118



      break;




34,692,063✔





119



    }










120



    case QUERY_NODE_INTERVAL_WINDOW: {




134,664,562✔





121



      SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;




134,664,562✔





122



      res = walkExpr(pInterval->pInterval, order, walker, pContext);




134,664,562✔





123



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




134,664,562✔





124



        res = walkExpr(pInterval->pOffset, order, walker, pContext);




134,664,562✔





125



      }










126



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




134,664,562✔





127



        res = walkExpr(pInterval->pSliding, order, walker, pContext);




134,664,562✔





128



      }










129



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




134,664,562✔





130



        res = walkExpr(pInterval->pFill, order, walker, pContext);




134,664,562✔





131



      }










132



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




134,664,562✔





133



        res = walkExpr(pInterval->pCol, order, walker, pContext);




134,664,562✔





134



      }










135



      break;




134,664,562✔





136



    }










137



    case QUERY_NODE_NODE_LIST:




70,011,192✔





138



      res = walkExprs(((SNodeListNode*)pNode)->pNodeList, order, walker, pContext);




70,011,192✔





139



      break;




70,011,888✔





140



    case QUERY_NODE_FILL: {




23,029,580✔





141



      SFillNode* pFill = (SFillNode*)pNode;




23,029,580✔





142



      res = walkExpr(pFill->pValues, order, walker, pContext);




23,029,580✔





143



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




23,028,988✔





144



        res = walkExpr(pFill->pWStartTs, order, walker, pContext);




23,026,314✔





145



      }










146



      break;




23,030,239✔





147



    }










148



    case QUERY_NODE_RAW_EXPR:




×







149



      res = walkExpr(((SRawExprNode*)pNode)->pNode, order, walker, pContext);




×







150



      break;




×







151



    case QUERY_NODE_TARGET:




191,546✔





152



      res = walkExpr(((STargetNode*)pNode)->pExpr, order, walker, pContext);




191,546✔





153



      break;




191,546✔





154



    case QUERY_NODE_WHEN_THEN: {




108,863,458✔





155



      SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;




108,863,458✔





156



      res = walkExpr(pWhenThen->pWhen, order, walker, pContext);




108,863,458✔





157



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




108,863,458✔





158



        res = walkExpr(pWhenThen->pThen, order, walker, pContext);




108,400,867✔





159



      }










160



      break;




108,863,458✔





161



    }










162



    case QUERY_NODE_CASE_WHEN: {




107,733,251✔





163



      SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;




107,733,251✔





164



      res = walkExpr(pCaseWhen->pCase, order, walker, pContext);




107,733,251✔





165



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




107,733,251✔





166



        res = walkExpr(pCaseWhen->pElse, order, walker, pContext);




107,669,644✔





167



      }










168



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




107,733,251✔





169



        res = walkExprs(pCaseWhen->pWhenThenList, order, walker, pContext);




107,216,545✔





170



      }










171



      break;




107,733,251✔





172



    }










173



    case QUERY_NODE_EVENT_WINDOW: {




15,466,104✔





174



      SEventWindowNode* pEvent = (SEventWindowNode*)pNode;




15,466,104✔





175



      res = walkExpr(pEvent->pCol, order, walker, pContext);




15,466,104✔





176



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




15,466,104✔





177



        res = walkExpr(pEvent->pStartCond, order, walker, pContext);




15,466,104✔





178



      }










179



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




15,466,104✔





180



        res = walkExpr(pEvent->pEndCond, order, walker, pContext);




15,466,104✔





181



      }










182



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




15,466,104✔





183



        res = walkExpr(pEvent->pTrueForLimit, order, walker, pContext);




15,466,104✔





184



      }










185



      break;




15,466,104✔





186



    }










187



    case QUERY_NODE_PERIOD_WINDOW: {




18,656✔





188



      SPeriodWindowNode* pPeriod = (SPeriodWindowNode*)pNode;




18,656✔





189



      res = walkExpr(pPeriod->pOffset, order, walker, pContext);




18,656✔





190



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




18,656✔





191



        res = walkExpr(pPeriod->pPeroid, order, walker, pContext);




18,656✔





192



      }










193



      break;




18,656✔





194



    }










195



    case QUERY_NODE_COUNT_WINDOW: {




15,408,807✔





196



      SCountWindowNode* pCount = (SCountWindowNode*)pNode;




15,408,807✔





197



      res = walkExpr(pCount->pCol, order, walker, pContext);




15,408,807✔





198



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




15,408,807✔





199



        res = walkExprs(pCount->pColList, order, walker, pContext);




15,408,807✔





200



      }










201



      break;




15,408,807✔





202



    }










203



    case QUERY_NODE_ANOMALY_WINDOW: {




×







204



      SAnomalyWindowNode* pAnomaly = (SAnomalyWindowNode*)pNode;




×







205



      res = walkExpr(pAnomaly->pExpr, order, walker, pContext);




×







206



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




×







207



        res = walkExpr(pAnomaly->pCol, order, walker, pContext);




×







208



      }










209



      break;




×







210



    }










211



    case QUERY_NODE_STREAM_TRIGGER: {




238,366✔





212



      SStreamTriggerNode* pTrigger = (SStreamTriggerNode*)pNode;




238,366✔





213



      res = walkExpr(pTrigger->pTriggerWindow, order, walker, pContext);




238,366✔





214



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




238,366✔





215



        res = walkExprs(pTrigger->pPartitionList, order, walker, pContext);




238,366✔





216



      }










217



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




238,366✔





218



        res = walkExpr(pTrigger->pOptions, order, walker, pContext);




238,366✔





219



      }










220



      break;




238,366✔





221



    }










222



    case QUERY_NODE_STREAM_TRIGGER_OPTIONS: {




8,289✔





223



      SStreamTriggerOptions* pOptions = (SStreamTriggerOptions*)pNode;




8,289✔





224



      res = walkExpr(pOptions->pPreFilter, order, walker, pContext);




8,289✔





225



      break;




7,419✔





226



    }










227



    default:




911,706,858✔





228



      break;




911,706,858✔





229



  }










230












231



  return res;




2,147,483,647✔





232



}










233












234



static EDealRes walkExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {




2,147,483,647✔





235



  return walkNode(pNode, order, walker, pContext, dispatchExpr);




2,147,483,647✔





236



}










237












238



static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext) {




2,147,483,647✔





239



  SNode* node;










240



  FOREACH(node, pNodeList) {




2,147,483,647✔





241



    EDealRes res = walkExpr(node, order, walker, pContext);




2,147,483,647✔





242



    if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {




2,147,483,647✔





243



      return res;




279,457,536✔





244



    }










245



  }










246



  return DEAL_RES_CONTINUE;




2,147,483,647✔





247



}










248












249



void nodesWalkExpr(SNode* pNode, FNodeWalker walker, void* pContext) {




2,147,483,647✔





250



  EDealRes res;










251



  res = walkExpr(pNode, TRAVERSAL_PREORDER, walker, pContext);




2,147,483,647✔





252



}




2,147,483,647✔





253












254



void nodesWalkExprs(SNodeList* pNodeList, FNodeWalker walker, void* pContext) {




2,147,483,647✔





255



  EDealRes res;










256



  res = walkExprs(pNodeList, TRAVERSAL_PREORDER, walker, pContext);




2,147,483,647✔





257



}




2,147,483,647✔





258












259



void nodesWalkExprPostOrder(SNode* pNode, FNodeWalker walker, void* pContext) {




616,670,429✔





260



  EDealRes res;










261



  res = walkExpr(pNode, TRAVERSAL_POSTORDER, walker, pContext);




616,670,429✔





262



}




616,618,376✔





263












264



void nodesWalkExprsPostOrder(SNodeList* pList, FNodeWalker walker, void* pContext) {




159,568,066✔





265



  EDealRes res;










266



  res = walkExprs(pList, TRAVERSAL_POSTORDER, walker, pContext);




159,568,066✔





267



}




159,568,107✔





268












269



static void markOpLeftAndRightAsParam(SOperatorNode* pOp) {




1,558,437,798✔





270



  if (NULL != pOp->pLeft) {




1,558,437,798✔





271



    if (nodeType(pOp->pLeft) == QUERY_NODE_FUNCTION) {




1,558,429,495✔





272



      ((SFunctionNode*)pOp->pLeft)->node.asParam = true;




212,770,588✔





273



    }










274



    if (nodeType(pOp->pLeft) == QUERY_NODE_COLUMN) {




1,558,426,600✔





275



      ((SColumnNode*)pOp->pLeft)->node.asParam = true;




1,035,533,676✔





276



    }










277



    if (nodeType(pOp->pLeft) == QUERY_NODE_VALUE) {




1,558,365,559✔





278



      ((SValueNode*)pOp->pLeft)->node.asParam = true;




55,570,282✔





279



    }










280



  }










281



  if (NULL != pOp->pRight) {




1,558,422,221✔





282



    if (nodeType(pOp->pRight) == QUERY_NODE_FUNCTION) {




1,361,612,747✔





283



      ((SFunctionNode*)pOp->pRight)->node.asParam = true;




8,239,340✔





284



    }










285



    if (nodeType(pOp->pRight) == QUERY_NODE_COLUMN) {




1,361,571,025✔





286



      ((SColumnNode*)pOp->pRight)->node.asParam = true;




339,067,903✔





287



    }










288



    if (nodeType(pOp->pRight) == QUERY_NODE_VALUE) {




1,361,585,278✔





289



      ((SValueNode*)pOp->pRight)->node.asParam = true;




875,051,906✔





290



    }










291



  }










292



}




1,558,343,895✔





293












294



static void checkParamIsFunc(SFunctionNode* pFunc) {




2,052,661,529✔





295



  int32_t numOfParams = LIST_LENGTH(pFunc->pParameterList);




2,052,661,529✔





296



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




2,147,483,647✔





297



    SNode* pPara = nodesListGetNode(pFunc->pParameterList, i);




2,147,483,647✔





298



    if (numOfParams > 1 && nodeType(pPara) == QUERY_NODE_FUNCTION) {




2,147,483,647✔





299



      ((SFunctionNode*)pPara)->node.asParam = true;




258,382,455✔





300



    }










301



    if (nodeType(pPara) == QUERY_NODE_COLUMN) {




2,147,483,647✔





302



      ((SColumnNode*)pPara)->node.asParam = true;




1,447,139,480✔





303



    }










304



    if (nodeType(pPara) == QUERY_NODE_VALUE) {




2,147,483,647✔





305



      ((SValueNode*)pPara)->node.asParam = true;




553,191,993✔





306



    }










307



  }










308



}




2,052,662,937✔





309












310



static EDealRes rewriteExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext);










311












312



static EDealRes rewriteExpr(SNode** pRawNode, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {




2,147,483,647✔





313



  if (NULL == pRawNode || NULL == *pRawNode) {




2,147,483,647✔





314



    return DEAL_RES_CONTINUE;




2,111,843,452✔





315



  }










316












317



  EDealRes res = DEAL_RES_CONTINUE;




2,147,483,647✔





318












319



  if (TRAVERSAL_PREORDER == order) {




2,147,483,647✔





320



    res = rewriter(pRawNode, pContext);




2,147,483,647✔





321



    if (DEAL_RES_CONTINUE != res) {




2,147,483,647✔





322



      return res;




727,393,500✔





323



    }










324



  }










325












326



  SNode* pNode = *pRawNode;




2,147,483,647✔





327



  switch (nodeType(pNode)) {




2,147,483,647✔





328



    case QUERY_NODE_COLUMN:




2,147,483,647✔





329



    case QUERY_NODE_VALUE:










330



    case QUERY_NODE_LIMIT:










331



      // these node types with no subnodes










332



      break;




2,147,483,647✔





333



    case QUERY_NODE_OPERATOR: {




1,558,440,943✔





334



      SOperatorNode* pOpNode = (SOperatorNode*)pNode;




1,558,440,943✔





335



      markOpLeftAndRightAsParam(pOpNode);




1,558,440,943✔





336



      res = rewriteExpr(&(pOpNode->pLeft), order, rewriter, pContext);




1,558,370,160✔





337



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




1,558,259,756✔





338



        res = rewriteExpr(&(pOpNode->pRight), order, rewriter, pContext);




1,537,113,813✔





339



      }










340



      break;




1,558,257,173✔





341



    }










342



    case QUERY_NODE_LOGIC_CONDITION:




269,536,609✔





343



      res = rewriteExprs(((SLogicConditionNode*)pNode)->pParameterList, order, rewriter, pContext);




269,536,609✔





344



      break;




269,549,132✔





345



    case QUERY_NODE_FUNCTION: {




2,052,658,831✔





346



      SFunctionNode* pFunc = (SFunctionNode*)pNode;




2,052,658,831✔





347



      checkParamIsFunc(pFunc);




2,052,658,831✔





348



      res = rewriteExprs(pFunc->pParameterList, order, rewriter, pContext);




2,052,665,502✔





349



      break;




2,052,660,618✔





350



    }










351



    case QUERY_NODE_REAL_TABLE:




277,522,682✔





352



    case QUERY_NODE_TEMP_TABLE:










353



    case QUERY_NODE_VIRTUAL_TABLE:










354



      break;  // todo




277,522,682✔





355



    case QUERY_NODE_JOIN_TABLE: {




36,116,535✔





356



      SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;




36,116,535✔





357



      res = rewriteExpr(&(pJoinTableNode->pLeft), order, rewriter, pContext);




36,116,535✔





358



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




36,116,535✔





359



        res = rewriteExpr(&(pJoinTableNode->pRight), order, rewriter, pContext);




36,116,535✔





360



      }










361



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




36,116,535✔





362



        res = rewriteExpr(&(pJoinTableNode->pOnCond), order, rewriter, pContext);




36,116,535✔





363



      }










364



      break;




36,116,535✔





365



    }










366



    case QUERY_NODE_GROUPING_SET:




109,558,066✔





367



      res = rewriteExprs(((SGroupingSetNode*)pNode)->pParameterList, order, rewriter, pContext);




109,558,066✔





368



      break;




109,558,066✔





369



    case QUERY_NODE_ORDER_BY_EXPR:




609,012,915✔





370



      res = rewriteExpr(&(((SOrderByExprNode*)pNode)->pExpr), order, rewriter, pContext);




609,012,915✔





371



      break;




609,012,949✔





372



    case QUERY_NODE_STATE_WINDOW: {




8,177,666✔





373



      SStateWindowNode* pState = (SStateWindowNode*)pNode;




8,177,666✔





374



      res = rewriteExpr(&pState->pExpr, order, rewriter, pContext);




8,177,666✔





375



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




8,177,666✔





376



        res = rewriteExpr(&pState->pCol, order, rewriter, pContext);




8,177,666✔





377



      }










378



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




8,177,666✔





379



        res = rewriteExpr(&pState->pTrueForLimit, order, rewriter, pContext);




8,177,666✔





380



      }










381



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




8,177,666✔





382



        res = rewriteExpr(&pState->pExtend, order, rewriter, pContext);




8,177,666✔





383



      }










384



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




8,177,666✔





385



        res = rewriteExpr(&pState->pZeroth, order, rewriter, pContext);




8,177,666✔





386



      }










387



      break;




8,177,666✔





388



    }










389



    case QUERY_NODE_SESSION_WINDOW: {




14,699,644✔





390



      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;




14,699,644✔





391



      res = rewriteExpr((SNode**)&pSession->pCol, order, rewriter, pContext);




14,699,644✔





392



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




14,699,644✔





393



        res = rewriteExpr((SNode**)&pSession->pGap, order, rewriter, pContext);




14,695,252✔





394



      }










395



      break;




14,699,644✔





396



    }










397



    case QUERY_NODE_INTERVAL_WINDOW: {




51,772,217✔





398



      SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;




51,772,217✔





399



      res = rewriteExpr(&(pInterval->pInterval), order, rewriter, pContext);




51,772,217✔





400



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




51,772,217✔





401



        res = rewriteExpr(&(pInterval->pOffset), order, rewriter, pContext);




51,772,217✔





402



      }










403



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




51,772,217✔





404



        res = rewriteExpr(&(pInterval->pSliding), order, rewriter, pContext);




51,772,217✔





405



      }










406



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




51,772,217✔





407



        res = rewriteExpr(&(pInterval->pSOffset), order, rewriter, pContext);




51,772,217✔





408



      }










409



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




51,772,217✔





410



        res = rewriteExpr(&(pInterval->pFill), order, rewriter, pContext);




51,772,217✔





411



      }










412



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




51,772,217✔





413



        res = rewriteExpr(&(pInterval->pCol), order, rewriter, pContext);




51,768,851✔





414



      }










415



      break;




51,772,217✔





416



    }










417



    case QUERY_NODE_NODE_LIST:




27,068,111✔





418



      res = rewriteExprs(((SNodeListNode*)pNode)->pNodeList, order, rewriter, pContext);




27,068,111✔





419



      break;




27,067,196✔





420



    case QUERY_NODE_FILL: {




6,380,794✔





421



      SFillNode* pFill = (SFillNode*)pNode;




6,380,794✔





422



      res = rewriteExpr(&pFill->pValues, order, rewriter, pContext);




6,380,794✔





423



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




6,380,794✔





424



        res = rewriteExpr(&(pFill->pWStartTs), order, rewriter, pContext);




6,377,428✔





425



      }










426



      if (DEAL_RES_ERROR!= res && DEAL_RES_END!= res) {




6,380,794✔





427



        res = rewriteExpr(&(pFill->pTimeRange), order, rewriter, pContext);




6,377,428✔





428



      }










429



      break;




6,380,794✔





430



    }










431



    case QUERY_NODE_RAW_EXPR:




×







432



      res = rewriteExpr(&(((SRawExprNode*)pNode)->pNode), order, rewriter, pContext);




×







433



      break;




×







434



    case QUERY_NODE_TARGET:




×







435



      res = rewriteExpr(&(((STargetNode*)pNode)->pExpr), order, rewriter, pContext);




×







436



      break;




×







437



    case QUERY_NODE_WHEN_THEN: {




67,568,366✔





438



      SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;




67,568,366✔





439



      res = rewriteExpr(&pWhenThen->pWhen, order, rewriter, pContext);




67,568,366✔





440



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




67,568,366✔





441



        res = rewriteExpr(&pWhenThen->pThen, order, rewriter, pContext);




65,827,482✔





442



      }










443



      break;




67,568,366✔





444



    }










445



    case QUERY_NODE_CASE_WHEN: {




69,365,280✔





446



      SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;




69,365,280✔





447



      res = rewriteExpr(&pCaseWhen->pCase, order, rewriter, pContext);




69,365,280✔





448



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




69,365,280✔





449



        res = rewriteExpr(&pCaseWhen->pElse, order, rewriter, pContext);




68,495,576✔





450



      }










451



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




69,365,280✔





452



        res = rewriteExprs(pCaseWhen->pWhenThenList, order, rewriter, pContext);




66,756,168✔





453



      }










454



      break;




69,365,280✔





455



    }










456



    case QUERY_NODE_EVENT_WINDOW: {




7,239,713✔





457



      SEventWindowNode* pEvent = (SEventWindowNode*)pNode;




7,239,713✔





458



      res = rewriteExpr(&pEvent->pCol, order, rewriter, pContext);




7,239,713✔





459



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




7,239,713✔





460



        res = rewriteExpr(&pEvent->pStartCond, order, rewriter, pContext);




7,239,713✔





461



      }










462



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




7,239,713✔





463



        res = rewriteExpr(&pEvent->pEndCond, order, rewriter, pContext);




7,238,213✔





464



      }










465



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




7,239,713✔





466



        res = rewriteExpr(&pEvent->pTrueForLimit, order, rewriter, pContext);




7,233,723✔





467



      }










468



      break;




7,239,713✔





469



    }










470



    case QUERY_NODE_WINDOW_OFFSET: {




483,554✔





471



      SWindowOffsetNode* pWin = (SWindowOffsetNode*)pNode;




483,554✔





472



      res = rewriteExpr(&pWin->pStartOffset, order, rewriter, pContext);




483,554✔





473



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




483,554✔





474



        res = rewriteExpr(&pWin->pEndOffset, order, rewriter, pContext);




483,554✔





475



      }










476



      break;




483,554✔





477



    }










478



    case QUERY_NODE_COUNT_WINDOW: {




7,219,538✔





479



      SCountWindowNode* pCount = (SCountWindowNode*)pNode;




7,219,538✔





480



      res = rewriteExpr(&pCount->pCol, order, rewriter, pContext);




7,219,538✔





481



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




7,219,538✔





482



        res = rewriteExprs(pCount->pColList, order, rewriter, pContext);




7,219,538✔





483



      }










484



      break;




7,219,538✔





485



    }










486



    case QUERY_NODE_ANOMALY_WINDOW: {




×







487



      SAnomalyWindowNode* pAnomaly = (SAnomalyWindowNode*)pNode;




×







488



      res = rewriteExpr(&pAnomaly->pExpr, order, rewriter, pContext);




×







489



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




×







490



        res = rewriteExpr(&pAnomaly->pCol, order, rewriter, pContext);




×







491



      }










492



      break;




×







493



    }










494



    case QUERY_NODE_PERIOD_WINDOW: {




13,547✔





495



      SPeriodWindowNode* pPeriod = (SPeriodWindowNode*)pNode;




13,547✔





496



      res = rewriteExpr(&pPeriod->pOffset, order, rewriter, pContext);




13,547✔





497



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




13,547✔





498



        res = rewriteExpr(&pPeriod->pPeroid, order, rewriter, pContext);




13,547✔





499



      }










500



      break;




13,547✔





501



    }










502



    case QUERY_NODE_STREAM_TAG_DEF: {




×







503



      SStreamTagDefNode* pTagDef = (SStreamTagDefNode*)pNode;




×







504



      res = rewriteExpr(&pTagDef->pTagExpr, order, rewriter, pContext);




×







505



      break;




×







506



    }










507



    case QUERY_NODE_TIME_RANGE: {




94,915✔





508



      STimeRangeNode* pTimeRange = (STimeRangeNode*)pNode;




94,915✔





509



      res = rewriteExpr(&pTimeRange->pStart, order, rewriter, pContext);




94,915✔





510



      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {




94,915✔





511



        res = rewriteExpr(&pTimeRange->pEnd, order, rewriter, pContext);




94,915✔





512



      }










513



      break;




94,915✔





514



    }










515












516



    default:




549,789,273✔





517



      break;




549,789,273✔





518



  }










519












520



  if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {




2,147,483,647✔





521



    res = rewriter(pRawNode, pContext);




2,147,483,647✔





522



  }










523












524



  return res;




2,147,483,647✔





525



}










526












527



static EDealRes rewriteExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {




2,147,483,647✔





528



  SNode** pNode;










529



  FOREACH_FOR_REWRITE(pNode, pNodeList) {




2,147,483,647✔





530



    EDealRes res = rewriteExpr(pNode, order, rewriter, pContext);




2,147,483,647✔





531



    if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {




2,147,483,647✔





532



      return res;




66,227,433✔





533



    }










534



  }










535



  return DEAL_RES_CONTINUE;




2,147,483,647✔





536



}










537












538



void nodesRewriteExpr(SNode** pNode, FNodeRewriter rewriter, void* pContext) {




1,930,002,724✔





539



  (void)rewriteExpr(pNode, TRAVERSAL_PREORDER, rewriter, pContext);




1,930,002,724✔





540



}




1,929,998,184✔





541












542



void nodesRewriteExprs(SNodeList* pList, FNodeRewriter rewriter, void* pContext) {




2,147,483,647✔





543



  (void)rewriteExprs(pList, TRAVERSAL_PREORDER, rewriter, pContext);




2,147,483,647✔





544



}




2,147,483,647✔





545












546



void nodesRewriteExprPostOrder(SNode** pNode, FNodeRewriter rewriter, void* pContext) {




2,147,483,647✔





547



  (void)rewriteExpr(pNode, TRAVERSAL_POSTORDER, rewriter, pContext);




2,147,483,647✔





548



}




2,147,483,647✔





549












550



void nodesRewriteExprsPostOrder(SNodeList* pList, FNodeRewriter rewriter, void* pContext) {




615,564,116✔





551



  (void)rewriteExprs(pList, TRAVERSAL_POSTORDER, rewriter, pContext);




615,564,116✔





552



}




615,564,071✔





553












554



void nodesWalkSelectStmtImpl(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext) {




2,147,483,647✔





555



  if (NULL == pSelect) {




2,147,483,647✔





556



    return;




×







557



  }










558












559



  switch (clause) {




2,147,483,647✔





560



    case SQL_CLAUSE_FROM:




2,032,944,384✔





561



      nodesWalkExpr(pSelect->pFromTable, walker, pContext);




2,032,944,384✔





562



      nodesWalkExpr(pSelect->pWhere, walker, pContext);




2,032,954,446✔





563



    case SQL_CLAUSE_WHERE:




2,051,053,130✔





564



      nodesWalkExprs(pSelect->pPartitionByList, walker, pContext);




2,051,053,130✔





565



    case SQL_CLAUSE_PARTITION_BY:




2,132,548,426✔





566



      nodesWalkExpr(pSelect->pWindow, walker, pContext);




2,132,548,426✔





567



      nodesWalkExpr(pSelect->pFill, walker, pContext);




2,132,549,344✔





568



    case SQL_CLAUSE_WINDOW:




2,147,483,647✔





569



      if (NULL != pSelect->pWindow) {




2,147,483,647✔





570



        if (QUERY_NODE_INTERVAL_WINDOW == nodeType(pSelect->pWindow)) {




239,643,331✔





571



          nodesWalkExpr(((SIntervalWindowNode*)pSelect->pWindow)->pFill, walker, pContext);




146,700,421✔





572



        }










573



        else if (QUERY_NODE_COUNT_WINDOW == nodeType(pSelect->pWindow)) {




92,942,910✔





574



          nodesWalkExprs(((SCountWindowNode*)pSelect->pWindow)->pColList, walker, pContext);




17,431,466✔





575



        }










576



      }










577



    case SQL_CLAUSE_FILL:










578



      nodesWalkExprs(pSelect->pGroupByList, walker, pContext);




2,147,483,647✔





579



    case SQL_CLAUSE_GROUP_BY:




2,147,483,647✔





580



      nodesWalkExpr(pSelect->pHaving, walker, pContext);




2,147,483,647✔





581



    case SQL_CLAUSE_HAVING:




2,147,483,647✔





582



    case SQL_CLAUSE_SELECT:










583



    case SQL_CLAUSE_DISTINCT:










584



      nodesWalkExprs(pSelect->pOrderByList, walker, pContext);




2,147,483,647✔





585



    case SQL_CLAUSE_ORDER_BY:




2,147,483,647✔





586



      nodesWalkExprs(pSelect->pProjectionList, walker, pContext);




2,147,483,647✔





587



      nodesWalkExprs(pSelect->pProjectionBindList, walker, pContext);




2,147,483,647✔





588



    default:




2,147,483,647✔





589



      break;




2,147,483,647✔





590



  }










591












592



  return;




2,147,483,647✔





593



}










594












595



void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext) {




2,147,483,647✔





596



  nodesWalkSelectStmtImpl(pSelect, clause, walker, pContext);




2,147,483,647✔





597



}




2,147,483,647✔





598












599



void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewriter rewriter, void* pContext) {




418,370,957✔





600



  if (NULL == pSelect) {




418,370,957✔






UNCOV

601



    return;




×







602



  }










603












604



  switch (clause) {




418,370,957✔





605



    case SQL_CLAUSE_FROM:




241,407,376✔





606



      nodesRewriteExpr(&(pSelect->pFromTable), rewriter, pContext);




241,407,376✔





607



      nodesRewriteExpr(&(pSelect->pWhere), rewriter, pContext);




241,406,866✔





608



    case SQL_CLAUSE_WHERE:




241,407,418✔





609



      nodesRewriteExprs(pSelect->pPartitionByList, rewriter, pContext);




241,407,418✔





610



    case SQL_CLAUSE_PARTITION_BY:




241,406,975✔





611



      nodesRewriteExpr(&(pSelect->pWindow), rewriter, pContext);




241,406,975✔





612



    case SQL_CLAUSE_WINDOW:




265,913,362✔





613



      if (NULL != pSelect->pWindow) {




265,913,362✔





614



        if (QUERY_NODE_INTERVAL_WINDOW == nodeType(pSelect->pWindow)) {




47,090,116✔





615



          nodesRewriteExpr(&(((SIntervalWindowNode*)pSelect->pWindow)->pFill), rewriter, pContext);




24,649,444✔





616



        } else if (QUERY_NODE_COUNT_WINDOW == nodeType(pSelect->pWindow)) {




22,440,672✔





617



          nodesRewriteExprs(((SCountWindowNode*)pSelect->pWindow)->pColList, rewriter, pContext);




4,226,172✔





618



        }










619



      }










620



    case SQL_CLAUSE_FILL:










621



      nodesRewriteExprs(pSelect->pGroupByList, rewriter, pContext);




266,650,648✔





622



    case SQL_CLAUSE_GROUP_BY:




404,574,751✔





623



      nodesRewriteExpr(&(pSelect->pHaving), rewriter, pContext);




404,574,751✔





624



    case SQL_CLAUSE_HAVING:




418,370,138✔





625



    case SQL_CLAUSE_SELECT:










626



    case SQL_CLAUSE_DISTINCT:










627



      nodesRewriteExprs(pSelect->pOrderByList, rewriter, pContext);




418,370,138✔





628



    case SQL_CLAUSE_ORDER_BY:




418,371,088✔





629



      nodesRewriteExprs(pSelect->pProjectionList, rewriter, pContext);




418,371,088✔





630



      nodesRewriteExprs(pSelect->pProjectionBindList, rewriter, pContext);




418,371,171✔





631



    default:




418,370,312✔





632



      break;




418,370,312✔





633



  }










634












635



  return;




418,370,312✔





636



}
























    

  • 

    •