taosdata / TDengine / #5038

coverage: 73.151% (-0.008%) from 73.159%
#5038

push

travis-ci

web-flow 
feat(statewindow): support multi columns (#35136)

1554 of 1828 new or added lines in 18 files covered. (85.01%)

7333 existing lines in 152 files now uncovered.

277490 of 379338 relevant lines covered (73.15%)

134410214.73 hits per line

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

82.92
/source/libs/function/src/functionMgt.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












18



#include "builtins.h"










19



#include "builtinsimpl.h"










20



#include "functionMgtInt.h"










21



#include "nodes.h"










22



#include "querynodes.h"










23



#include "taos.h"










24



#include "taoserror.h"










25



#include "thash.h"










26



#include "tudf.h"










27












28



typedef struct SFuncMgtService {










29



  SHashObj* pFuncNameHashTable;










30



} SFuncMgtService;










31












32



static SFuncMgtService gFunMgtService;










33



static TdThreadOnce    functionHashTableInit = PTHREAD_ONCE_INIT;










34



static int32_t         initFunctionCode = 0;










35












36



static void InitSpecialFuncId() {




1,546,142✔





37



  // just to make sure the funcId of these functions are initialized before used.










38



  (void)fmGetTwstartFuncId();




1,546,142✔





39



  (void)fmGetTwendFuncId();




1,546,142✔





40



  (void)fmGetTwdurationFuncId();




1,546,142✔





41



  (void)fmGetExternalWindowColumnFuncId();




1,546,142✔





42



}




1,546,142✔





43












44



static void doInitFunctionTable() {




1,546,142✔





45



  gFunMgtService.pFuncNameHashTable =




1,546,142✔





46



      taosHashInit(funcMgtBuiltinsNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);




1,546,142✔





47



  if (NULL == gFunMgtService.pFuncNameHashTable) {




1,546,142✔





48



    initFunctionCode = terrno;




×







49



    return;




×







50



  }










51












52



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




360,251,086✔





53



    if (TSDB_CODE_SUCCESS != taosHashPut(gFunMgtService.pFuncNameHashTable, funcMgtBuiltins[i].name,




358,704,944✔





54



                                         strlen(funcMgtBuiltins[i].name), &i, sizeof(int32_t))) {




358,704,944✔





55



      initFunctionCode = terrno;




×







56



      return;




×







57



    }










58



  }










59



  InitSpecialFuncId();




1,546,142✔





60



}










61












62



static bool isSpecificClassifyFunc(int32_t funcId, uint64_t classification) {




2,147,483,647✔





63



  if (fmIsUserDefinedFunc(funcId)) {




2,147,483,647✔





64



    return FUNC_MGT_AGG_FUNC == classification










65



               ? FUNC_AGGREGATE_UDF_ID == funcId










66



               : (FUNC_MGT_SCALAR_FUNC == classification ? FUNC_SCALAR_UDF_ID == funcId : false);




9,012,439✔





67



  }










68



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




2,147,483,647✔





69



    return false;




2,147,483,647✔





70



  }










71



  return FUNC_MGT_TEST_MASK(funcMgtBuiltins[funcId].classification, classification);




2,147,483,647✔





72



}










73












74



int32_t fmFuncMgtInit() {




1,546,142✔





75



  (void)taosThreadOnce(&functionHashTableInit, doInitFunctionTable);




1,546,142✔





76



  return initFunctionCode;




1,546,142✔





77



}










78












79



int32_t fmGetFuncInfo(SFunctionNode* pFunc, char* pMsg, int32_t msgLen) {




863,582,171✔





80



  if (NULL != gFunMgtService.pFuncNameHashTable) {




863,582,171✔





81



    void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, pFunc->functionName, strlen(pFunc->functionName));




863,419,610✔





82



    if (NULL != pVal) {




863,448,517✔





83



      pFunc->funcId = *(int32_t*)pVal;




863,240,049✔





84



      pFunc->funcType = funcMgtBuiltins[pFunc->funcId].type;




863,238,891✔





85



      return funcMgtBuiltins[pFunc->funcId].translateFunc(pFunc, pMsg, msgLen);




863,237,637✔





86



    }










87



    return TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION;




208,468✔





88



  }










89



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




3,309,716✔





90



    if (0 == strcmp(funcMgtBuiltins[i].name, pFunc->functionName)) {




3,309,392✔





91



      pFunc->funcId = i;




177,856✔





92



      pFunc->funcType = funcMgtBuiltins[pFunc->funcId].type;




177,856✔





93



      return funcMgtBuiltins[pFunc->funcId].translateFunc(pFunc, pMsg, msgLen);




177,856✔





94



    }










95



  }










96



  return TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION;




324✔





97



}










98












99



EFuncReturnRows fmGetFuncReturnRows(SFunctionNode* pFunc) {




18,155,693✔





100



  if (NULL != funcMgtBuiltins[pFunc->funcId].estimateReturnRowsFunc) {




18,155,693✔





101



    return funcMgtBuiltins[pFunc->funcId].estimateReturnRowsFunc(pFunc);




12,788,736✔





102



  }










103



  return (fmIsIndefiniteRowsFunc(pFunc->funcId) || fmIsMultiRowsFunc(pFunc->funcId)) ? FUNC_RETURN_ROWS_INDEFINITE




5,366,957✔





104



                                                                                     : FUNC_RETURN_ROWS_NORMAL;




5,366,957✔





105



}










106












107



bool canCoexistIndefiniteRowsFunc(int32_t funcId1, int32_t funcId2) {




183,001✔





108



  if (fmIsUserDefinedFunc(funcId1) || funcId1 < 0 || funcId1 >= funcMgtBuiltinsNum ||




366,002✔





109



      fmIsUserDefinedFunc(funcId2) || funcId2 < 0 || funcId2 >= funcMgtBuiltinsNum) {




366,002✔





110



    return false;




×







111



  }










112



  if (funcId1 == funcId2) {




183,001✔





113



    return true;




167,273✔





114



  }










115



  if ((funcMgtBuiltins[funcId1].type == FUNCTION_TYPE_LAG || funcMgtBuiltins[funcId1].type == FUNCTION_TYPE_LEAD) &&




15,728✔





116



      (funcMgtBuiltins[funcId2].type == FUNCTION_TYPE_LAG || funcMgtBuiltins[funcId2].type == FUNCTION_TYPE_LEAD)) {




15,275✔





117



    return true;




15,275✔





118



  }










119



  return false;




453✔





120



}










121












122



bool fmIsBuiltinFunc(const char* pFunc) {




16,735✔





123



  return NULL != taosHashGet(gFunMgtService.pFuncNameHashTable, pFunc, strlen(pFunc));




16,735✔





124



}










125












126



EFunctionType fmGetFuncType(const char* pFunc) {




626,242,093✔





127



  void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, pFunc, strlen(pFunc));




626,242,093✔





128



  if (NULL != pVal) {




626,257,805✔





129



    return funcMgtBuiltins[*(int32_t*)pVal].type;




626,046,476✔





130



  }










131



  return FUNCTION_TYPE_UDF;




211,329✔





132



}










133












134



EFunctionType fmGetFuncTypeFromId(int32_t funcId) {




24,318,367✔





135



  if (funcId >= 0 && funcId < funcMgtBuiltinsNum) {




24,318,367✔





136



    return funcMgtBuiltins[funcId].type;




24,317,595✔





137



  }










138



  return FUNCTION_TYPE_UDF;




772✔





139



}










140












141



EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow) {




41,725,744✔





142



  if (fmIsUserDefinedFunc(pFunc->funcId) || pFunc->funcId < 0 || pFunc->funcId >= funcMgtBuiltinsNum) {




41,725,744✔





143



    return FUNC_DATA_REQUIRED_DATA_LOAD;




×







144



  }










145



  if (NULL == funcMgtBuiltins[pFunc->funcId].dataRequiredFunc) {




41,732,635✔





146



    return FUNC_DATA_REQUIRED_DATA_LOAD;




×







147



  }










148



  return funcMgtBuiltins[pFunc->funcId].dataRequiredFunc(pFunc, pTimeWindow);




41,732,355✔





149



}










150












151



EFuncDataRequired fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo) {




2,147,483,647✔





152



  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {




2,147,483,647✔





153



    return FUNC_DATA_REQUIRED_DATA_LOAD;




150✔





154



  }










155












156



  const char* name = funcMgtBuiltins[funcId].name;




2,147,483,647✔





157



  if ((strcmp(name, "_group_key") == 0) || (strcmp(name, "_select_value") == 0)) {




2,147,483,647✔





158



    return FUNC_DATA_REQUIRED_NOT_LOAD;




607,449✔





159



    ;










160



  }










161












162



  if (funcMgtBuiltins[funcId].dynDataRequiredFunc == NULL) {




2,147,483,647✔





163



    return FUNC_DATA_REQUIRED_DATA_LOAD;




193,290,823✔





164



  } else {










165



    return funcMgtBuiltins[funcId].dynDataRequiredFunc(pRes, pBlockInfo);




2,147,483,647✔





166



  }










167



}










168












169



int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {




326,052,060✔





170



  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {




326,052,060✔





171



    return TSDB_CODE_FAILED;




46,149✔





172



  }










173



  pFpSet->getEnv = funcMgtBuiltins[funcId].getEnvFunc;




326,007,248✔





174



  pFpSet->init = funcMgtBuiltins[funcId].initFunc;




325,989,975✔





175



  pFpSet->process = funcMgtBuiltins[funcId].processFunc;




326,008,389✔





176



  pFpSet->finalize = funcMgtBuiltins[funcId].finalizeFunc;




325,992,400✔





177



  pFpSet->combine = funcMgtBuiltins[funcId].combineFunc;




325,996,943✔





178



  pFpSet->processFuncByRow = funcMgtBuiltins[funcId].processFuncByRow;




325,999,229✔





179



  pFpSet->cleanup = funcMgtBuiltins[funcId].cleanupFunc;




326,055,381✔





180



  return TSDB_CODE_SUCCESS;




326,014,854✔





181



}










182












183



int32_t fmGetUdafExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {




38,406✔





184



#ifdef USE_UDF










185



  if (!fmIsUserDefinedFunc(funcId)) {




38,406✔





186



    return TSDB_CODE_FAILED;




×







187



  }










188



  pFpSet->getEnv = udfAggGetEnv;




38,406✔





189



  pFpSet->init = udfAggInit;




38,406✔





190



  pFpSet->process = udfAggProcess;




38,406✔





191



  pFpSet->finalize = udfAggFinalize;




38,406✔





192



  return TSDB_CODE_SUCCESS;




38,406✔





193



#else










194



  TAOS_RETURN(TSDB_CODE_OPS_NOT_SUPPORT);










195



#endif










196



}










197












198



int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet) {




1,161,479,667✔





199



  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {




1,161,479,667✔





200



    return TSDB_CODE_FAILED;




91,673✔





201



  }










202



  pFpSet->process = funcMgtBuiltins[funcId].sprocessFunc;




1,161,636,430✔





203



  pFpSet->getEnv = funcMgtBuiltins[funcId].getEnvFunc;




1,161,710,433✔





204



  return TSDB_CODE_SUCCESS;




1,161,777,588✔





205



}










206












207



bool fmIsAggFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_AGG_FUNC); }




2,147,483,647✔





208












209



bool fmIsScalarFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SCALAR_FUNC); }




2,147,483,647✔





210












211



bool fmIsVectorFunc(int32_t funcId) { return !fmIsScalarFunc(funcId) && !fmIsPseudoColumnFunc(funcId); }




1,337,551,202✔





212












213



bool fmIsSelectColsFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SELECT_COLS_FUNC); }




156,550,546✔





214












215



bool fmIsSelectFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SELECT_FUNC); }




1,994,991,212✔





216












217



bool fmIsTimelineFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_TIMELINE_FUNC); }




1,206,052,222✔





218












219



bool fmIsDateTimeFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_DATETIME_FUNC); }




609,942,484✔





220












221



bool fmIsPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_PSEUDO_COLUMN_FUNC); }




2,147,483,647✔





222












223



bool fmIsScanPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SCAN_PC_FUNC); }




2,147,483,647✔





224












225



bool fmIsWindowPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_WINDOW_PC_FUNC); }




1,512,661,171✔





226












227



bool fmIsWindowClauseFunc(int32_t funcId) { return fmIsAggFunc(funcId) || fmIsWindowPseudoColumnFunc(funcId); }




61,822,385✔





228












229



bool fmIsWindowIndefRowsFunc(int32_t funcId) { return fmIsVectorFunc(funcId) || fmIsWindowPseudoColumnFunc(funcId); }




405,394✔





230












231



bool fmIsStreamWindowClauseFunc(int32_t funcId) { return fmIsWindowClauseFunc(funcId) || fmIsPlaceHolderFunc(funcId); }




1,140,435✔





232












233



bool fmIsStreamVectorFunc(int32_t funcId) { return fmIsVectorFunc(funcId) || fmIsPlaceHolderFunc(funcId); }




10,811✔





234












235



bool fmIsIndefiniteRowsFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_INDEFINITE_ROWS_FUNC); }




1,643,219,562✔





236












237



bool fmIsSpecialDataRequiredFunc(int32_t funcId) {




94,625,037✔





238



  return isSpecificClassifyFunc(funcId, FUNC_MGT_SPECIAL_DATA_REQUIRED);




94,625,037✔





239



}










240












241



bool fmIsDynamicScanOptimizedFunc(int32_t funcId) {




45,452,025✔





242



  return isSpecificClassifyFunc(funcId, FUNC_MGT_DYNAMIC_SCAN_OPTIMIZED);




45,452,025✔





243



}










244












245



bool fmIsMultiResFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_MULTI_RES_FUNC); }




1,242,430,184✔





246












247



bool fmIsRepeatScanFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_REPEAT_SCAN_FUNC); }




1,219,183,569✔





248












249



bool fmIsUserDefinedFunc(int32_t funcId) { return funcId > FUNC_UDF_ID_START; }




2,147,483,647✔





250












251



bool fmIsForbidFillFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_FORBID_FILL_FUNC); }




610,231,628✔





252












253



bool fmIsIntervalInterpoFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_INTERVAL_INTERPO_FUNC); }




65,839,935✔





254












255



bool fmIsSystemInfoFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SYSTEM_INFO_FUNC); }




613,307,485✔





256












257



bool fmIsImplicitTsFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_IMPLICIT_TS_FUNC); }




2,147,483,647✔





258












259



bool fmIsClientPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_CLIENT_PC_FUNC); }




621,050,943✔





260












261



bool fmIsMultiRowsFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_MULTI_ROWS_FUNC); }




1,215,744,552✔





262












263



static bool fmIsKeepOrderFuncId(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_KEEP_ORDER_FUNC); }




730,652,726✔





264












265



