taosdata / TDengine / #4892

coverage: 65.571% (+0.02%) from 65.549%

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

94.09
/source/libs/parser/src/parCalcConst.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 "functionMgt.h"










17



#include "parInt.h"










18



#include "scalar.h"










19



#include "ttime.h"










20












21



typedef struct SNodeReplaceContext {










22



  SNode* pTarget;










23



  SNode* pNew;










24



  bool   replaced;










25



} SNodeReplaceContext;










26












27



typedef struct SCalcConstContext {










28



  SParseContext*      pParseCxt;










29



  SNodeReplaceContext replaceCxt;










30



  SMsgBuf             msgBuf;










31



  int32_t             code;










32



} SCalcConstContext;










33












34



static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subquery);










35












36



static int32_t calcConstSubquery(SCalcConstContext* pCxt, STempTableNode* pTempTable) {




12,387,230✔





37



  return calcConstQuery(pCxt, pTempTable->pSubquery, true);




12,387,230✔





38



}










39












40



static int32_t calcConstNode(SNode** pNode) {




363,157,740✔





41



  if (NULL == *pNode) {




363,157,740✔





42



    return TSDB_CODE_SUCCESS;




299,298,214✔





43



  }










44












45



  SNode*  pNew = NULL;




63,859,526✔





46



  int32_t code = scalarCalculateConstants(*pNode, &pNew);




63,859,526✔





47



  if (TSDB_CODE_SUCCESS == code) {




63,860,024✔





48



    *pNode = pNew;




63,860,024✔





49



  }










50



  return code;




63,860,024✔





51



}










52












53



static int32_t calcConstList(SNodeList* pList) {




307,728,737✔





54



  SNode* pNode = NULL;




307,728,737✔





55



  FOREACH(pNode, pList) {




353,867,437✔





56



    SNode*  pNew = NULL;




46,138,700✔





57



    int32_t code = scalarCalculateConstants(pNode, &pNew);




46,138,700✔





58



    if (TSDB_CODE_SUCCESS == code) {




46,138,202✔





59



      REPLACE_NODE(pNew);




46,138,202✔





60



    } else {










61



      return code;




×







62



    }










63



  }










64



  return TSDB_CODE_SUCCESS;




307,728,183✔





65



}










66












67



static bool isCondition(const SNode* pNode) {




112,556,258✔





68



  if (QUERY_NODE_OPERATOR == nodeType(pNode)) {




112,556,258✔





69



    return nodesIsComparisonOp((const SOperatorNode*)pNode);




88,305,660✔





70



  }










71



  return (QUERY_NODE_LOGIC_CONDITION == nodeType(pNode));




24,251,096✔





72



}










73












74



static int32_t rewriteIsTrue(SNode* pSrc, SNode** pIsTrue) {




280,315✔





75



  SOperatorNode* pOp = NULL;




280,315✔





76



  int32_t        code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp);




280,315✔





77



  if (NULL == pOp) {




280,315✔





78



    return code;




×







79



  }










80



  pOp->opType = OP_TYPE_IS_TRUE;




280,315✔





81



  pOp->pLeft = pSrc;




280,315✔





82



  pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;




280,315✔





83



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




280,315✔





84



  *pIsTrue = (SNode*)pOp;




280,315✔





85



  return TSDB_CODE_SUCCESS;




280,315✔





86



}










87












88



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




365,987,390✔





89



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




365,987,390✔





90



    SNode* pParam = NULL;




23,977,351✔





91



    FOREACH(pParam, ((SLogicConditionNode*)*pNode)->pParameterList) {




84,234,920✔





92



      if (!isCondition(pParam)) {




60,258,067✔





93



        SNode* pIsTrue = NULL;




264,351✔





94



        if (TSDB_CODE_SUCCESS != rewriteIsTrue(pParam, &pIsTrue)) {




264,351✔





95



          ((SCalcConstContext*)pContext)->code = TSDB_CODE_OUT_OF_MEMORY;




×







96



          return DEAL_RES_ERROR;




×







97



        }










98



        REPLACE_NODE(pIsTrue);




264,351✔





99



      }










100



    }










101



  }










102



  return DEAL_RES_CONTINUE;




365,989,382✔





103



}










104












105



static int32_t rewriteCondition(SCalcConstContext* pCxt, SNode** pNode) {




52,298,689✔





106



  if (!isCondition(*pNode)) {




52,298,689✔





107



    return rewriteIsTrue(*pNode, pNode);




15,964✔





108



  }










109



  nodesRewriteExprPostOrder(pNode, doRewriteCondition, pCxt);




52,283,223✔





110



  return pCxt->code;




52,283,223✔





111



}










112












113



static int32_t calcConstCondition(SCalcConstContext* pCxt, SNode** pNode) {




2,572,675✔





114



  int32_t code = rewriteCondition(pCxt, pNode);




2,572,675✔





115



  if (TSDB_CODE_SUCCESS == code) {




2,572,675✔





116



    code = calcConstNode(pNode);




2,572,675✔





117



  }










118



  return code;




2,572,675✔





119



}










