#3362

Committed 16 Mar 2024 03:58PM UTC coverage: 54.112% (-0.07%) from 54.178%

Build # #3362

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #25111 from taosdata/fix/liaohj

fix(meta): fix repeatly reader lock for tsdb meta.

Run Details

77745 of 184347 branches covered (42.17%)

Branch coverage included in aggregate %.

23 of 34 new or added lines in 15 files covered. (67.65%)

1651 existing lines in 74 files now uncovered.

142496 of 222666 relevant lines covered (64.0%)

649375.39 hits per line

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

84.56

/source/libs/nodes/src/nodesTraverseFuncs.c

/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "plannodes.h"
#include "querynodes.h"

typedef enum ETraversalOrder {
  TRAVERSAL_PREORDER = 1,
  TRAVERSAL_INORDER,
  TRAVERSAL_POSTORDER,
} ETraversalOrder;

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

static EDealRes walkExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);
static EDealRes walkPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
static EDealRes walkPhysiPlans(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);

static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext,
                         FNodeDispatcher dispatcher) {
  if (NULL == pNode) {
    return DEAL_RES_CONTINUE;
  }

  EDealRes res = DEAL_RES_CONTINUE;

  if (TRAVERSAL_PREORDER == order) {
    res = walker(pNode, pContext);
    if (DEAL_RES_CONTINUE != res) {
      return res;
    }
  }

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

  if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {
    res = walker(pNode, pContext);
  }

  return res;
}

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

  switch (nodeType(pNode)) {
    case QUERY_NODE_COLUMN:
    case QUERY_NODE_VALUE:
    case QUERY_NODE_LIMIT:
      // these node types with no subnodes
      break;
    case QUERY_NODE_OPERATOR: {
      SOperatorNode* pOpNode = (SOperatorNode*)pNode;
      res = walkExpr(pOpNode->pLeft, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pOpNode->pRight, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_LOGIC_CONDITION:
      res = walkExprs(((SLogicConditionNode*)pNode)->pParameterList, order, walker, pContext);
      break;
    case QUERY_NODE_FUNCTION:
      res = walkExprs(((SFunctionNode*)pNode)->pParameterList, order, walker, pContext);
      break;
    case QUERY_NODE_REAL_TABLE:
    case QUERY_NODE_TEMP_TABLE:
      break;  // todo
    case QUERY_NODE_JOIN_TABLE: {
      SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
      res = walkExpr(pJoinTableNode->pLeft, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pJoinTableNode->pRight, order, walker, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pJoinTableNode->pOnCond, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_GROUPING_SET:
      res = walkExprs(((SGroupingSetNode*)pNode)->pParameterList, order, walker, pContext);
      break;
    case QUERY_NODE_ORDER_BY_EXPR:
      res = walkExpr(((SOrderByExprNode*)pNode)->pExpr, order, walker, pContext);
      break;
    case QUERY_NODE_STATE_WINDOW: {
      SStateWindowNode* pState = (SStateWindowNode*)pNode;
      res = walkExpr(pState->pExpr, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pState->pCol, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_SESSION_WINDOW: {
      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
      res = walkExpr((SNode*)pSession->pCol, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr((SNode*)pSession->pGap, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_INTERVAL_WINDOW: {
      SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;
      res = walkExpr(pInterval->pInterval, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pInterval->pOffset, order, walker, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pInterval->pSliding, order, walker, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pInterval->pFill, order, walker, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pInterval->pCol, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_NODE_LIST:
      res = walkExprs(((SNodeListNode*)pNode)->pNodeList, order, walker, pContext);
      break;
    case QUERY_NODE_FILL: {
      SFillNode* pFill = (SFillNode*)pNode;
      res = walkExpr(pFill->pValues, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pFill->pWStartTs, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_RAW_EXPR:
      res = walkExpr(((SRawExprNode*)pNode)->pNode, order, walker, pContext);
      break;
    case QUERY_NODE_TARGET:
      res = walkExpr(((STargetNode*)pNode)->pExpr, order, walker, pContext);
      break;
    case QUERY_NODE_WHEN_THEN: {
      SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;
      res = walkExpr(pWhenThen->pWhen, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pWhenThen->pThen, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_CASE_WHEN: {
      SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;
      res = walkExpr(pCaseWhen->pCase, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pCaseWhen->pElse, order, walker, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExprs(pCaseWhen->pWhenThenList, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_EVENT_WINDOW: {
      SEventWindowNode* pEvent = (SEventWindowNode*)pNode;
      res = walkExpr(pEvent->pCol, order, walker, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pEvent->pStartCond, order, walker, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = walkExpr(pEvent->pEndCond, order, walker, pContext);
      }
      break;
    }
    case QUERY_NODE_COUNT_WINDOW: {
      SCountWindowNode* pEvent = (SCountWindowNode*)pNode;
      res = walkExpr(pEvent->pCol, order, walker, pContext);
      break;
    }
    default:
      break;
  }

  return res;
}

static EDealRes walkExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {
  return walkNode(pNode, order, walker, pContext, dispatchExpr);
}

static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext) {
  SNode* node;
  FOREACH(node, pNodeList) {
    EDealRes res = walkExpr(node, order, walker, pContext);
    if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {
      return res;
    }
  }
  return DEAL_RES_CONTINUE;
}

void nodesWalkExpr(SNode* pNode, FNodeWalker walker, void* pContext) {
  (void)walkExpr(pNode, TRAVERSAL_PREORDER, walker, pContext);
}

void nodesWalkExprs(SNodeList* pNodeList, FNodeWalker walker, void* pContext) {
  (void)walkExprs(pNodeList, TRAVERSAL_PREORDER, walker, pContext);
}

void nodesWalkExprPostOrder(SNode* pNode, FNodeWalker walker, void* pContext) {
  (void)walkExpr(pNode, TRAVERSAL_POSTORDER, walker, pContext);
}

void nodesWalkExprsPostOrder(SNodeList* pList, FNodeWalker walker, void* pContext) {
  (void)walkExprs(pList, TRAVERSAL_POSTORDER, walker, pContext);
}

static void checkParamIsFunc(SFunctionNode* pFunc) {
  int32_t numOfParams = LIST_LENGTH(pFunc->pParameterList);
  for (int32_t i = 0; i < numOfParams; ++i) {
    SNode* pPara = nodesListGetNode(pFunc->pParameterList, i);
    if (numOfParams > 1 && nodeType(pPara) == QUERY_NODE_FUNCTION) {
      ((SFunctionNode*)pPara)->node.asParam = true;
    }
    if (nodeType(pPara) == QUERY_NODE_COLUMN) {
      ((SColumnNode*)pPara)->node.asParam = true;
    }
  }
}

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

static EDealRes rewriteExpr(SNode** pRawNode, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {
  if (NULL == pRawNode || NULL == *pRawNode) {
    return DEAL_RES_CONTINUE;
  }

  EDealRes res = DEAL_RES_CONTINUE;

  if (TRAVERSAL_PREORDER == order) {
    res = rewriter(pRawNode, pContext);
    if (DEAL_RES_CONTINUE != res) {
      return res;
    }
  }

  SNode* pNode = *pRawNode;
  switch (nodeType(pNode)) {
    case QUERY_NODE_COLUMN:
    case QUERY_NODE_VALUE:
    case QUERY_NODE_LIMIT:
      // these node types with no subnodes
      break;
    case QUERY_NODE_OPERATOR: {
      SOperatorNode* pOpNode = (SOperatorNode*)pNode;
      res = rewriteExpr(&(pOpNode->pLeft), order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&(pOpNode->pRight), order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_LOGIC_CONDITION:
      res = rewriteExprs(((SLogicConditionNode*)pNode)->pParameterList, order, rewriter, pContext);
      break;
    case QUERY_NODE_FUNCTION: {
      SFunctionNode* pFunc = (SFunctionNode*)pNode;
      checkParamIsFunc(pFunc);
      res = rewriteExprs(pFunc->pParameterList, order, rewriter, pContext);
      break;
    }
    case QUERY_NODE_REAL_TABLE:
    case QUERY_NODE_TEMP_TABLE:
      break;  // todo
    case QUERY_NODE_JOIN_TABLE: {
      SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
      res = rewriteExpr(&(pJoinTableNode->pLeft), order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&(pJoinTableNode->pRight), order, rewriter, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&(pJoinTableNode->pOnCond), order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_GROUPING_SET:
      res = rewriteExprs(((SGroupingSetNode*)pNode)->pParameterList, order, rewriter, pContext);
      break;
    case QUERY_NODE_ORDER_BY_EXPR:
      res = rewriteExpr(&(((SOrderByExprNode*)pNode)->pExpr), order, rewriter, pContext);
      break;
    case QUERY_NODE_STATE_WINDOW: {
      SStateWindowNode* pState = (SStateWindowNode*)pNode;
      res = rewriteExpr(&pState->pExpr, order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&pState->pCol, order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_SESSION_WINDOW: {
      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
      res = rewriteExpr((SNode**)&pSession->pCol, order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr((SNode**)&pSession->pGap, order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_INTERVAL_WINDOW: {
      SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;
      res = rewriteExpr(&(pInterval->pInterval), order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&(pInterval->pOffset), order, rewriter, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&(pInterval->pSliding), order, rewriter, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&(pInterval->pFill), order, rewriter, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&(pInterval->pCol), order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_NODE_LIST:
      res = rewriteExprs(((SNodeListNode*)pNode)->pNodeList, order, rewriter, pContext);
      break;
    case QUERY_NODE_FILL: {
      SFillNode* pFill = (SFillNode*)pNode;
      res = rewriteExpr(&pFill->pValues, order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&(pFill->pWStartTs), order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_RAW_EXPR:
      res = rewriteExpr(&(((SRawExprNode*)pNode)->pNode), order, rewriter, pContext);
      break;
    case QUERY_NODE_TARGET:
      res = rewriteExpr(&(((STargetNode*)pNode)->pExpr), order, rewriter, pContext);
      break;
    case QUERY_NODE_WHEN_THEN: {
      SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;
      res = rewriteExpr(&pWhenThen->pWhen, order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&pWhenThen->pThen, order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_CASE_WHEN: {
      SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;
      res = rewriteExpr(&pCaseWhen->pCase, order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&pCaseWhen->pElse, order, rewriter, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExprs(pCaseWhen->pWhenThenList, order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_EVENT_WINDOW: {
      SEventWindowNode* pEvent = (SEventWindowNode*)pNode;
      res = rewriteExpr(&pEvent->pCol, order, rewriter, pContext);
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&pEvent->pStartCond, order, rewriter, pContext);
      }
      if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {
        res = rewriteExpr(&pEvent->pEndCond, order, rewriter, pContext);
      }
      break;
    }
    case QUERY_NODE_COUNT_WINDOW: {
      SCountWindowNode* pEvent = (SCountWindowNode*)pNode;
      res = rewriteExpr(&pEvent->pCol, order, rewriter, pContext);
      break;
    }
    default:
      break;
  }

  if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {
    res = rewriter(pRawNode, pContext);
  }

  return res;
}

static EDealRes rewriteExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {
  SNode** pNode;
  FOREACH_FOR_REWRITE(pNode, pNodeList) {
    EDealRes res = rewriteExpr(pNode, order, rewriter, pContext);
    if (DEAL_RES_ERROR == res || DEAL_RES_END == res) {
      return res;
    }
  }
  return DEAL_RES_CONTINUE;
}

void nodesRewriteExpr(SNode** pNode, FNodeRewriter rewriter, void* pContext) {
  (void)rewriteExpr(pNode, TRAVERSAL_PREORDER, rewriter, pContext);
}

void nodesRewriteExprs(SNodeList* pList, FNodeRewriter rewriter, void* pContext) {
  (void)rewriteExprs(pList, TRAVERSAL_PREORDER, rewriter, pContext);
}

void nodesRewriteExprPostOrder(SNode** pNode, FNodeRewriter rewriter, void* pContext) {
  (void)rewriteExpr(pNode, TRAVERSAL_POSTORDER, rewriter, pContext);
}

void nodesRewriteExprsPostOrder(SNodeList* pList, FNodeRewriter rewriter, void* pContext) {
  (void)rewriteExprs(pList, TRAVERSAL_POSTORDER, rewriter, pContext);
}

void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext) {
  if (NULL == pSelect) {
    return;
  }

  switch (clause) {
    case SQL_CLAUSE_FROM:
      nodesWalkExpr(pSelect->pFromTable, walker, pContext);
      nodesWalkExpr(pSelect->pWhere, walker, pContext);
    case SQL_CLAUSE_WHERE:
      nodesWalkExprs(pSelect->pPartitionByList, walker, pContext);
      nodesWalkExprs(pSelect->pTags, walker, pContext);
      nodesWalkExpr(pSelect->pSubtable, walker, pContext);
    case SQL_CLAUSE_PARTITION_BY:
      nodesWalkExpr(pSelect->pWindow, walker, pContext);
    case SQL_CLAUSE_WINDOW:
      if (NULL != pSelect->pWindow && QUERY_NODE_INTERVAL_WINDOW == nodeType(pSelect->pWindow)) {
        nodesWalkExpr(((SIntervalWindowNode*)pSelect->pWindow)->pFill, walker, pContext);
      }
    case SQL_CLAUSE_FILL:
      nodesWalkExprs(pSelect->pGroupByList, walker, pContext);
    case SQL_CLAUSE_GROUP_BY:
      nodesWalkExpr(pSelect->pHaving, walker, pContext);
    case SQL_CLAUSE_HAVING:
    case SQL_CLAUSE_SELECT:
    case SQL_CLAUSE_DISTINCT:
      nodesWalkExprs(pSelect->pOrderByList, walker, pContext);
    case SQL_CLAUSE_ORDER_BY:
      nodesWalkExprs(pSelect->pProjectionList, walker, pContext);
    default:
      break;
  }

  return;
}

void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewriter rewriter, void* pContext) {
  if (NULL == pSelect) {
    return;
  }

  switch (clause) {
    case SQL_CLAUSE_FROM:
      nodesRewriteExpr(&(pSelect->pFromTable), rewriter, pContext);
      nodesRewriteExpr(&(pSelect->pWhere), rewriter, pContext);
    case SQL_CLAUSE_WHERE:
      nodesRewriteExprs(pSelect->pPartitionByList, rewriter, pContext);
      nodesRewriteExprs(pSelect->pTags, rewriter, pContext);
      nodesRewriteExpr(&(pSelect->pSubtable), rewriter, pContext);
    case SQL_CLAUSE_PARTITION_BY:
      nodesRewriteExpr(&(pSelect->pWindow), rewriter, pContext);
    case SQL_CLAUSE_WINDOW:
      if (NULL != pSelect->pWindow && QUERY_NODE_INTERVAL_WINDOW == nodeType(pSelect->pWindow)) {
        nodesRewriteExpr(&(((SIntervalWindowNode*)pSelect->pWindow)->pFill), rewriter, pContext);
      }
    case SQL_CLAUSE_FILL:
      nodesRewriteExprs(pSelect->pGroupByList, rewriter, pContext);
    case SQL_CLAUSE_GROUP_BY:
      nodesRewriteExpr(&(pSelect->pHaving), rewriter, pContext);
    case SQL_CLAUSE_HAVING:
    case SQL_CLAUSE_SELECT:
    case SQL_CLAUSE_DISTINCT:
      nodesRewriteExprs(pSelect->pOrderByList, rewriter, pContext);
    case SQL_CLAUSE_ORDER_BY:
      nodesRewriteExprs(pSelect->pProjectionList, rewriter, pContext);
    default:
      break;
  }

  return;
}

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
19	typedef enum ETraversalOrder {
20	TRAVERSAL_PREORDER = 1,
21	TRAVERSAL_INORDER,
22	TRAVERSAL_POSTORDER,
23	} ETraversalOrder;
24
25	typedef EDealRes (FNodeDispatcher)(SNode pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
26
27	static EDealRes walkExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
28	static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);
29	static EDealRes walkPhysiPlan(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext);
30	static EDealRes walkPhysiPlans(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext);
31
32	static EDealRes walkNode(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext,	36,843,100✔
33	FNodeDispatcher dispatcher) {
34	if (NULL == pNode) {	36,843,100✔
35	return DEAL_RES_CONTINUE;	396,030✔
36	}
37
38	EDealRes res = DEAL_RES_CONTINUE;	36,447,100✔
39
40	if (TRAVERSAL_PREORDER == order) {	36,447,100✔
41	res = walker(pNode, pContext);	36,325,800✔
42	if (DEAL_RES_CONTINUE != res) {	36,329,000✔
43	return res;	536,385✔
44	}
45	}
46
47	res = dispatcher(pNode, order, walker, pContext);	35,913,800✔
48
49	if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {	35,951,300!
50	res = walker(pNode, pContext);	141,762✔
51	}
52
53	return res;	35,993,200✔
54	}
55
56	static EDealRes dispatchExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {	35,936,600✔
57	EDealRes res = DEAL_RES_CONTINUE;	35,936,600✔
58
59	switch (nodeType(pNode)) {	35,936,600!
60	case QUERY_NODE_COLUMN:	35,233,300✔
61	case QUERY_NODE_VALUE:
62	case QUERY_NODE_LIMIT:
63	// these node types with no subnodes
64	break;	35,233,300✔
65	case QUERY_NODE_OPERATOR: {	329,678✔
66	SOperatorNode* pOpNode = (SOperatorNode*)pNode;	329,678✔
67	res = walkExpr(pOpNode->pLeft, order, walker, pContext);	329,678✔
68	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	329,670✔
69	res = walkExpr(pOpNode->pRight, order, walker, pContext);	329,030✔
70	}
71	break;	329,656✔
72	}
73	case QUERY_NODE_LOGIC_CONDITION:	66,878✔
74	res = walkExprs(((SLogicConditionNode*)pNode)->pParameterList, order, walker, pContext);	66,878✔
75	break;	66,880✔
76	case QUERY_NODE_FUNCTION:	171,795✔
77	res = walkExprs(((SFunctionNode*)pNode)->pParameterList, order, walker, pContext);	171,795✔
78	break;	171,795✔
79	case QUERY_NODE_REAL_TABLE:	112,331✔
80	case QUERY_NODE_TEMP_TABLE:
81	break; // todo	112,331✔
82	case QUERY_NODE_JOIN_TABLE: {	3,528✔
83	SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;	3,528✔
84	res = walkExpr(pJoinTableNode->pLeft, order, walker, pContext);	3,528✔
85	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	3,528!
86	res = walkExpr(pJoinTableNode->pRight, order, walker, pContext);	3,528✔
87	}
88	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	3,528!
89	res = walkExpr(pJoinTableNode->pOnCond, order, walker, pContext);	3,528✔
90	}
91	break;	3,528✔
92	}
93	case QUERY_NODE_GROUPING_SET:	8,816✔
94	res = walkExprs(((SGroupingSetNode*)pNode)->pParameterList, order, walker, pContext);	8,816✔
95	break;	8,816✔
96	case QUERY_NODE_ORDER_BY_EXPR:	14,773✔
97	res = walkExpr(((SOrderByExprNode*)pNode)->pExpr, order, walker, pContext);	14,773✔
98	break;	14,773✔
99	case QUERY_NODE_STATE_WINDOW: {	172✔
100	SStateWindowNode* pState = (SStateWindowNode*)pNode;	172✔
101	res = walkExpr(pState->pExpr, order, walker, pContext);	172✔
102	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	172!
103	res = walkExpr(pState->pCol, order, walker, pContext);	172✔
104	}
105	break;	172✔
106	}
107	case QUERY_NODE_SESSION_WINDOW: {	322✔
108	SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;	322✔
109	res = walkExpr((SNode*)pSession->pCol, order, walker, pContext);	322✔
110	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	322!
111	res = walkExpr((SNode*)pSession->pGap, order, walker, pContext);	322✔
112	}
113	break;	322✔
114	}
115	case QUERY_NODE_INTERVAL_WINDOW: {	5,516✔
116	SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;	5,516✔
117	res = walkExpr(pInterval->pInterval, order, walker, pContext);	5,516✔
118	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	5,516!
119	res = walkExpr(pInterval->pOffset, order, walker, pContext);	5,516✔
120	}
121	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	5,516!
122	res = walkExpr(pInterval->pSliding, order, walker, pContext);	5,516✔
123	}
124	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	5,516!
125	res = walkExpr(pInterval->pFill, order, walker, pContext);	5,516✔
126	}
127	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	5,516!
128	res = walkExpr(pInterval->pCol, order, walker, pContext);	5,516✔
129	}
130	break;	5,516✔
131	}
132	case QUERY_NODE_NODE_LIST:	16,612✔
133	res = walkExprs(((SNodeListNode*)pNode)->pNodeList, order, walker, pContext);	16,612✔
134	break;	16,613✔
135	case QUERY_NODE_FILL: {	3,368✔
136	SFillNode* pFill = (SFillNode*)pNode;	3,368✔
137	res = walkExpr(pFill->pValues, order, walker, pContext);	3,368✔
138	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	3,368!
139	res = walkExpr(pFill->pWStartTs, order, walker, pContext);	3,368✔
140	}
141	break;	3,368✔
142	}
143	case QUERY_NODE_RAW_EXPR:	×
144	res = walkExpr(((SRawExprNode*)pNode)->pNode, order, walker, pContext);	×
145	break;	×
146	case QUERY_NODE_TARGET:	363✔
147	res = walkExpr(((STargetNode*)pNode)->pExpr, order, walker, pContext);	363✔
148	break;	363✔
149	case QUERY_NODE_WHEN_THEN: {	993✔
150	SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;	993✔
151	res = walkExpr(pWhenThen->pWhen, order, walker, pContext);	993✔
152	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	993!
153	res = walkExpr(pWhenThen->pThen, order, walker, pContext);	980✔
154	}
155	break;	993✔
156	}
157	case QUERY_NODE_CASE_WHEN: {	675✔
158	SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;	675✔
159	res = walkExpr(pCaseWhen->pCase, order, walker, pContext);	675✔
160	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	675!
161	res = walkExpr(pCaseWhen->pElse, order, walker, pContext);	675✔
162	}
163	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	675!
164	res = walkExprs(pCaseWhen->pWhenThenList, order, walker, pContext);	675✔
165	}
166	break;	675✔
167	}
168	case QUERY_NODE_EVENT_WINDOW: {	180✔
169	SEventWindowNode* pEvent = (SEventWindowNode*)pNode;	180✔
170	res = walkExpr(pEvent->pCol, order, walker, pContext);	180✔
171	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	180!
172	res = walkExpr(pEvent->pStartCond, order, walker, pContext);	180✔
173	}
174	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	180!
175	res = walkExpr(pEvent->pEndCond, order, walker, pContext);	180✔
176	}
177	break;	180✔
178	}
179	case QUERY_NODE_COUNT_WINDOW: {	204✔
180	SCountWindowNode* pEvent = (SCountWindowNode*)pNode;	204✔
181	res = walkExpr(pEvent->pCol, order, walker, pContext);	204✔
182	break;	204✔
183	}
184	default:	×
185	break;	×
186	}
187
188	return res;	35,936,500✔
189	}
190
191	static EDealRes walkExpr(SNode* pNode, ETraversalOrder order, FNodeWalker walker, void* pContext) {	36,868,700✔
192	return walkNode(pNode, order, walker, pContext, dispatchExpr);	36,868,700✔
193	}
194
195	static EDealRes walkExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeWalker walker, void* pContext) {	997,323✔
196	SNode* node;
197	FOREACH(node, pNodeList) {	36,369,800✔
198	EDealRes res = walkExpr(node, order, walker, pContext);	35,385,600✔
199	if (DEAL_RES_ERROR == res \|\| DEAL_RES_END == res) {	35,388,100!
200	return res;	15,669✔
201	}
202	}
203	return DEAL_RES_CONTINUE;	984,177✔
204	}
205
206	void nodesWalkExpr(SNode* pNode, FNodeWalker walker, void* pContext) {	736,134✔
207	(void)walkExpr(pNode, TRAVERSAL_PREORDER, walker, pContext);	736,134✔
208	}	736,142✔
209
210	void nodesWalkExprs(SNodeList* pNodeList, FNodeWalker walker, void* pContext) {	714,432✔
211	(void)walkExprs(pNodeList, TRAVERSAL_PREORDER, walker, pContext);	714,432✔
212	}	714,399✔
213
214	void nodesWalkExprPostOrder(SNode* pNode, FNodeWalker walker, void* pContext) {	33,524✔
215	(void)walkExpr(pNode, TRAVERSAL_POSTORDER, walker, pContext);	33,524✔
216	}	33,552✔
217
218	void nodesWalkExprsPostOrder(SNodeList* pList, FNodeWalker walker, void* pContext) {	18,138✔
219	(void)walkExprs(pList, TRAVERSAL_POSTORDER, walker, pContext);	18,138✔
220	}	18,138✔
221
222	static void checkParamIsFunc(SFunctionNode* pFunc) {	106,041✔
223	int32_t numOfParams = LIST_LENGTH(pFunc->pParameterList);	106,041✔
224	for (int32_t i = 0; i < numOfParams; ++i) {	215,518✔
225	SNode* pPara = nodesListGetNode(pFunc->pParameterList, i);	109,477✔
226	if (numOfParams > 1 && nodeType(pPara) == QUERY_NODE_FUNCTION) {	109,477✔
227	((SFunctionNode*)pPara)->node.asParam = true;	102✔
228	}
229	if (nodeType(pPara) == QUERY_NODE_COLUMN) {	109,477✔
230	((SColumnNode*)pPara)->node.asParam = true;	99,314✔
231	}
232	}
233	}	106,041✔
234
235	static EDealRes rewriteExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext);
236
237	static EDealRes rewriteExpr(SNode** pRawNode, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {	26,248,100✔
238	if (NULL == pRawNode \|\| NULL == *pRawNode) {	26,248,100!
239	return DEAL_RES_CONTINUE;	130,843✔
240	}
241
242	EDealRes res = DEAL_RES_CONTINUE;	26,117,300✔
243
244	if (TRAVERSAL_PREORDER == order) {	26,117,300✔
245	res = rewriter(pRawNode, pContext);	3,519,180✔
246	if (DEAL_RES_CONTINUE != res) {	3,519,020✔
247	return res;	44,505✔
248	}
249	}
250
251	SNode* pNode = *pRawNode;	26,072,600✔
252	switch (nodeType(pNode)) {	26,072,600!
253	case QUERY_NODE_COLUMN:	25,647,700✔
254	case QUERY_NODE_VALUE:
255	case QUERY_NODE_LIMIT:
256	// these node types with no subnodes
257	break;	25,647,700✔
258	case QUERY_NODE_OPERATOR: {	204,480✔
259	SOperatorNode* pOpNode = (SOperatorNode*)pNode;	204,480✔
260	res = rewriteExpr(&(pOpNode->pLeft), order, rewriter, pContext);	204,480✔
261	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	204,471!
262	res = rewriteExpr(&(pOpNode->pRight), order, rewriter, pContext);	204,169✔
263	}
264	break;	204,466✔
265	}
266	case QUERY_NODE_LOGIC_CONDITION:	68,038✔
267	res = rewriteExprs(((SLogicConditionNode*)pNode)->pParameterList, order, rewriter, pContext);	68,038✔
268	break;	68,035✔
269	case QUERY_NODE_FUNCTION: {	106,042✔
270	SFunctionNode* pFunc = (SFunctionNode*)pNode;	106,042✔
271	checkParamIsFunc(pFunc);	106,042✔
272	res = rewriteExprs(pFunc->pParameterList, order, rewriter, pContext);	106,041✔
273	break;	106,042✔
274	}
275	case QUERY_NODE_REAL_TABLE:	18,568✔
276	case QUERY_NODE_TEMP_TABLE:
277	break; // todo	18,568✔
278	case QUERY_NODE_JOIN_TABLE: {	857✔
279	SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;	857✔
280	res = rewriteExpr(&(pJoinTableNode->pLeft), order, rewriter, pContext);	857✔
281	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	857!
282	res = rewriteExpr(&(pJoinTableNode->pRight), order, rewriter, pContext);	857✔
283	}
284	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	857!
285	res = rewriteExpr(&(pJoinTableNode->pOnCond), order, rewriter, pContext);	857✔
286	}
287	break;	857✔
288	}
289	case QUERY_NODE_GROUPING_SET:	2,350✔
290	res = rewriteExprs(((SGroupingSetNode*)pNode)->pParameterList, order, rewriter, pContext);	2,350✔
291	break;	2,350✔
292	case QUERY_NODE_ORDER_BY_EXPR:	10,494✔
293	res = rewriteExpr(&(((SOrderByExprNode*)pNode)->pExpr), order, rewriter, pContext);	10,494✔
294	break;	10,494✔
295	case QUERY_NODE_STATE_WINDOW: {	80✔
296	SStateWindowNode* pState = (SStateWindowNode*)pNode;	80✔
297	res = rewriteExpr(&pState->pExpr, order, rewriter, pContext);	80✔
298	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	80!
299	res = rewriteExpr(&pState->pCol, order, rewriter, pContext);	80✔
300	}
301	break;	80✔
302	}
303	case QUERY_NODE_SESSION_WINDOW: {	144✔
304	SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;	144✔
305	res = rewriteExpr((SNode**)&pSession->pCol, order, rewriter, pContext);	144✔
306	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	144!
307	res = rewriteExpr((SNode**)&pSession->pGap, order, rewriter, pContext);	132✔
308	}
309	break;	144✔
310	}
311	case QUERY_NODE_INTERVAL_WINDOW: {	2,554✔
312	SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pNode;	2,554✔
313	res = rewriteExpr(&(pInterval->pInterval), order, rewriter, pContext);	2,554✔
314	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	2,554!
315	res = rewriteExpr(&(pInterval->pOffset), order, rewriter, pContext);	2,554✔
316	}
317	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	2,554!
318	res = rewriteExpr(&(pInterval->pSliding), order, rewriter, pContext);	2,554✔
319	}
320	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	2,554!
321	res = rewriteExpr(&(pInterval->pFill), order, rewriter, pContext);	2,554✔
322	}
323	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	2,554!
324	res = rewriteExpr(&(pInterval->pCol), order, rewriter, pContext);	2,545✔
325	}
326	break;	2,554✔
327	}
328	case QUERY_NODE_NODE_LIST:	10,593✔
329	res = rewriteExprs(((SNodeListNode*)pNode)->pNodeList, order, rewriter, pContext);	10,593✔
330	break;	10,592✔
331	case QUERY_NODE_FILL: {	1,155✔
332	SFillNode* pFill = (SFillNode*)pNode;	1,155✔
333	res = rewriteExpr(&pFill->pValues, order, rewriter, pContext);	1,155✔
334	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	1,155!
335	res = rewriteExpr(&(pFill->pWStartTs), order, rewriter, pContext);	1,146✔
336	}
337	break;	1,155✔
338	}
339	case QUERY_NODE_RAW_EXPR:	×
340	res = rewriteExpr(&(((SRawExprNode*)pNode)->pNode), order, rewriter, pContext);	×
341	break;	×
342	case QUERY_NODE_TARGET:	×
343	res = rewriteExpr(&(((STargetNode*)pNode)->pExpr), order, rewriter, pContext);	×
344	break;	×
345	case QUERY_NODE_WHEN_THEN: {	480✔
346	SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;	480✔
347	res = rewriteExpr(&pWhenThen->pWhen, order, rewriter, pContext);	480✔
348	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	480!
349	res = rewriteExpr(&pWhenThen->pThen, order, rewriter, pContext);	480✔
350	}
351	break;	480✔
352	}
353	case QUERY_NODE_CASE_WHEN: {	325✔
354	SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;	325✔
355	res = rewriteExpr(&pCaseWhen->pCase, order, rewriter, pContext);	325✔
356	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	325!
357	res = rewriteExpr(&pCaseWhen->pElse, order, rewriter, pContext);	325✔
358	}
359	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	325!
360	res = rewriteExprs(pCaseWhen->pWhenThenList, order, rewriter, pContext);	325✔
361	}
362	break;	325✔
363	}
364	case QUERY_NODE_EVENT_WINDOW: {	83✔
365	SEventWindowNode* pEvent = (SEventWindowNode*)pNode;	83✔
366	res = rewriteExpr(&pEvent->pCol, order, rewriter, pContext);	83✔
367	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	83!
368	res = rewriteExpr(&pEvent->pStartCond, order, rewriter, pContext);	83✔
369	}
370	if (DEAL_RES_ERROR != res && DEAL_RES_END != res) {	83!
371	res = rewriteExpr(&pEvent->pEndCond, order, rewriter, pContext);	83✔
372	}
373	break;	83✔
374	}
375	case QUERY_NODE_COUNT_WINDOW: {	90✔
376	SCountWindowNode* pEvent = (SCountWindowNode*)pNode;	90✔
377	res = rewriteExpr(&pEvent->pCol, order, rewriter, pContext);	90✔
378	break;	90✔
379	}
380	default:	×
381	break;	×
382	}
383
384	if (DEAL_RES_ERROR != res && DEAL_RES_END != res && TRAVERSAL_POSTORDER == order) {	26,072,600!
385	res = rewriter(pRawNode, pContext);	22,638,200✔
386	}
387
388	return res;	26,075,300✔
389	}
390
391	static EDealRes rewriteExprs(SNodeList* pNodeList, ETraversalOrder order, FNodeRewriter rewriter, void* pContext) {	383,311✔
392	SNode** pNode;
393	FOREACH_FOR_REWRITE(pNode, pNodeList) {	25,843,400✔
394	EDealRes res = rewriteExpr(pNode, order, rewriter, pContext);	25,460,300✔
395	if (DEAL_RES_ERROR == res \|\| DEAL_RES_END == res) {	25,459,100!
UNCOV 396	return res;	×
397	}
398	}
399	return DEAL_RES_CONTINUE;	383,140✔
400	}
401
402	void nodesRewriteExpr(SNode** pNode, FNodeRewriter rewriter, void* pContext) {	114,345✔
403	(void)rewriteExpr(pNode, TRAVERSAL_PREORDER, rewriter, pContext);	114,345✔
404	}	114,346✔
405
406	void nodesRewriteExprs(SNodeList* pList, FNodeRewriter rewriter, void* pContext) {	152,046✔
407	(void)rewriteExprs(pList, TRAVERSAL_PREORDER, rewriter, pContext);	152,046✔
408	}	152,044✔
409
410	void nodesRewriteExprPostOrder(SNode** pNode, FNodeRewriter rewriter, void* pContext) {	238,067✔
411	(void)rewriteExpr(pNode, TRAVERSAL_POSTORDER, rewriter, pContext);	238,067✔
412	}	238,074✔
413
414	void nodesRewriteExprsPostOrder(SNodeList* pList, FNodeRewriter rewriter, void* pContext) {	43,938✔
415	(void)rewriteExprs(pList, TRAVERSAL_POSTORDER, rewriter, pContext);	43,938✔
416	}	43,937✔
417
418	void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext) {	120,313✔
419	if (NULL == pSelect) {	120,313!
420	return;	×
421	}
422
423	switch (clause) {	120,313!
424	case SQL_CLAUSE_FROM:	109,739✔
425	nodesWalkExpr(pSelect->pFromTable, walker, pContext);	109,739✔
426	nodesWalkExpr(pSelect->pWhere, walker, pContext);	109,738✔
427	case SQL_CLAUSE_WHERE:	110,039✔
428	nodesWalkExprs(pSelect->pPartitionByList, walker, pContext);	110,039✔
429	nodesWalkExprs(pSelect->pTags, walker, pContext);	110,039✔
430	nodesWalkExpr(pSelect->pSubtable, walker, pContext);	110,041✔
431	case SQL_CLAUSE_PARTITION_BY:	110,398✔
432	nodesWalkExpr(pSelect->pWindow, walker, pContext);	110,398✔
433	case SQL_CLAUSE_WINDOW:	111,251✔
434	if (NULL != pSelect->pWindow && QUERY_NODE_INTERVAL_WINDOW == nodeType(pSelect->pWindow)) {	111,251✔
435	nodesWalkExpr(((SIntervalWindowNode*)pSelect->pWindow)->pFill, walker, pContext);	6,243✔
436	}
437	case SQL_CLAUSE_FILL:
438	nodesWalkExprs(pSelect->pGroupByList, walker, pContext);	111,251✔
439	case SQL_CLAUSE_GROUP_BY:	118,536✔
440	nodesWalkExpr(pSelect->pHaving, walker, pContext);	118,536✔
441	case SQL_CLAUSE_HAVING:	118,632✔
442	case SQL_CLAUSE_SELECT:
443	case SQL_CLAUSE_DISTINCT:
444	nodesWalkExprs(pSelect->pOrderByList, walker, pContext);	118,632✔
445	case SQL_CLAUSE_ORDER_BY:	120,313✔
446	nodesWalkExprs(pSelect->pProjectionList, walker, pContext);	120,313✔
447	default:	120,312✔
448	break;	120,312✔
449	}
450
451	return;	120,312✔
452	}
453
454	void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewriter rewriter, void* pContext) {	32,976✔
455	if (NULL == pSelect) {	32,976!
456	return;	×
457	}
458
459	switch (clause) {	32,976!
460	case SQL_CLAUSE_FROM:	17,710✔
461	nodesRewriteExpr(&(pSelect->pFromTable), rewriter, pContext);	17,710✔
462	nodesRewriteExpr(&(pSelect->pWhere), rewriter, pContext);	17,711✔
463	case SQL_CLAUSE_WHERE:	17,711✔
464	nodesRewriteExprs(pSelect->pPartitionByList, rewriter, pContext);	17,711✔
465	nodesRewriteExprs(pSelect->pTags, rewriter, pContext);	17,711✔
466	nodesRewriteExpr(&(pSelect->pSubtable), rewriter, pContext);	17,711✔
467	case SQL_CLAUSE_PARTITION_BY:	17,711✔
468	nodesRewriteExpr(&(pSelect->pWindow), rewriter, pContext);	17,711✔
469	case SQL_CLAUSE_WINDOW:	18,585✔
470	if (NULL != pSelect->pWindow && QUERY_NODE_INTERVAL_WINDOW == nodeType(pSelect->pWindow)) {	18,585✔
471	nodesRewriteExpr(&(((SIntervalWindowNode*)pSelect->pWindow)->pFill), rewriter, pContext);	1,455✔
472	}
473	case SQL_CLAUSE_FILL:
474	nodesRewriteExprs(pSelect->pGroupByList, rewriter, pContext);	18,999✔
475	case SQL_CLAUSE_GROUP_BY:	32,847✔
476	nodesRewriteExpr(&(pSelect->pHaving), rewriter, pContext);	32,847✔
477	case SQL_CLAUSE_HAVING:	32,977✔
478	case SQL_CLAUSE_SELECT:
479	case SQL_CLAUSE_DISTINCT:
480	nodesRewriteExprs(pSelect->pOrderByList, rewriter, pContext);	32,977✔
481	case SQL_CLAUSE_ORDER_BY:	32,977✔
482	nodesRewriteExprs(pSelect->pProjectionList, rewriter, pContext);	32,977✔
483	default:	32,977✔
484	break;	32,977✔
485	}
486
487	return;	32,977✔
488	}

taosdata / TDengine / #3362

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

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