bool fmIsKeepOrderFunc(SFunctionNode* pFunc) {




737,113,766✔





266



  if (pFunc->funcType == FUNCTION_TYPE_TOP || pFunc->funcType == FUNCTION_TYPE_BOTTOM ||




737,113,766✔





267



      pFunc->funcType == FUNCTION_TYPE_SAMPLE) {




733,046,384✔





268



    if (pFunc->pParameterList != NULL && pFunc->pParameterList->length >= 2) {




6,485,137✔





269



      SNode* pParam = nodesListGetNode(pFunc->pParameterList, 1);




6,497,089✔





270



      if (pParam != NULL && nodeType(pParam) == QUERY_NODE_VALUE) {




6,497,089✔





271



        SValueNode* pConst = (SValueNode*)pParam;




6,497,089✔





272



        if (pConst->datum.i == 1) {




6,497,089✔





273



          return true;




766,361✔





274



        }










275



      }










276



    }










277



    return false;




5,720,954✔





278



  }










279



  return fmIsKeepOrderFuncId(pFunc->funcId);




730,675,749✔





280



}










281












282



bool fmIsCumulativeFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_CUMULATIVE_FUNC); }




159,084,643✔





283












284



bool fmIsForbidSysTableFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_FORBID_SYSTABLE_FUNC); }




610,125,781✔





285












286



bool fmIsInterpFunc(int32_t funcId) {




1,249,591,791✔





287



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




1,249,591,791✔





288



    return false;




387,935✔





289



  }










290



  return FUNCTION_TYPE_INTERP == funcMgtBuiltins[funcId].type;




1,249,206,483✔





291



}










292












293



bool fmIsInterpPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_INTERP_PC_FUNC); }




1,230,481,222✔





294












295



bool fmIsForecastFunc(int32_t funcId) {




1,199,947,069✔





296



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




1,199,947,069✔





297



    return false;




390,533✔





298



  }










299



  return FUNCTION_TYPE_FORECAST == funcMgtBuiltins[funcId].type;




1,199,559,279✔





300



}










301












302



bool fmIsAnalysisPseudoColumnFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_ANALYTICS_PC_FUNC); }




1,233,384,574✔





303












304



bool fmIsImputationCorrelationFunc(int32_t funcId) {




×







305



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




×







306



    return false;




×







307



  }










308












309



  int32_t type = funcMgtBuiltins[funcId].type;




×







310



  return FUNCTION_TYPE_IMPUTATION == type || FUNCTION_TYPE_DTW == type || FUNCTION_TYPE_DTW_PATH == type ||




×







311



         FUNCTION_TYPE_TLCC == type;










312



}










313












314



bool fmIsLastRowFunc(int32_t funcId) {




72,023,712✔





315



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




72,023,712✔





316



    return false;




×







317



  }










318



  return FUNCTION_TYPE_LAST_ROW == funcMgtBuiltins[funcId].type;




72,024,015✔





319



}










320












321



bool fmIsLastFunc(int32_t funcId) {




12,940✔





322



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




12,940✔





323



    return false;




×







324



  }










325



  return FUNCTION_TYPE_LAST == funcMgtBuiltins[funcId].type;




12,940✔





326



}










327












328



bool fmIsNotNullOutputFunc(int32_t funcId) {




489,417,578✔





329



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




489,417,578✔





330



    return false;




88,764✔





331



  }










332



  return FUNCTION_TYPE_LAST == funcMgtBuiltins[funcId].type ||




489,339,459✔





333



         FUNCTION_TYPE_CACHE_LAST == funcMgtBuiltins[funcId].type ||




471,354,623✔





334



         FUNCTION_TYPE_LAST_PARTIAL == funcMgtBuiltins[funcId].type ||




470,027,549✔





335



         FUNCTION_TYPE_LAST_MERGE == funcMgtBuiltins[funcId].type ||




460,823,955✔





336



         FUNCTION_TYPE_FIRST == funcMgtBuiltins[funcId].type ||




457,135,678✔





337



         FUNCTION_TYPE_FIRST_PARTIAL == funcMgtBuiltins[funcId].type ||




445,103,751✔





338



         FUNCTION_TYPE_FIRST_MERGE == funcMgtBuiltins[funcId].type ||




439,498,170✔





339



         FUNCTION_TYPE_COUNT == funcMgtBuiltins[funcId].type ||




437,452,565✔





340



         FUNCTION_TYPE_HYPERLOGLOG == funcMgtBuiltins[funcId].type ||




380,441,678✔





341



         FUNCTION_TYPE_HYPERLOGLOG_PARTIAL == funcMgtBuiltins[funcId].type ||




1,337,171,013✔





342



         FUNCTION_TYPE_HYPERLOGLOG_MERGE == funcMgtBuiltins[funcId].type;




376,379,923✔





343



}










344












345



bool fmIsSelectValueFunc(int32_t funcId) {




366,968,299✔





346



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




366,968,299✔





347



    return false;




×







348



  }










349



  return FUNCTION_TYPE_SELECT_VALUE == funcMgtBuiltins[funcId].type;




366,970,007✔





350



}










351












352



bool fmIsGroupKeyFunc(int32_t funcId) {




284,692,856✔





353



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




284,692,856✔





354



    return false;




160✔





355



  }










356



  return FUNCTION_TYPE_GROUP_KEY == funcMgtBuiltins[funcId].type;




284,693,991✔





357



}










358












359



bool fmIsHasNullFunc(int32_t funcId) {




×







360



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




×







361



    return false;




×







362



  }










363



  return FUNCTION_TYPE_HAS_NULL == funcMgtBuiltins[funcId].type;




×







364



}










365












366



bool fmisSelectGroupConstValueFunc(int32_t funcId) {




18,077,141✔





367



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




18,077,141✔





368



    return false;




×







369



  }










370



  return FUNCTION_TYPE_GROUP_CONST_VALUE == funcMgtBuiltins[funcId].type;




18,077,141✔





371



}










372












373



bool fmIsElapsedFunc(int32_t funcId) {




11,143,111✔





374



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




11,143,111✔





375



    return false;




×







376



  }










377



  return FUNCTION_TYPE_ELAPSED == funcMgtBuiltins[funcId].type;




11,143,111✔





378



}










379












380



bool fmIsBlockDistFunc(int32_t funcId) {




609,926,048✔





381



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




609,926,048✔





382



    return false;




195,570✔





383



  }










384



  return FUNCTION_TYPE_BLOCK_DIST == funcMgtBuiltins[funcId].type;




609,731,646✔





385



}










386












387



bool fmIsDBUsageFunc(int32_t funcId) {




609,936,551✔





388



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




609,936,551✔





389



    return false;




185,560✔





390



  }










391



  return FUNCTION_TYPE_DB_USAGE == funcMgtBuiltins[funcId].type;




609,754,964✔





392



}










393












394



bool fmIsProcessByRowFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_PROCESS_BY_ROW); }




829,433,962✔





395












396



bool fmIsVolatileFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_VOLATILE_FUNC); }




907,495,177✔





397












398



bool fmIsNoPushdownFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_NO_PUSHDOWN_FUNC); }




43,143,889✔





399












400



bool fmIsIgnoreNullFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_IGNORE_NULL_FUNC); }




265,366✔





401












402



void fmFuncMgtDestroy() {




1,546,185✔





403



  void* m = gFunMgtService.pFuncNameHashTable;




1,546,185✔





404



  if (m != NULL && atomic_val_compare_exchange_ptr((void**)&gFunMgtService.pFuncNameHashTable, m, 0) == m) {




1,546,185✔





405



    taosHashCleanup(m);




1,546,142✔





406



  }










407



}




1,546,185✔





408












409



#ifdef BUILD_NO_CALL










410



int32_t fmSetNormalFunc(int32_t funcId, SFuncExecFuncs* pFpSet) {










411



  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {










412



    return TSDB_CODE_FAILED;










413



  }










414



  pFpSet->process = funcMgtBuiltins[funcId].processFunc;










415



  return TSDB_CODE_SUCCESS;










416



}