120












121



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




11,639,742✔





122



  int32_t                code = TSDB_CODE_SUCCESS;




11,639,742✔





123



  int32_t                lino = 0;




11,639,742✔





124



  SCalcConstContext* pCtx = (SCalcConstContext*)pContext;




11,639,742✔





125












126



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




11,639,742✔





127



    return DEAL_RES_CONTINUE;




1,719,950✔





128



  } else if (QUERY_NODE_OPERATOR == nodeType(*pNode)) {




9,919,792✔





129



    SOperatorNode* pOp = (SOperatorNode*)*pNode;




9,919,792✔





130



    if (OP_TYPE_EQUAL == pOp->opType && (TSDB_DATA_TYPE_TIMESTAMP == ((SExprNode*)pOp->pLeft)->resType.type || TSDB_DATA_TYPE_TIMESTAMP == ((SExprNode*)pOp->pRight)->resType.type)) {




9,919,792✔





131



      code = calcConstNode(&pOp->pLeft);




7,347,117✔





132



      if (TSDB_CODE_SUCCESS == code) {




7,347,117✔





133



        code = calcConstNode(&pOp->pRight);




7,347,117✔





134



      }










135



      










136



      goto _end;




7,347,117✔





137



    }










138



  }










139












140



  if (TSDB_CODE_SUCCESS == code) {




2,572,675✔





141



    code = calcConstCondition(pCtx, pNode);




2,572,675✔





142



  }










143



  










144



_end:




×







145












146



  if (code != TSDB_CODE_SUCCESS) {




9,919,792✔





147



    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));




×







148



    return DEAL_RES_ERROR;




×







149



  }










150



  










151



  return DEAL_RES_IGNORE_CHILD;




9,919,792✔





152



}










153












154



static int32_t rewriteConditionForFromTable(SCalcConstContext* pCxt, SNode* pTable) {




119,173,347✔





155



  int32_t code = TSDB_CODE_SUCCESS;




119,173,347✔





156



  switch (nodeType(pTable)) {




119,173,347✔





157



    case QUERY_NODE_TEMP_TABLE: {




12,387,230✔





158



      code = calcConstSubquery(pCxt, (STempTableNode*)pTable);




12,387,230✔





159



      break;




12,387,230✔





160



    }










161



    case QUERY_NODE_JOIN_TABLE: {




8,086,960✔





162



      SJoinTableNode* pJoin = (SJoinTableNode*)pTable;




8,086,960✔





163



      SNode* pCond = NULL;




8,086,960✔





164



      code = rewriteConditionForFromTable(pCxt, pJoin->pLeft);




8,086,960✔





165



      if (TSDB_CODE_SUCCESS == code) {




8,086,462✔





166



        code = rewriteConditionForFromTable(pCxt, pJoin->pRight);




8,086,462✔





167



      }










168



      if (TSDB_CODE_SUCCESS == code && NULL != pJoin->pOnCond) {




8,086,462✔





169



        code = rewriteCondition(pCxt, &pJoin->pOnCond);




7,697,578✔





170



      }










171



      if (TSDB_CODE_SUCCESS == code && NULL != pJoin->pOnCond) {




8,086,462✔





172



        nodesRewriteExpr(&pJoin->pOnCond, rewriteCalcConstValue, pCxt);




7,697,578✔





173



      }










174












175



/*










176



      if (TSDB_CODE_SUCCESS == code && NULL != pJoin->pOnCond) {










177



        code = nodesCloneNode(pJoin->pOnCond, &pCond);










178



      }










179



      if (TSDB_CODE_SUCCESS == code && NULL != pJoin->pOnCond) {










180



        code = calcConstCondition(pCxt, &pJoin->pOnCond);










181



      }










182



      if (TSDB_CODE_SUCCESS == code && pJoin->pOnCond && QUERY_NODE_VALUE == nodeType(pJoin->pOnCond)) {










183



        nodesDestroyNode(pJoin->pOnCond);










184



        pJoin->pOnCond = pCond;










185



        pCond = NULL;










186



      }










187



      nodesDestroyNode(pCond);










188



*/










189



      // todo empty table










190



      break;




8,086,462✔





191



    }










192



    default:




98,699,912✔





193



      break;




98,699,912✔





194



  }










195



  return code;




119,173,604✔





196



}










197












198



static int32_t calcConstFromTable(SCalcConstContext* pCxt, SNode* pTable) {




103,000,680✔





199



  return rewriteConditionForFromTable(pCxt, pTable);




103,000,680✔





200



}










201












202



static void rewriteConstCondition(SNode** pCond, bool* pAlwaysFalse) {




42,028,934✔





203



  if (QUERY_NODE_VALUE != nodeType(*pCond)) {




42,028,934✔





204



    return;




40,299,014✔





205



  }










206



  if (((SValueNode*)*pCond)->datum.b) {




1,729,920✔





207



    nodesDestroyNode(*pCond);




1,693,514✔





208



    *pCond = NULL;




1,693,514✔





209



  } else {










210



    *pAlwaysFalse = true;




36,406✔





211



  }










212



}










213












214



static int32_t calcConstStmtCondition(SCalcConstContext* pCxt, SNode** pCond, bool* pAlwaysFalse) {




204,152,731✔





215



  if (NULL == *pCond) {




204,152,731✔





216



    return TSDB_CODE_SUCCESS;




162,125,203✔





217



  }










218












219



  int32_t code = rewriteCondition(pCxt, pCond);




42,027,684✔





220



  if (TSDB_CODE_SUCCESS == code) {




42,028,934✔





221



    code = calcConstNode(pCond);




42,028,934✔





222



  }










223



  if (TSDB_CODE_SUCCESS == code) {




42,028,934✔





224



    rewriteConstCondition(pCond, pAlwaysFalse);




42,028,934✔





225



  }










226



  return code;




42,028,934✔





227



}










228












229



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




4,248✔





230



  SCalcConstContext* pCxt = pContext;




4,248✔





231



  if (pCxt->replaceCxt.pTarget == *pNode) {




4,248✔





232



    char aliasName[TSDB_COL_NAME_LEN] = {0};




4,248✔





233



    tstrncpy(aliasName, ((SExprNode*)*pNode)->aliasName, TSDB_COL_NAME_LEN);




4,248✔





234



    nodesDestroyNode(*pNode);




4,248✔





235



    *pNode = NULL;




4,248✔





236



    pCxt->code = nodesCloneNode(pCxt->replaceCxt.pNew, pNode);




4,248✔





237



    if (NULL == *pNode) {




4,248✔





238



      return DEAL_RES_ERROR;




×







239



    }










240



    tstrncpy(((SExprNode*)*pNode)->aliasName, aliasName, TSDB_COL_NAME_LEN);




4,248✔





241












242



    pCxt->replaceCxt.replaced = true;




4,248✔





243



    return DEAL_RES_END;




4,248✔





244



  }










245



  return DEAL_RES_CONTINUE;




×







246



}










247












248



static int32_t findAndReplaceNode(SCalcConstContext* pCxt, SNode** pRoot, SNode* pTarget, SNode* pNew, bool strict) {




4,248✔





249



  pCxt->replaceCxt.pNew = pNew;




4,248✔





250



  pCxt->replaceCxt.pTarget = pTarget;




4,248✔





251












252



  nodesRewriteExprPostOrder(pRoot, doFindAndReplaceNode, pCxt);




4,248✔





253



  if (TSDB_CODE_SUCCESS == pCxt->code && strict && !pCxt->replaceCxt.replaced) {




4,248✔





254



    parserError("target replace node not found, %p", pTarget);




×







255



    return TSDB_CODE_PAR_INTERNAL_ERROR;




×







256



  }










257



  return pCxt->code;




4,248✔





258



}










259












260



static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool dual, SNode** pNew) {




490,770,202✔





261



  SArray* pAssociation = NULL;




490,770,202✔





262



  










263



  if (NULL != ((SExprNode*)pProject)->pAssociation) {




490,770,202✔





264



    pAssociation = taosArrayDup(((SExprNode*)pProject)->pAssociation, NULL);




24,373,855✔





265



    if (NULL == pAssociation) {




24,373,855✔






UNCOV

266



      return terrno;




×







267



    }










268



  }










269












270



  char    aliasName[TSDB_COL_NAME_LEN] = {0}, srcTable[TSDB_TABLE_NAME_LEN] = {0};




490,770,459✔





271



  int32_t code = TSDB_CODE_SUCCESS;




490,770,411✔





272



  if (dual) {




490,770,411✔





273



    code = scalarCalculateConstantsFromDual(pProject, pNew);




2,940,404✔





274



  } else {










275



    code = scalarCalculateConstants(pProject, pNew);




487,830,007✔





276



  }










277



  if (TSDB_CODE_SUCCESS == code) {




490,771,432✔





278



    if (QUERY_NODE_VALUE == nodeType(*pNew) && NULL != pAssociation) {




490,767,223✔





279



      int32_t size = taosArrayGetSize(pAssociation);




1,166,625✔





280



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




2,334,850✔





281



        SAssociationNode* pAssNode = taosArrayGet(pAssociation, i);




1,168,225✔





282



        SNode**           pCol = pAssNode->pPlace;




1,168,225✔





283



        if (((SExprNode*)pAssNode->pAssociationNode)->joinSrc) {




1,168,225✔





284



          //((SExprNode*)pAssNode->pAssociationNode)->constValue = true;










285



          continue;




×







286



        }










287



        










288



        if (*pCol == pAssNode->pAssociationNode) {




1,168,225✔





289



          tstrncpy(aliasName, ((SExprNode*)*pCol)->aliasName, TSDB_COL_NAME_LEN);




1,163,977✔





290



          if (QUERY_NODE_COLUMN == nodeType(*pCol)) {




1,163,977✔





291



            tstrncpy(srcTable, ((SColumnNode*)*pCol)->tableAlias, TSDB_TABLE_NAME_LEN);




1,163,977✔





292



          }










293



          SArray* pOrigAss = NULL;




1,163,977✔





294



          TSWAP(((SExprNode*)*pCol)->pAssociation, pOrigAss);




1,163,977✔





295



          nodesDestroyNode(*pCol);




1,163,977✔





296



          *pCol = NULL;




1,163,977✔





297



          code = nodesCloneNode(*pNew, pCol);




1,163,977✔





298



          if (TSDB_CODE_SUCCESS == code) {




1,163,977✔





299



            tstrncpy(((SExprNode*)*pCol)->aliasName, aliasName, TSDB_COL_NAME_LEN);




1,163,977✔





300



            if (srcTable[0]) {




1,163,977✔





301



              tstrncpy(((SExprNode*)*pCol)->srcTable, srcTable, TSDB_TABLE_NAME_LEN);




1,163,977✔





302



            }










303



            TSWAP(pOrigAss, ((SExprNode*)*pCol)->pAssociation);




1,163,977✔





304



          }










305



          taosArrayDestroy(pOrigAss);




1,163,977✔





306



          if (TSDB_CODE_SUCCESS != code) {




1,163,977✔





307



            break;




×







308



          }










309



        } else {










310



          code = findAndReplaceNode(pCxt, pCol, pAssNode->pAssociationNode, *pNew, true);




4,248✔





311



          if (TSDB_CODE_SUCCESS != code) {




4,248✔





312



            break;




×







313



          }










314



        }










315



      }










316



    }










317



  }