417



#endif










418












419



// function has same input/output type










420



bool fmIsSameInOutType(int32_t funcId) {




50,896,793✔





421



  bool res = false;




50,896,793✔





422



  switch (funcMgtBuiltins[funcId].type) {




50,896,793✔





423



    case FUNCTION_TYPE_MAX:




20,129,384✔





424



    case FUNCTION_TYPE_MIN:










425



    case FUNCTION_TYPE_TOP:










426



    case FUNCTION_TYPE_BOTTOM:










427



    case FUNCTION_TYPE_FIRST:










428



    case FUNCTION_TYPE_LAST:










429



    case FUNCTION_TYPE_SAMPLE:










430



    case FUNCTION_TYPE_TAIL:










431



    case FUNCTION_TYPE_UNIQUE:










432



      res = true;




20,129,384✔





433



      break;




20,129,384✔





434



    default:




30,767,409✔





435



      break;




30,767,409✔





436



  }










437



  return res;




50,896,793✔





438



}










439












440



bool fmIsConstantResFunc(SFunctionNode* pFunc) {




15,084,065✔





441



  SNode* pNode;










442



  FOREACH(pNode, pFunc->pParameterList) {




15,172,361✔





443



    if (nodeType(pNode) != QUERY_NODE_VALUE) {




205,786✔





444



      return false;




117,490✔





445



    }










446



  }










447



  return true;




14,966,575✔





448



}










449












450



bool fmIsSkipScanCheckFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_SKIP_SCAN_CHECK_FUNC); }




45,447,003✔





451












452



bool fmIsPrimaryKeyFunc(int32_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_PRIMARY_KEY_FUNC); }




532,359,935✔





453












454



bool fmIsPlaceHolderFunc(int32_t funcId) {return isSpecificClassifyFunc(funcId, FUNC_MGT_PLACE_HOLDER_FUNC); }




2,147,483,647✔





455












456



bool fmIsPlaceHolderFuncForExternalWin(int32_t funcId) {




694,214✔





457



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




694,214✔





458



    return false;




×







459



  }










460



  return (funcMgtBuiltins[funcId].type == FUNCTION_TYPE_WSTART || funcMgtBuiltins[funcId].type == FUNCTION_TYPE_WEND ||




1,165,499✔





461



          funcMgtBuiltins[funcId].type == FUNCTION_TYPE_WDURATION);




471,285✔





462



}










463












464



void getLastCacheDataType(SDataType* pType, int32_t pkBytes) {




×







465



  // TODO: do it later.










466



  pType->bytes = getFirstLastInfoSize(pType->bytes, pkBytes) + VARSTR_HEADER_SIZE;




×







467



  pType->type = TSDB_DATA_TYPE_BINARY;




×







468



}




×







469












470



static int32_t getFuncInfo(SFunctionNode* pFunc) {




162,616,312✔





471



  char msg[128] = {0};




162,616,312✔





472



  return fmGetFuncInfo(pFunc, msg, sizeof(msg));




162,616,312✔





473



}










474












475



int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** ppFunc) {




10,325,918✔





476



  int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)ppFunc);




10,325,918✔





477



  if (NULL == *ppFunc) {




10,325,918✔





478



    return code;




×







479



  }










480



  (void)snprintf((*ppFunc)->functionName, sizeof((*ppFunc)->functionName), "%s", pName);




10,325,918✔





481



  (*ppFunc)->pParameterList = pParameterList;




10,325,918✔





482



  code = getFuncInfo((*ppFunc));




10,325,918✔





483



  if (TSDB_CODE_SUCCESS != code) {




10,325,918✔





484



    (*ppFunc)->pParameterList = NULL;




×







485



    nodesDestroyNode((SNode*)*ppFunc);




×







486



    *ppFunc = NULL;




×







487



    return code;




×







488



  }










489



  return code;




10,325,918✔





490



}










491












492



static void resetOutputChangedFunc(SFunctionNode *pFunc, const SFunctionNode* pSrcFunc) {




152,292,467✔





493



  if (funcMgtBuiltins[pFunc->funcId].type == FUNCTION_TYPE_LAST_MERGE) {




152,292,467✔





494



    pFunc->node.resType = pSrcFunc->node.resType;




23,903,755✔





495



    return;




23,903,755✔





496



  }










497



}










498












499



int32_t createFunctionWithSrcFunc(const char* pName, const SFunctionNode* pSrcFunc, SNodeList* pParameterList, SFunctionNode** ppFunc) {




152,289,603✔





500



  int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)ppFunc);




152,289,603✔





501



  if (NULL == *ppFunc) {




152,298,038✔





502



    return code;




×







503



  }










504












505



  (*ppFunc)->hasPk = pSrcFunc->hasPk;




152,298,038✔





506



  (*ppFunc)->pkBytes = pSrcFunc->pkBytes;




152,298,038✔





507



  (*ppFunc)->pSrcFuncRef = pSrcFunc;




152,298,038✔





508












509



  (void)snprintf((*ppFunc)->functionName, sizeof((*ppFunc)->functionName), "%s", pName);




152,297,995✔





510



  (*ppFunc)->pParameterList = pParameterList;




152,297,995✔





511



  code = getFuncInfo((*ppFunc));




152,298,038✔





512



  if (TSDB_CODE_SUCCESS != code) {




152,294,658✔





513



    (*ppFunc)->pParameterList = NULL;




×







514



    nodesDestroyNode((SNode*)*ppFunc);




×







515



    *ppFunc = NULL;




×







516



    return code;




×







517



  }










518



  resetOutputChangedFunc(*ppFunc, pSrcFunc);




152,294,658✔





519



  (*ppFunc)->node.relatedTo = pSrcFunc->node.relatedTo;




152,295,268✔





520



  (*ppFunc)->node.bindExprID = pSrcFunc->node.bindExprID;




152,295,268✔





521



  return code;




152,295,268✔





522



}










523












524



static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** ppCol) {




101,383,849✔





525



  int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)ppCol);




101,383,849✔





526



  if (NULL == *ppCol) {




101,392,784✔





527



    return code;




×







528



  }










529



  tstrncpy((*ppCol)->colName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);




101,392,784✔





530



  (*ppCol)->node.resType = pFunc->node.resType;




101,392,784✔





531



  return TSDB_CODE_SUCCESS;




101,392,784✔





532



}










533












534



bool fmIsDistExecFunc(int32_t funcId) {




385,208,107✔





535



  if (fmIsUserDefinedFunc(funcId)) {




385,208,107✔





536



    return false;




106,893✔





537



  }










538



  if (!fmIsVectorFunc(funcId)) {




385,132,640✔





539



    return true;




507,052✔





540



  }










541



  return (NULL != funcMgtBuiltins[funcId].pPartialFunc && NULL != funcMgtBuiltins[funcId].pMergeFunc);




384,635,745✔





542



}










543












544



static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNode** pPartialFunc) {




50,898,738✔





545



  SNodeList* pParameterList = NULL;




50,898,738✔





546



  int32_t    code = nodesCloneList(pSrcFunc->pParameterList, &pParameterList);




50,898,738✔





547



  if (NULL == pParameterList) {




50,901,816✔





548



    return code;




×







549



  }










550



  code =










551



      createFunctionWithSrcFunc(funcMgtBuiltins[pSrcFunc->funcId].pPartialFunc, pSrcFunc, pParameterList, pPartialFunc);




50,901,816✔





552



  if (TSDB_CODE_SUCCESS != code) {




50,900,100✔





553



    nodesDestroyList(pParameterList);




×







554



    return code;




×







555



  }










556



  (*pPartialFunc)->hasOriginalFunc = true;




50,900,825✔





557



  (*pPartialFunc)->originalFuncId = pSrcFunc->hasOriginalFunc ? pSrcFunc->originalFuncId : pSrcFunc->funcId;




50,900,825✔





558



  char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};