318



  taosArrayDestroy(pAssociation);




490,772,139✔





319



  return code;




490,770,714✔





320



}










321












322



typedef struct SIsUselessColCtx {










323



  bool isUseless;










324



} SIsUselessColCtx;










325












326



EDealRes checkUselessCol(SNode* pNode, void* pContext) {




93,210,104✔





327



  SIsUselessColCtx* ctx = (SIsUselessColCtx*)pContext;




93,210,104✔





328



  if (QUERY_NODE_FUNCTION == nodeType(pNode) && !fmIsScalarFunc(((SFunctionNode*)pNode)->funcId) &&




93,210,104✔





329



      !fmIsPseudoColumnFunc(((SFunctionNode*)pNode)->funcId)) {




7,647,693✔





330



    ctx->isUseless = false;




6,318,031✔





331



    return DEAL_RES_END;




6,318,031✔





332



  }










333












334



  return DEAL_RES_CONTINUE;




86,892,073✔





335



}










336












337



static bool isUselessCol(SExprNode* pProj) {




78,115,799✔





338



  SIsUselessColCtx ctx = {.isUseless = true};




78,115,799✔





339



  nodesWalkExpr((SNode*)pProj, checkUselessCol, (void*)&ctx);




78,115,799✔





340



  if (!ctx.isUseless) {




78,115,799✔





341



    return false;




6,318,031✔





342



  }










343



  return NULL == ((SExprNode*)pProj)->pAssociation;




71,797,768✔





344



}










345












346



static int32_t createConstantValue(SValueNode** ppNode) {




109,384✔





347



  SValueNode* pVal = NULL;




109,384✔





348



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




109,384✔





349



  if (NULL == pVal) {




109,384✔





350



    return code;




×







351



  }










352



  pVal->node.resType.type = TSDB_DATA_TYPE_INT;




109,384✔





353



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




109,384✔





354



  const int32_t val = 1;




109,384✔





355



  code = nodesSetValueNodeValue(pVal, (void*)&val);




109,384✔





356



  if (TSDB_CODE_SUCCESS == code) {




109,384✔





357



    pVal->translate = true;




109,384✔





358



    *ppNode = pVal;




109,384✔





359



  } else {










360



    nodesDestroyNode((SNode*)pVal);




×







361



  }










362



  return code;




109,384✔





363



}










364












365



static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) {




103,478,638✔





366



  SNode* pProj = NULL;




103,478,638✔





367



  WHERE_EACH(pProj, pSelect->pProjectionList) {




644,649,395✔





368



    if (subquery && !pSelect->isDistinct && !pSelect->tagScan && isUselessCol((SExprNode*)pProj) && (pSelect->pFromTable && nodeType(pSelect->pFromTable) != QUERY_NODE_VIRTUAL_TABLE)) {




541,174,987✔





369



      ERASE_NODE(pSelect->pProjectionList);




50,403,844✔





370



      continue;




50,403,844✔





371



    }










372



    SNode*  pNew = NULL;




490,771,143✔





373



    int32_t code = calcConstProject(pCxt, pProj, (NULL == pSelect->pFromTable), &pNew);




490,770,411✔





374



    if (TSDB_CODE_SUCCESS == code) {




490,771,467✔





375



      REPLACE_NODE(pNew);




490,767,258✔





376



    } else {










377



      return code;




4,209✔





378



    }










379



    WHERE_NEXT;




490,766,262✔





380



  }










381



  if (0 == LIST_LENGTH(pSelect->pProjectionList)) {




103,475,349✔





382



    SValueNode* pVal = NULL;




104,865✔





383



    int32_t     code = createConstantValue(&pVal);




104,865✔





384



    if (TSDB_CODE_SUCCESS == code) {




104,865✔





385



      return nodesListStrictAppend(pSelect->pProjectionList, (SNode*)pVal);




104,865✔





386



    }










387



  }










388



  return TSDB_CODE_SUCCESS;




103,369,343✔





389



}