50,900,868✔





559












560



  int32_t len = snprintf(name, sizeof(name), "%s.%p", (*pPartialFunc)->functionName, pSrcFunc);




50,900,868✔





561



  if (taosHashBinary(name, len, sizeof(name)) < 0) {




50,901,887✔





562



    return TSDB_CODE_FAILED;




×







563



  }










564



  tstrncpy((*pPartialFunc)->node.aliasName, name, TSDB_COL_NAME_LEN);




50,901,887✔





565



  return TSDB_CODE_SUCCESS;




50,901,887✔





566



}










567












568



static int32_t createMergeFuncPara(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,




101,383,375✔





569



                                   SNodeList** pParameterList) {










570



  SNode*  pRes = NULL;




101,383,375✔





571



  int32_t code = createColumnByFunc(pPartialFunc, (SColumnNode**)&pRes);




101,383,375✔





572



  if (TSDB_CODE_SUCCESS != code) {




101,392,026✔





573



    return code;




×







574



  }










575



  if (NULL != funcMgtBuiltins[pSrcFunc->funcId].createMergeParaFuc) {




101,392,026✔





576



    return funcMgtBuiltins[pSrcFunc->funcId].createMergeParaFuc(pSrcFunc->pParameterList, pRes, pParameterList);




865,612✔





577



  } else {










578



    return nodesListMakeStrictAppend(pParameterList, pRes);




100,526,414✔





579



  }










580



}










581












582



static int32_t createMidFunction(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,




50,484,499✔





583



                                 SFunctionNode** pMidFunc) {










584



  SNodeList*     pParameterList = NULL;




50,484,499✔





585



  SFunctionNode* pFunc = NULL;




50,484,499✔





586












587



  int32_t code = createMergeFuncPara(pSrcFunc, pPartialFunc, &pParameterList);




50,484,499✔





588



  if (TSDB_CODE_SUCCESS == code) {




50,491,750✔





589



    if(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc != NULL){




50,491,915✔





590



      code = createFunctionWithSrcFunc(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc, pSrcFunc, pParameterList, &pFunc);




5,871,524✔





591



    }else{










592



      code = createFunctionWithSrcFunc(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pSrcFunc, pParameterList, &pFunc);




44,620,391✔





593



    }










594



  }










595



  if (TSDB_CODE_SUCCESS == code) {




50,491,711✔





596



    tstrncpy(pFunc->node.aliasName, pPartialFunc->node.aliasName, TSDB_COL_NAME_LEN);




50,490,539✔





597



  }










598












599



  if (TSDB_CODE_SUCCESS == code) {




50,491,711✔





600



    *pMidFunc = pFunc;




50,491,711✔





601



  } else {










602



    nodesDestroyList(pParameterList);




×







603



  }










604



  return code;




50,491,900✔





605



}










606












607



static int32_t createMergeFunction(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,




50,899,232✔





608



                                   SFunctionNode** pMergeFunc) {










609



  SNodeList*     pParameterList = NULL;




50,899,232✔





610



  SFunctionNode* pFunc = NULL;




50,899,232✔





611












612



  int32_t code = createMergeFuncPara(pSrcFunc, pPartialFunc, &pParameterList);




50,899,232✔





613



  if (TSDB_CODE_SUCCESS == code) {




50,902,432✔





614



    code = createFunctionWithSrcFunc(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pSrcFunc, pParameterList, &pFunc);




50,902,503✔





615



  }










616



  if (TSDB_CODE_SUCCESS == code) {




50,905,567✔





617



    pFunc->hasOriginalFunc = true;




50,902,597✔





618



    pFunc->originalFuncId = pSrcFunc->hasOriginalFunc ? pSrcFunc->originalFuncId : pSrcFunc->funcId;




50,902,597✔





619



    // overwrite function restype set by translate function










620



    if (fmIsSameInOutType(pSrcFunc->funcId)) {




50,902,597✔





621



      pFunc->node.resType = pSrcFunc->node.resType;




20,129,455✔





622



    }










623



    tstrncpy(pFunc->node.aliasName, pSrcFunc->node.aliasName, TSDB_COL_NAME_LEN);




50,897,646✔





624



  }










625












626



  if (TSDB_CODE_SUCCESS == code) {




50,900,573✔





627



    *pMergeFunc = pFunc;




50,900,573✔





628



  } else {










629



    nodesDestroyList(pParameterList);




×







630



  }










631



  return code;




50,900,825✔





632



}










633












634



int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMidFunc,




50,894,471✔





635



                        SFunctionNode** pMergeFunc) {










636



  if (!fmIsDistExecFunc(pFunc->funcId)) {




50,894,471✔





637



    return TSDB_CODE_FAILED;




×







638



  }










639












640



  int32_t code = createPartialFunction(pFunc, pPartialFunc);




50,902,791✔





641



  if (TSDB_CODE_SUCCESS == code && pMidFunc) {




50,898,864✔





642



    code = createMidFunction(pFunc, *pPartialFunc, pMidFunc);




50,491,252✔





643



  }










644



  if (TSDB_CODE_SUCCESS == code) {




50,899,512✔





645



    code = createMergeFunction(pFunc, *pPartialFunc, pMergeFunc);




50,902,464✔





646



  }










647












648



  if (TSDB_CODE_SUCCESS != code) {




50,895,134✔





649



    nodesDestroyNode((SNode*)*pPartialFunc);




×







650



    if (pMidFunc) nodesDestroyNode((SNode*)*pMidFunc);




×







651



    nodesDestroyNode((SNode*)*pMergeFunc);




×







652



  }










653












654



  return code;




50,899,744✔





655



}










656












657



const char* fmGetFuncName(int32_t funcId) {




348,314✔





658



  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {




348,314✔





659



    return "invalid function";




×







660



  }










661



  return funcMgtBuiltins[funcId].name;




348,314✔





662



}










663












664



/// @param [out] pStateFunc, not changed if error occured or no need to create state func










665



/// @retval 0 for succ, otherwise err occured










666



static int32_t fmCreateStateFunc(const SFunctionNode* pFunc, SFunctionNode** pStateFunc) {




6,644✔





667



  if (funcMgtBuiltins[pFunc->funcId].pStateFunc) {




6,644✔





668



    SNodeList* pParams = NULL;




6,644✔





669



    int32_t    code = nodesCloneList(pFunc->pParameterList, &pParams);




6,644✔





670



    if (!pParams) return code;




6,644✔





671



    code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc);




6,644✔





672



    if (TSDB_CODE_SUCCESS != code) {




6,644✔





673



      nodesDestroyList(pParams);




×







674



      return code;




×







675



    }










676



    tstrncpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);




6,644✔





677



    tstrncpy((*pStateFunc)->node.userAlias, pFunc->node.userAlias, TSDB_COL_NAME_LEN);




6,644✔





678



  }










679



  return TSDB_CODE_SUCCESS;




6,644✔





680



}










681












682



bool fmIsTSMASupportedFunc(func_id_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_TSMA_FUNC); }




1,097,965✔





683












684



bool fmIsRsmaSupportedFunc(func_id_t funcId) { return isSpecificClassifyFunc(funcId, FUNC_MGT_RSMA_FUNC); }




139,586✔





685












686



int32_t fmCreateStateFuncs(SNodeList* pFuncs) {




2,937✔





687



  int32_t code;










688



  SNode*  pNode;










689



  char    buf[128] = {0};




2,937✔





690



  FOREACH(pNode, pFuncs) {




9,581✔





691



    SFunctionNode* pFunc = (SFunctionNode*)pNode;




6,644✔





692



    code = fmGetFuncInfo(pFunc, buf, 128);




6,644✔





693



    if (code) break;




6,644✔





694



    if (fmIsTSMASupportedFunc(pFunc->funcId)) {




6,644✔





695



      SFunctionNode* pNewFunc = NULL;




6,644✔





696



      code = fmCreateStateFunc(pFunc, &pNewFunc);




6,644✔





697



      if (code) {




6,644✔





698



        // error










699



        break;




×







700



      } else if (!pNewFunc) {




6,644✔





701



        // no need state func










702



        continue;




×







703



      } else {










704



        REPLACE_NODE(pNewFunc);




6,644✔





705



        nodesDestroyNode(pNode);




6,644✔





706



      }










707



    }










708



  }










709



  return code;




2,937✔





710



}










711












712



static int32_t fmCreateStateMergeFunc(SFunctionNode* pFunc, SFunctionNode** pStateMergeFunc) {




1,452✔





713



  if (funcMgtBuiltins[pFunc->funcId].pMergeFunc) {




1,452✔





714



    SNodeList* pParams = NULL;




1,188✔





715



    int32_t    code = nodesCloneList(pFunc->pParameterList, &pParams);




1,188✔





716



    if (!pParams) return code;




1,188✔





717



    code = createFunctionWithSrcFunc(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pFunc, pParams, pStateMergeFunc);




1,188✔





718



    if (TSDB_CODE_SUCCESS != code) {




1,188✔





719



      nodesDestroyList(pParams);




×







720



      return code;




×







721



    }










722



    tstrncpy((*pStateMergeFunc)->node.aliasName, pFunc->node.aliasName, TSDB_COL_NAME_LEN);




1,188✔





723



    tstrncpy((*pStateMergeFunc)->node.userAlias, pFunc->node.userAlias, TSDB_COL_NAME_LEN);




1,188✔





724



  }










725



  return TSDB_CODE_SUCCESS;




1,452✔





726



}










727












728



int32_t fmCreateStateMergeFuncs(SNodeList* pFuncs) {




660✔





729



  int32_t code;










730



  SNode*  pNode;










731



  char    buf[128] = {0};




660✔





732



  FOREACH(pNode, pFuncs) {




2,112✔





733



    SFunctionNode* pFunc = (SFunctionNode*)pNode;




1,452✔





734



    if (fmIsTSMASupportedFunc(pFunc->funcId)) {




1,452✔





735



      SFunctionNode* pNewFunc = NULL;




1,452✔





736



      code = fmCreateStateMergeFunc(pFunc, &pNewFunc);




1,452✔





737



      if (code) {




1,452✔





738



        // error










739



        break;




×







740



      } else if (!pNewFunc) {




1,452✔





741



        // no state merge func










742



        continue;




264✔





743



      } else {










744



        REPLACE_NODE(pNewFunc);




1,188✔





745



        nodesDestroyNode(pNode);




1,188✔





746



      }










747



    }










748



  }










749



  return code;




660✔





750



}










751












752



int32_t fmGetFuncId(const char* name) {




8,083,777✔





753



  if (NULL != gFunMgtService.pFuncNameHashTable) {




8,083,777✔





754



    void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, name, strlen(name));




8,083,777✔





755



    if (NULL != pVal) {




8,083,777✔





756



      return *(int32_t*)pVal;




8,083,777✔





757



    }










758



    return -1;




×







759



  }










760



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




×







761



    if (0 == strcmp(funcMgtBuiltins[i].name, name)) {




×







762



      return i;




×







763



    }










764



  }










765



  return -1;




×







766



}










767












768



int32_t fmGetTwstartFuncId() {




1,736,034✔





769



  static int32_t twstartFuncId = -2;










770



  if (twstartFuncId < 0) {




1,736,034✔





771



    twstartFuncId = fmGetFuncId("_twstart");




1,546,142✔





772



  }










773



  return twstartFuncId;




1,736,034✔





774



}










775












776



int32_t fmGetTwendFuncId() {




1,579,179✔





777



  static int32_t twendFuncId = -2;










778



  if (twendFuncId < 0) {




1,579,179✔





779



    twendFuncId = fmGetFuncId("_twend");




1,546,142✔





780



  }










781



  return twendFuncId;




1,579,179✔





782



}










783












784



int32_t fmGetTwdurationFuncId() {




1,546,568✔





785



  static int32_t twdurationFuncId = -2;










786



  if (twdurationFuncId < 0) {




1,546,568✔





787



    twdurationFuncId = fmGetFuncId("_twduration");




1,546,142✔





788



  }










789



  return twdurationFuncId;




1,546,568✔





790



}










791












792



int32_t fmGetExternalWindowColumnFuncId() {




1,591,457✔





793



  static int32_t externalWindowColumnFuncId = -2;










794



  if (externalWindowColumnFuncId < 0) {




1,591,457✔





795



    externalWindowColumnFuncId = fmGetFuncId("_external_window_column");




1,546,142✔





796



  }










797



  return externalWindowColumnFuncId;




1,591,457✔





798



}










799












800



bool fmIsMyStateFunc(int32_t funcId, int32_t stateFuncId) {




1,866,612✔





801



  const SBuiltinFuncDefinition* pFunc = &funcMgtBuiltins[funcId];




1,866,612✔





802



  const SBuiltinFuncDefinition* pStateFunc = &funcMgtBuiltins[stateFuncId];




1,866,612✔





803



  if (!pFunc->pStateFunc) {




1,866,612✔





804



    return false;




×







805



  }










806



  if (strcmp(pFunc->pStateFunc, pStateFunc->name) == 0) return true;




1,866,612✔





807



  int32_t stateMergeFuncId = fmGetFuncId(pFunc->pStateFunc);




690,228✔





808



  if (stateMergeFuncId == -1) {




690,228✔





809



    return false;




×







810



  }










811



  const SBuiltinFuncDefinition* pStateMergeFunc = &funcMgtBuiltins[stateMergeFuncId];




690,228✔





812



  return strcmp(pStateFunc->name, pStateMergeFunc->pMergeFunc) == 0;




690,228✔





813



}










814












815



bool fmIsCountLikeFunc(int32_t funcId) {




634,668,625✔





816



  return isSpecificClassifyFunc(funcId, FUNC_MGT_COUNT_LIKE_FUNC);




634,668,625✔





817



}










818












819



bool fmIsRowTsOriginFunc(int32_t funcId) {




5,459,120✔





820



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




5,459,120✔






UNCOV

821



    return false;




×







822



  }










823



  return FUNCTION_TYPE_IROWTS_ORIGIN == funcMgtBuiltins[funcId].type;




5,459,563✔





824



}










825












826



bool fmIsGroupIdFunc(int32_t funcId) {




2,403,528✔





827



  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {




2,403,528✔





828



    return false;




×







829



  }










830



  return FUNCTION_TYPE_GROUP_ID == funcMgtBuiltins[funcId].type;




2,403,528✔





831



}










832












833



const void* fmGetExternalWindowColumnFuncVal(const SStreamRuntimeFuncInfo* pStreamRuntimeFuncInfo, int32_t index) {




10,664,452✔





834



  SSTriggerCalcParam *pParams = taosArrayGet(pStreamRuntimeFuncInfo->pStreamPesudoFuncVals, pStreamRuntimeFuncInfo->curIdx);




10,664,452✔





835



  if (pParams == NULL || pParams->pExternalWindowData == NULL || index < 0) {




10,675,765✔





836



    return NULL;




×







837



  }










838



  return taosArrayGet(pParams->pExternalWindowData, index);




10,677,022✔





839



}