390












391



static int32_t calcConstGroupBy(SCalcConstContext* pCxt, SSelectStmt* pSelect) {




101,287,147✔





392



  int32_t code = calcConstList(pSelect->pGroupByList);




101,287,147✔





393



  if (TSDB_CODE_SUCCESS == code) {




101,286,885✔





394



    SNode* pNode = NULL;




101,286,885✔





395



    FOREACH(pNode, pSelect->pGroupByList) {




118,775,042✔





396



      bool   hasNotValue = false;




17,488,157✔





397



      SNode* pGroupPara = NULL;




17,488,157✔





398



      FOREACH(pGroupPara, ((SGroupingSetNode*)pNode)->pParameterList) {




18,261,441✔





399



        if (QUERY_NODE_VALUE != nodeType(pGroupPara)) {




17,488,157✔





400



          hasNotValue = true;




16,714,873✔





401



          break;




16,714,873✔





402



        }










403



      }










404



      if (!hasNotValue) {




17,488,157✔





405



        if (pSelect->hasAggFuncs) {




773,284✔





406



          ERASE_NODE(pSelect->pGroupByList);




37,538✔





407



        } else {










408



          if (!cell->pPrev && !cell->pNext) continue;




735,746✔





409



          ERASE_NODE(pSelect->pGroupByList);




×







410



        }










411



      }










412



    }










413



  }










414



  return code;




101,287,649✔





415



}










416












417



static int32_t calcConstSelectWithoutFrom(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) {




2,191,909✔





418



  return calcConstProjections(pCxt, pSelect, subquery);




2,191,909✔





419



}










420












421



static int32_t calcConstSelectFrom(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) {




101,338,904✔





422



  int32_t code = calcConstFromTable(pCxt, pSelect->pFromTable);




101,338,904✔





423



  if (TSDB_CODE_SUCCESS == code && QUERY_NODE_TEMP_TABLE == nodeType(pSelect->pFromTable) &&




101,339,402✔





424



      ((STempTableNode*)pSelect->pFromTable)->pSubquery != NULL &&




11,995,914✔





425



      QUERY_NODE_SELECT_STMT == nodeType(((STempTableNode*)pSelect->pFromTable)->pSubquery) &&




11,995,914✔





426



      ((SSelectStmt*)((STempTableNode*)pSelect->pFromTable)->pSubquery)->isEmptyResult) {




10,471,785✔





427



    pSelect->isEmptyResult = true;




52,188✔





428



    return code;




52,188✔





429



  }










430



  if (pSelect->mixSysTableAndActualTable) {




101,288,134✔





431



    return code;




710✔





432



  }










433



  if (TSDB_CODE_SUCCESS == code) {




101,286,504✔





434



    code = calcConstProjections(pCxt, pSelect, subquery);




101,287,702✔





435



  }










436



  if (TSDB_CODE_SUCCESS == code) {




101,285,310✔





437



    code = calcConstStmtCondition(pCxt, &pSelect->pWhere, &pSelect->isEmptyResult);




101,286,508✔





438



  }










439



  if (TSDB_CODE_SUCCESS == code) {




101,286,934✔





440



    code = calcConstList(pSelect->pPartitionByList);




101,286,934✔





441



  }










442



  if (TSDB_CODE_SUCCESS == code) {




101,287,649✔





443



    code = calcConstNode(&pSelect->pWindow);




101,287,649✔





444



  }










445



  if (TSDB_CODE_SUCCESS == code) {




101,286,672✔





446



    code = calcConstGroupBy(pCxt, pSelect);




101,286,672✔





447



  }










448



  if (TSDB_CODE_SUCCESS == code) {




101,287,649✔





449



    code = calcConstStmtCondition(pCxt, &pSelect->pHaving, &pSelect->isEmptyResult);




101,287,911✔





450



  }










451



  if (TSDB_CODE_SUCCESS == code) {




101,287,911✔





452



    code = calcConstList(pSelect->pOrderByList);




101,287,911✔





453



  }










454



  if (TSDB_CODE_SUCCESS == code) {




101,287,911✔





455



    code = calcConstNode(&pSelect->pFill);




101,287,911✔





456



  }










457



  if (TSDB_CODE_SUCCESS == code) {




101,287,686✔





458



    code = calcConstNode(&pSelect->pTimeRange);




101,287,686✔





459



  }










460



  return code;




101,287,911✔





461



}