840












841



const void* fmGetStreamPesudoFuncVal(int32_t funcId, const SStreamRuntimeFuncInfo* pStreamRuntimeFuncInfo) {




393,432,731✔





842



  switch (funcMgtBuiltins[funcId].type) {




393,432,731✔





843



    case FUNCTION_TYPE_TGRPID:




144,408✔





844



      return &pStreamRuntimeFuncInfo->groupId;




144,408✔





845



    case FUNCTION_TYPE_PLACEHOLDER_COLUMN:




885,339✔





846



      return pStreamRuntimeFuncInfo->pStreamPartColVals;




885,339✔





847



    case FUNCTION_TYPE_PLACEHOLDER_TBNAME:




1,981,857✔





848



      return pStreamRuntimeFuncInfo->pStreamPartColVals;




1,981,857✔





849



    default:




390,484,069✔





850



      break;




390,484,069✔





851



  }










852












853



  SSTriggerCalcParam *pParams = taosArrayGet(pStreamRuntimeFuncInfo->pStreamPesudoFuncVals, pStreamRuntimeFuncInfo->curIdx);




390,484,069✔





854



  switch (funcMgtBuiltins[funcId].type) {




390,536,936✔





855



    case FUNCTION_TYPE_TPREV_TS:




×







856



      return &pParams->prevTs;




×







857



    case FUNCTION_TYPE_TCURRENT_TS:




2,069,605✔





858



      return &pParams->currentTs;




2,069,605✔





859



    case FUNCTION_TYPE_TNEXT_TS:




×







860



      return &pParams->nextTs;




×







861



    case FUNCTION_TYPE_TWSTART:




337,791,937✔





862



      return &pParams->wstart;




337,791,937✔





863



    case FUNCTION_TYPE_TWEND:




17,170,244✔





864



      return &pParams->wend;




17,170,244✔





865



    case FUNCTION_TYPE_TWDURATION:




975,143✔





866



      return &pParams->wduration;




975,143✔





867



    case FUNCTION_TYPE_TWROWNUM:




31,422,395✔





868



      return &pParams->wrownum;




31,422,395✔





869



    case FUNCTION_TYPE_TPREV_LOCALTIME:




165,650✔





870



      return &pParams->prevLocalTime;




165,650✔





871



    case FUNCTION_TYPE_TLOCALTIME:




613,155✔





872



      return &pParams->triggerTime;




613,155✔





873



    case FUNCTION_TYPE_TNEXT_LOCALTIME:




307,776✔





874



      return &pParams->nextLocalTime;




307,776✔





875



    case FUNCTION_TYPE_TGRPID:




×







876



      return &pStreamRuntimeFuncInfo->groupId;




×







877



    case FUNCTION_TYPE_PLACEHOLDER_COLUMN:




×







878



      return pStreamRuntimeFuncInfo->pStreamPartColVals;




×







879



    case FUNCTION_TYPE_PLACEHOLDER_TBNAME:




×







880



      return pStreamRuntimeFuncInfo->pStreamPartColVals;




×







881



    case FUNCTION_TYPE_TIDLESTART:




6,021✔





882



      return &pParams->idlestart;




6,021✔





883



    case FUNCTION_TYPE_TIDLEEND:




6,021✔





884



      return &pParams->idleend;




6,021✔





885



    default:




×







886



      break;




×







887



  }










888



  return NULL;




×







889



}










890












891



bool fmIsStreamPesudoColVal(int32_t funcId) {




502,973✔





892



  return funcMgtBuiltins[funcId].type == FUNCTION_TYPE_PLACEHOLDER_COLUMN




502,973✔





893



         || funcMgtBuiltins[funcId].type == FUNCTION_TYPE_PLACEHOLDER_TBNAME;




502,973✔





894



}










895












896



int32_t fmGetStreamPesudoFuncEnv(int32_t funcId, SNodeList* pParamNodes, SFuncExecEnv *pEnv) {




7,961,761✔





897



  if (NULL == pParamNodes || pParamNodes->length < 1) {




7,961,761✔





898



    uError("invalid stream pesudo func param list %p", pParamNodes);




885✔





899



    return TSDB_CODE_INTERNAL_ERROR;




×







900



  }










901












902



  int32_t firstParamType = nodeType(nodesListGetNode(pParamNodes, 0));




7,961,116✔





903



  if (QUERY_NODE_VALUE != firstParamType) {




7,962,412✔





904



    uError("invalid stream pesudo func first param type %d", firstParamType);




×







905



    return TSDB_CODE_INTERNAL_ERROR;




×







906



  }










907












908



  SValueNode* pResDesc = (SValueNode*)nodesListGetNode(pParamNodes, 0);




7,962,412✔





909



  pEnv->calcMemSize = pResDesc->node.resType.bytes;




7,962,892✔





910












911



  return TSDB_CODE_SUCCESS;




7,962,892✔





912



}










913












914












915