462












463



static int32_t calcConstSelect(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) {




103,531,536✔





464



  if (NULL == pSelect->pFromTable) {




103,531,536✔





465



    return calcConstSelectWithoutFrom(pCxt, pSelect, subquery);




2,191,909✔





466



  } else {










467



    return calcConstSelectFrom(pCxt, pSelect, subquery);




101,340,809✔





468



  }










469



}










470












471



static int32_t calcConstDelete(SCalcConstContext* pCxt, SDeleteStmt* pDelete) {




1,578,577✔





472



  int32_t code = calcConstFromTable(pCxt, pDelete->pFromTable);




1,578,577✔





473



  if (TSDB_CODE_SUCCESS == code) {




1,578,577✔





474



    code = calcConstStmtCondition(pCxt, &pDelete->pWhere, &pDelete->deleteZeroRows);




1,578,577✔





475



  }










476



  if (code == TSDB_CODE_SUCCESS && pDelete->timeRange.skey > pDelete->timeRange.ekey) {




1,578,577✔





477



    pDelete->deleteZeroRows = true;




205,424✔





478



  }










479



  return code;




1,578,577✔





480



}










481












482



static int32_t calcConstInsert(SCalcConstContext* pCxt, SInsertStmt* pInsert) {




82,476✔





483



  int32_t code = calcConstFromTable(pCxt, pInsert->pTable);




82,476✔





484



  if (TSDB_CODE_SUCCESS == code) {




82,476✔





485



    code = calcConstQuery(pCxt, pInsert->pQuery, false);




82,476✔





486



  }










487



  return code;




82,476✔





488



}










489












490



static SNodeList* getChildProjection(SNode* pStmt) {




2,381,871✔





491



  switch (nodeType(pStmt)) {




2,381,871✔





492



    case QUERY_NODE_SELECT_STMT:




2,371,169✔





493



      return ((SSelectStmt*)pStmt)->pProjectionList;




2,371,169✔





494



    case QUERY_NODE_SET_OPERATOR:




10,702✔





495



      return ((SSetOperator*)pStmt)->pProjectionList;




10,702✔





496



    default:




×







497



      break;




×







498



  }










499



  return NULL;




×







500



}










501












502



static void eraseSetOpChildProjection(SSetOperator* pSetOp, int32_t index) {




593,958✔





503



  SNodeList* pLeftProjs = getChildProjection(pSetOp->pLeft);




593,958✔





504



  (void)nodesListErase(pLeftProjs, nodesListGetCell(pLeftProjs, index));




593,958✔





505



  if (QUERY_NODE_SET_OPERATOR == nodeType(pSetOp->pLeft)) {




593,958✔





506



    eraseSetOpChildProjection((SSetOperator*)pSetOp->pLeft, index);




5,280✔





507



  }










508



  SNodeList* pRightProjs = getChildProjection(pSetOp->pRight);




593,958✔





509



  (void)nodesListErase(pRightProjs, nodesListGetCell(pRightProjs, index));




593,958✔





510



  if (QUERY_NODE_SET_OPERATOR == nodeType(pSetOp->pRight)) {




593,958✔





511



    eraseSetOpChildProjection((SSetOperator*)pSetOp->pRight, index);




×







512



  }










513



}




593,958✔





514












515



typedef struct SNotRefByOrderByCxt {










516



  SColumnNode* pCol;










517



  bool         hasThisCol;










518



} SNotRefByOrderByCxt;










519












520



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




3,832,248✔





521



  if (QUERY_NODE_COLUMN == nodeType(pNode)) {




3,832,248✔





522



    SNotRefByOrderByCxt* pCxt = (SNotRefByOrderByCxt*)pContext;




1,916,124✔





523



    if (nodesEqualNode((SNode*)pCxt->pCol, pNode)) {




1,916,124✔





524



      pCxt->hasThisCol = true;




618,319✔





525



      return DEAL_RES_END;




618,319✔





526



    }










527



  }










528



  return DEAL_RES_CONTINUE;




3,213,929✔





529



}










530












531



static bool notRefByOrderBy(SColumnNode* pCol, SNodeList* pOrderByList) {




2,279,164✔





532



  SNotRefByOrderByCxt cxt = {.pCol = pCol, .hasThisCol = false};




2,279,164✔





533



  nodesWalkExprs(pOrderByList, notRefByOrderByImpl, &cxt);




2,279,164✔





534



  return !cxt.hasThisCol;




2,279,164✔





535



}










536












537



static bool isDistinctSubQuery(SNode* pNode) {




1,222,332✔





538



  if (NULL == pNode) {




1,222,332✔





539



    return false;




×







540



  }










541



  switch (nodeType(pNode)) {




1,222,332✔





542



    case QUERY_NODE_SELECT_STMT:




1,200,128✔





543



      return ((SSelectStmt*)pNode)->isDistinct;




1,200,128✔





544



    case QUERY_NODE_SET_OPERATOR:




22,204✔





545



      return isDistinctSubQuery((((SSetOperator*)pNode)->pLeft)) || isDistinctSubQuery((((SSetOperator*)pNode)->pLeft));




22,204✔





546



    default:




×







547



      break;




×







548



  }










549



  return false;




×







550



}










551












552



static bool isSetUselessCol(SSetOperator* pSetOp, int32_t index, SExprNode* pProj) {




1,660,845✔





553



  if (!isUselessCol(pProj)) {




1,660,845✔





554



    return false;




1,056,136✔





555



  }










556












557



  SNodeList* pLeftProjs = getChildProjection(pSetOp->pLeft);




604,709✔





558



  if (!isUselessCol((SExprNode*)nodesListGetNode(pLeftProjs, index)) || isDistinctSubQuery(pSetOp->pLeft)) {




604,709✔





559



    return false;




15,463✔





560



  }










561












562



  SNodeList* pRightProjs = getChildProjection(pSetOp->pRight);




589,246✔





563



  if (!isUselessCol((SExprNode*)nodesListGetNode(pRightProjs, index)) || isDistinctSubQuery(pSetOp->pLeft)) {




589,246✔





564



    return false;




568✔





565



  }










566












567



  return true;




588,678✔





568



}










569












570



static int32_t calcConstSetOpProjections(SCalcConstContext* pCxt, SSetOperator* pSetOp, bool subquery) {




3,866,364✔





571



  if (subquery && pSetOp->opType == SET_OP_TYPE_UNION) {




3,866,364✔





572



    return TSDB_CODE_SUCCESS;




754,555✔





573



  }










574



  int32_t index = 0;




3,111,809✔





575



  SNode*  pProj = NULL;




3,111,809✔





576



  WHERE_EACH(pProj, pSetOp->pProjectionList) {




10,226,394✔





577



    if (subquery && notRefByOrderBy((SColumnNode*)pProj, pSetOp->pOrderByList) &&




8,775,430✔





578



        isSetUselessCol(pSetOp, index, (SExprNode*)pProj)) {




1,660,845✔





579



      ERASE_NODE(pSetOp->pProjectionList);




588,678✔





580



      eraseSetOpChildProjection(pSetOp, index);




588,678✔





581



      continue;




588,678✔





582



    }










583



    ++index;




6,525,907✔





584



    WHERE_NEXT;




6,525,907✔





585



  }










586



  if (0 == LIST_LENGTH(pSetOp->pProjectionList)) {




3,111,809✔





587



    SValueNode* pVal = NULL;




4,519✔





588



    int32_t     code = createConstantValue(&pVal);




4,519✔





589



    if (TSDB_CODE_SUCCESS == code) {




4,519✔





590



      return nodesListStrictAppend(pSetOp->pProjectionList, (SNode*)pVal);




4,519✔





591



    }










592



  }










593



  return TSDB_CODE_SUCCESS;




3,107,290✔





594



}










595












596



static int32_t calcConstSetOperator(SCalcConstContext* pCxt, SSetOperator* pSetOp, bool subquery) {




3,866,364✔





597



  int32_t code = calcConstSetOpProjections(pCxt, pSetOp, subquery);




3,866,364✔





598



  if (TSDB_CODE_SUCCESS == code) {




3,866,364✔





599



    code = calcConstQuery(pCxt, pSetOp->pLeft, false);




3,866,364✔





600



  }










601



  if (TSDB_CODE_SUCCESS == code) {




3,866,364✔





602



    code = calcConstQuery(pCxt, pSetOp->pRight, false);




3,866,364✔





603



  }










604



  if (TSDB_CODE_SUCCESS == code) {




3,866,364✔





605



    code = calcConstList(pSetOp->pOrderByList);




3,866,364✔





606



  }










607



  return code;




3,866,364✔





608



}










609












610



static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subquery) {




186,417,385✔





611



  int32_t code = TSDB_CODE_SUCCESS;




186,417,385✔





612



  switch (nodeType(pStmt)) {




186,417,385✔





613



    case QUERY_NODE_SELECT_STMT:




103,531,750✔





614



      code = calcConstSelect(pCxt, (SSelectStmt*)pStmt, subquery);




103,531,750✔





615



      break;




103,532,220✔





616



    case QUERY_NODE_EXPLAIN_STMT:




4,754,838✔





617



      code = calcConstQuery(pCxt, ((SExplainStmt*)pStmt)->pQuery, subquery);




4,754,838✔





618



      break;




4,755,110✔





619



    case QUERY_NODE_SET_OPERATOR: {




3,866,364✔





620



      code = calcConstSetOperator(pCxt, (SSetOperator*)pStmt, subquery);




3,866,364✔





621



      break;




3,866,364✔





622



    }










623



    case QUERY_NODE_DELETE_STMT:




1,578,577✔





624



      code = calcConstDelete(pCxt, (SDeleteStmt*)pStmt);




1,578,577✔





625



      break;




1,578,577✔





626



    case QUERY_NODE_INSERT_STMT:




82,002✔





627



      code = calcConstInsert(pCxt, (SInsertStmt*)pStmt);




82,002✔





628



      break;




82,476✔





629



    default:




72,605,392✔





630



      break;




72,605,392✔





631



  }










632



  return code;




186,420,139✔





633



}