int32_t fmSetStreamPseudoFuncParamVal(int32_t funcId, SNodeList* pParamNodes, const SStreamRuntimeFuncInfo* pStreamRuntimeInfo) {




404,107,200✔





916



  if (!pStreamRuntimeInfo) {




404,107,200✔





917



    uError("internal error, should have pVals for stream pseudo funcs");




×







918



    return TSDB_CODE_INTERNAL_ERROR;




×







919



  }










920



  int32_t code = 0;




404,107,200✔





921



  SArray *pVals1 = NULL;




404,107,200✔





922



  SNode* pFirstParam = nodesListGetNode(pParamNodes, 0);




404,107,200✔





923



  if (nodeType(pFirstParam) != QUERY_NODE_VALUE) {




404,155,710✔





924



    uError("invalid param node type: %d for func: %d", nodeType(pFirstParam), funcId);




×







925



    return TSDB_CODE_INTERNAL_ERROR;




×







926



  }










927












928



  int32_t t = funcMgtBuiltins[funcId].type;




404,121,474✔





929



  uDebug("set stream pseudo func param val, functype: %d, pStreamRuntimeInfo: %p", t, pStreamRuntimeInfo);




404,157,604✔





930



  if (FUNCTION_TYPE_TGRPID == t) {




404,101,024✔





931



    SValue v = {0};




144,408✔





932



    v.type = TSDB_DATA_TYPE_BIGINT;




144,408✔





933



    v.val = *(int64_t*)fmGetStreamPesudoFuncVal(funcId, pStreamRuntimeInfo);




144,408✔





934



    










935



    code = nodesSetValueNodeValue((SValueNode*)pFirstParam, VALUE_GET_DATUM(&v, pFirstParam->type));




144,408✔





936



    if (code != 0) {




144,408✔





937



      uError("failed to set value node value: %s", tstrerror(code));




×







938



      return code;




×







939



    }










940



  } else if (FUNCTION_TYPE_PLACEHOLDER_COLUMN == t) {




403,956,616✔





941



    SNode* pSecondParam = nodesListGetNode(pParamNodes, 1);




885,586✔





942



    if (nodeType(pSecondParam) != QUERY_NODE_VALUE) {




885,586✔





943



      uError("invalid param node type: %d for func: %d", nodeType(pSecondParam), funcId);




×







944



      return TSDB_CODE_INTERNAL_ERROR;




×







945



    }










946



    SArray* pVal = (SArray*)fmGetStreamPesudoFuncVal(funcId, pStreamRuntimeInfo);




885,586✔





947



    int32_t idx = ((SValueNode*)pSecondParam)->datum.i;




885,339✔





948



    if (idx - 1 < 0 || idx - 1 >= taosArrayGetSize(pVal)) {




885,586✔





949



      uError("invalid idx: %d for func: %d, should be in [1, %d]", idx, funcId, (int32_t)taosArrayGetSize(pVal));




208✔





950



      return TSDB_CODE_INTERNAL_ERROR;




×







951



    }










952



    SStreamGroupValue* pValue = taosArrayGet(pVal, idx - 1);




885,378✔





953



    if (pValue == NULL) {




885,586✔





954



      uError("invalid idx: %d for func: %d, should be in [1, %d]", idx, funcId, (int32_t)taosArrayGetSize(pVal));




×







955



      return TSDB_CODE_INTERNAL_ERROR;




×







956



    }










957



    if (!pValue->isNull){




885,586✔





958



      if (pValue->data.type != ((SValueNode*)pFirstParam)->node.resType.type){




878,866✔





959



        uError("invalid value type: %d for func: %d, should be: %d", pValue->data.type, funcId, ((SValueNode*)pFirstParam)->node.resType.type);




×







960



        return TSDB_CODE_INTERNAL_ERROR;




×







961



      }










962



      if (IS_VAR_DATA_TYPE(((SValueNode*)pFirstParam)->node.resType.type)) {




878,411✔





963



        char* tmp = taosMemoryCalloc(1, pValue->data.nData + VARSTR_HEADER_SIZE); 




613,169✔





964



        if (tmp == NULL) {




613,130✔





965



          return TSDB_CODE_OUT_OF_MEMORY;




×







966



        }










967



        taosMemoryFree(((SValueNode*)pFirstParam)->datum.p);




613,130✔





968



        ((SValueNode*)pFirstParam)->datum.p = tmp;




613,377✔





969



        memcpy(varDataVal(((SValueNode*)pFirstParam)->datum.p), pValue->data.pData, pValue->data.nData);




613,377✔





970



        varDataLen(((SValueNode*)pFirstParam)->datum.p) = pValue->data.nData;




613,130✔





971



      } else {










972



        code = nodesSetValueNodeValue((SValueNode*)pFirstParam, VALUE_GET_DATUM(&pValue->data, pValue->data.type));




265,489✔





973



      }










974



    }










975



    ((SValueNode*)pFirstParam)->isNull = pValue->isNull;




885,131✔





976



  } else if (FUNCTION_TYPE_PLACEHOLDER_TBNAME == t) {




403,071,030✔





977



    SArray* pVal = (SArray*)fmGetStreamPesudoFuncVal(funcId, pStreamRuntimeInfo);




1,921,527✔





978



    for (int32_t i = 0; i < taosArrayGetSize(pVal); ++i) {




2,303,368✔





979



      SStreamGroupValue* pValue = taosArrayGet(pVal, i);




2,303,368✔





980



      if (pValue != NULL && pValue->isTbname) {




2,303,092✔





981



        taosMemoryFreeClear(((SValueNode*)pFirstParam)->datum.p);




1,923,501✔





982



        ((SValueNode*)pFirstParam)->datum.p = taosMemoryCalloc(pValue->data.nData + VARSTR_HEADER_SIZE, 1);




1,922,928✔





983



        if (NULL == ((SValueNode*)pFirstParam)->datum.p ) {




1,923,225✔





984



          return terrno;




×







985



        }










986












987



        (void)memcpy(varDataVal(((SValueNode*)pFirstParam)->datum.p), pValue->data.pData, pValue->data.nData);




1,923,221✔





988



        varDataLen(((SValueNode*)pFirstParam)->datum.p) = pValue->data.nData;




1,923,225✔





989



        break;




1,922,915✔





990



      }










991



    }










992



  } else if(FUNCTION_TYPE_EXTERNAL_WINDOW_COLUMN == t) {




401,149,503✔





993



    if (NULL == pParamNodes || LIST_LENGTH(pParamNodes) < 2) {




10,674,089✔





994



      uError("invalid stream external window column param list %p, len: %d", pParamNodes,




838✔





995



             pParamNodes ? LIST_LENGTH(pParamNodes) : 0);










996



      return TSDB_CODE_INTERNAL_ERROR;




×







997



    }










998












999



    SNode* pParamNode = nodesListGetNode(pParamNodes, 1);




10,673,251✔





1000



    if (NULL == pParamNode || QUERY_NODE_VALUE != nodeType(pParamNode)) {




10,672,413✔





1001



      uError("invalid stream external window column param node %p type %d for func: %d", pParamNode,




3,352✔





1002



             pParamNode ? nodeType(pParamNode) : -1, funcId);










1003



      return TSDB_CODE_INTERNAL_ERROR;




×







1004



    }










1005












1006



    const SStreamGroupValue* pVal =










1007



        fmGetExternalWindowColumnFuncVal(pStreamRuntimeInfo, ((SValueNode*)pParamNode)->placeholderNo);




10,669,061✔





1008



    if (!pVal) {




10,676,603✔





1009



      uError("failed to set stream pseudo func param val, NULL val for funcId: %d", funcId);




×







1010



      return TSDB_CODE_INTERNAL_ERROR;




×







1011



    }










1012



    if (pVal->isNull) {




10,676,603✔





1013



      ((SValueNode*)pFirstParam)->isNull = true;




838✔





1014



    } else {










1015



      ((SValueNode*)pFirstParam)->isNull = false;




10,675,765✔





1016



      if (IS_VAR_DATA_TYPE(pVal->data.type)) {




10,675,765✔





1017



        // pVal->data.pData already includes the VARSTR header from colDataGetData,










1018



        // so copy it directly as datum.p expects VARSTR format [header][raw data].










1019



        char* tmp = taosMemoryMalloc(pVal->data.nData);




9,222✔





1020



        if (tmp == NULL) {




9,222✔





1021



          return TSDB_CODE_OUT_OF_MEMORY;




×







1022



        }










1023



        taosMemoryFree(((SValueNode*)pFirstParam)->datum.p);




9,222✔





1024



        ((SValueNode*)pFirstParam)->datum.p = tmp;




9,222✔





1025



        memcpy(tmp, pVal->data.pData, pVal->data.nData);




9,222✔





1026



      } else {










1027



        code = nodesSetValueNodeValue((SValueNode*)pFirstParam, (void*)&pVal->data.val);




10,666,543✔





1028



      }










1029



    }










1030



    if (code != 0) {




10,674,508✔





1031



      uError("failed to set value node value: %s", tstrerror(code));




×







1032



      return code;




×







1033



    }










1034



  } else if (LIST_LENGTH(pParamNodes) == 1) {




780,998,355✔





1035



    // twstart, twend










1036



    const void* pVal = fmGetStreamPesudoFuncVal(funcId, pStreamRuntimeInfo);




390,521,896✔





1037



    if (!pVal) {




390,502,743✔





1038



      uError("failed to set stream pseudo func param val, NULL val for funcId: %d", funcId);




×







1039



      return TSDB_CODE_INTERNAL_ERROR;




×







1040



    }










1041



    code = nodesSetValueNodeValue((SValueNode*)pFirstParam, (void*)pVal);




390,502,743✔





1042



    if (code != 0) {




390,537,540✔





1043



      uError("failed to set value node value: %s", tstrerror(code));




14,599✔





1044



      return code;




×







1045



    }










1046



  } else {










1047



    uError("invalid placeholder function type: %d", t);




954✔





1048



    return TSDB_CODE_INTERNAL_ERROR;




×







1049



  }










1050



  










1051



  return code;




404,143,584✔





1052



}










1053


























    

  • 

    •