634












635



static bool isEmptyResultQuery(SNode* pStmt) {




168,330,778✔





636



  bool isEmptyResult = false;




168,330,778✔





637



  switch (nodeType(pStmt)) {




168,330,778✔





638



    case QUERY_NODE_SELECT_STMT:




87,191,830✔





639



      isEmptyResult = ((SSelectStmt*)pStmt)->isEmptyResult;




87,191,830✔





640



      break;




87,192,092✔





641



    case QUERY_NODE_EXPLAIN_STMT:




4,754,838✔





642



      isEmptyResult = isEmptyResultQuery(((SExplainStmt*)pStmt)->pQuery);




4,754,838✔





643



      break;




4,755,463✔





644



    case QUERY_NODE_SET_OPERATOR: {




2,120,017✔





645



      SSetOperator* pSetOp = (SSetOperator*)pStmt;




2,120,017✔





646



      isEmptyResult = isEmptyResultQuery(pSetOp->pLeft);




2,120,017✔





647



      if (isEmptyResult) {




2,120,017✔





648



        isEmptyResult = isEmptyResultQuery(pSetOp->pRight);




589✔





649



      }










650



      break;




2,120,017✔





651



    }










652



    case QUERY_NODE_DELETE_STMT:




1,580,475✔





653



      isEmptyResult = ((SDeleteStmt*)pStmt)->deleteZeroRows;




1,580,475✔





654



      break;




1,578,577✔





655



    default:




72,684,928✔





656



      break;




72,684,928✔





657



  }










658



  return isEmptyResult;




168,331,077✔





659



}










660












661



static void resetProjectNullTypeImpl(SNodeList* pProjects) {




85,739,688✔





662



  SNode* pProj = NULL;




85,739,688✔





663



  FOREACH(pProj, pProjects) {




530,208,865✔





664



    SExprNode* pExpr = (SExprNode*)pProj;




444,468,941✔





665



    if (TSDB_DATA_TYPE_NULL == pExpr->resType.type) {




444,468,941✔





666



      pExpr->resType.type = TSDB_DATA_TYPE_VARCHAR;




20,822✔





667



      pExpr->resType.bytes = VARSTR_HEADER_SIZE;




20,822✔





668



    }










669



  }










670



}




85,739,213✔





671












672



static void resetProjectNullType(SNode* pStmt) {




164,746,149✔





673



  switch (nodeType(pStmt)) {




164,746,149✔





674



    case QUERY_NODE_SELECT_STMT:




84,094,358✔





675



      resetProjectNullTypeImpl(((SSelectStmt*)pStmt)->pProjectionList);




84,094,358✔





676



      break;




84,093,160✔





677



    case QUERY_NODE_SET_OPERATOR: {




1,648,109✔





678



      SSetOperator* pSetOp = (SSetOperator*)pStmt;




1,648,109✔





679



      resetProjectNullTypeImpl(pSetOp->pProjectionList);




1,648,109✔





680



      if (pSetOp->pLeft)




1,645,828✔





681



        resetProjectNullType(pSetOp->pLeft);




1,645,828✔





682



      if (pSetOp->pRight)




1,645,828✔





683



        resetProjectNullType(pSetOp->pRight);




1,645,828✔





684



      break;




1,645,828✔





685



    }










686



    default:




79,006,239✔





687



      break;




79,006,239✔





688



  }










689



}




164,745,227✔





690












691



int32_t calculateConstant(SParseContext* pParseCxt, SQuery* pQuery) {




161,460,658✔





692



  SCalcConstContext cxt = {.pParseCxt = pParseCxt,




161,460,658✔





693



                           .msgBuf.buf = pParseCxt->pMsg,




161,453,518✔





694



                           .msgBuf.len = pParseCxt->msgLen,




161,464,181✔





695



                           .code = TSDB_CODE_SUCCESS};










696












697



  int32_t code = calcConstQuery(&cxt, pQuery->pRoot, false);




161,454,051✔





698



  if (TSDB_CODE_SUCCESS == code) {




161,460,002✔





699



    resetProjectNullType(pQuery->pRoot);




161,456,637✔





700



    if (isEmptyResultQuery(pQuery->pRoot)) {




161,451,063✔





701



      pQuery->execMode = QUERY_EXEC_MODE_EMPTY_RESULT;




377,131✔





702



    }










703



  }










704



  return code;




161,446,373✔





705



}
























    

  • 

    •