taosdata / TDengine / #5049

coverage: 73.313% (+0.09%) from 73.222%
#5049

push

travis-ci

web-flow 
feat: refactor taosdump code to improve backup speed and compression ratio (#35292)

6625 of 8435 new or added lines in 28 files covered. (78.54%)

2491 existing lines in 142 files now uncovered.

281233 of 383605 relevant lines covered (73.31%)

132489999.79 hits per line

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

82.97
/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,636,705✔





37



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










38



  (void)fmGetTwstartFuncId();




1,636,705✔





39



  (void)fmGetTwendFuncId();




1,636,705✔





40



  (void)fmGetTwdurationFuncId();




1,636,705✔





41



  (void)fmGetExternalWindowColumnFuncId();




1,636,705✔





42



}




1,636,705✔





43












44



static void doInitFunctionTable() {




1,636,705✔





45



  gFunMgtService.pFuncNameHashTable =




1,636,705✔





46



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




1,636,705✔





47



  if (NULL == gFunMgtService.pFuncNameHashTable) {




1,636,705✔





48



    initFunctionCode = terrno;




×







49



    return;




×







50



  }










51












52



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




381,352,265✔





53



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




379,715,560✔





54



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




379,715,560✔





55



      initFunctionCode = terrno;




×







56



      return;




×







57



    }










58



  }










59



  InitSpecialFuncId();




1,636,705✔





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,971,885✔





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,636,705✔





75



  (void)taosThreadOnce(&functionHashTableInit, doInitFunctionTable);




1,636,705✔





76



  return initFunctionCode;




1,636,705✔





77



}










78












79



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




901,105,817✔





80



  if (NULL != gFunMgtService.pFuncNameHashTable) {




901,105,817✔





81



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




900,943,188✔





82



    if (NULL != pVal) {




900,983,935✔





83



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




900,757,922✔





84



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




900,757,057✔





85



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




900,757,762✔





86



    }










87



    return TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION;




226,013✔





88



  }










89



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




3,439,335✔





90



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




3,438,600✔





91



      pFunc->funcId = i;




184,800✔





92



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




184,800✔





93



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




184,800✔





94



    }










95



  }










96



  return TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION;




798✔





97



}










98












99



EFuncReturnRows fmGetFuncReturnRows(SFunctionNode* pFunc) {




19,412,651✔





100



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




19,412,651✔





101



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




13,701,092✔





102



  }










103



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




5,712,126✔





104



                                                                                     : FUNC_RETURN_ROWS_NORMAL;




5,712,126✔





105



}










106












107



bool canCoexistIndefiniteRowsFunc(int32_t funcId1, int32_t funcId2) {




195,464✔





108



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




390,928✔





109



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




390,928✔





110



    return false;




×







111



  }










112



  if (funcId1 == funcId2) {




195,464✔





113



    return true;




178,629✔





114



  }










115



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




16,835✔





116



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




16,348✔





117



    return true;




16,348✔





118



  }










119



  return false;




487✔





120



}










121












122



bool fmIsBuiltinFunc(const char* pFunc) {




18,420✔





123



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




18,420✔





124



}










125












126



EFunctionType fmGetFuncType(const char* pFunc) {




654,415,270✔





127



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




654,415,270✔





128



  if (NULL != pVal) {




654,440,155✔





129



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




654,209,788✔





130



  }










131



  return FUNCTION_TYPE_UDF;




230,367✔





132



}










133












134



EFunctionType fmGetFuncTypeFromId(int32_t funcId) {




25,509,644✔





135



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




25,509,644✔





136



    return funcMgtBuiltins[funcId].type;




25,509,060✔





137



  }










138



  return FUNCTION_TYPE_UDF;




584✔





139



}










140












141



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




44,150,687✔





142



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




44,150,687✔





143



    return FUNC_DATA_REQUIRED_DATA_LOAD;




1,976✔





144



  }










145



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




44,156,892✔





146



    return FUNC_DATA_REQUIRED_DATA_LOAD;




×







147



  }










148



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




44,156,828✔





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✔






UNCOV

153



    return FUNC_DATA_REQUIRED_DATA_LOAD;




×







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;




2,196,772✔





159



    ;










160



  }










161












162



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




2,147,483,647✔





163



    return FUNC_DATA_REQUIRED_DATA_LOAD;




228,045,450✔





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




319,528,952✔





170



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




319,528,952✔





171



    return TSDB_CODE_FAILED;




×







172



  }










173



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




319,551,860✔





174



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




319,436,773✔





175



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




319,471,139✔





176



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




319,461,792✔





177



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




319,458,108✔





178



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




319,474,490✔





179



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




319,447,542✔





180



  return TSDB_CODE_SUCCESS;




319,436,934✔





181



}










182












183



int32_t fmGetUdafExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {




53,164✔





184



#ifdef USE_UDF










185



  if (!fmIsUserDefinedFunc(funcId)) {




53,164✔





186



    return TSDB_CODE_FAILED;




×







187



  }










188



  pFpSet->getEnv = udfAggGetEnv;




53,164✔





189



  pFpSet->init = udfAggInit;




53,164✔





190



  pFpSet->process = udfAggProcess;




53,164✔





191



  pFpSet->finalize = udfAggFinalize;




53,164✔





192



  return TSDB_CODE_SUCCESS;




53,164✔





193



#else










194



  TAOS_RETURN(TSDB_CODE_OPS_NOT_SUPPORT);










195



#endif










196



}










197












198



int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet) {




1,233,579,153✔





199



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




1,233,579,153✔





200



    return TSDB_CODE_FAILED;




47,545✔





201



  }










202



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




1,233,760,360✔





203



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




1,233,743,167✔





204



  return TSDB_CODE_SUCCESS;




1,233,774,560✔





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,403,108,618✔





212












213



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




164,908,384✔





214












215



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




2,038,391,987✔





216












217



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




1,263,087,179✔





218












219



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




638,918,883✔





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,558,076,855✔





226












227



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




65,159,432✔





228












229



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




435,112✔





230












231



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




1,226,468✔





232












233



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




10,812✔





234












235



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




1,719,417,392✔





236












237



bool fmIsSpecialDataRequiredFunc(int32_t funcId) {




99,705,948✔





238



  return isSpecificClassifyFunc(funcId, FUNC_MGT_SPECIAL_DATA_REQUIRED);




99,705,948✔





239



}










240












241



bool fmIsDynamicScanOptimizedFunc(int32_t funcId) {




47,652,496✔





242



  return isSpecificClassifyFunc(funcId, FUNC_MGT_DYNAMIC_SCAN_OPTIMIZED);




47,652,496✔





243



}










244












245



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




1,300,901,648✔





246












247



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




1,277,217,570✔





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




639,224,021✔





252












253



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




70,088,147✔





254












255



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




642,507,288✔





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




650,830,504✔





260












261



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




1,273,451,456✔





262












263



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




771,274,201✔





264












265



bool fmIsKeepOrderFunc(SFunctionNode* pFunc) {




778,252,842✔





266



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




778,252,842✔





267



      pFunc->funcType == FUNCTION_TYPE_SAMPLE) {




773,840,908✔





268



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




6,979,584✔





269



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




6,998,697✔





270



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




6,998,697✔





271



        SValueNode* pConst = (SValueNode*)pParam;




6,998,697✔





272



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




6,998,697✔





273



          return true;




822,615✔





274



        }










275



      }










276



    }










277



    return false;




6,166,242✔





278



  }










279



  return fmIsKeepOrderFuncId(pFunc->funcId);




771,293,567✔





280



}










281












282



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




167,603,267✔





283












284



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




639,114,741✔





285












286



bool fmIsInterpFunc(int32_t funcId) {




1,309,754,492✔





287



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




1,309,754,492✔





288



    return false;




412,597✔





289



  }










290



  return FUNCTION_TYPE_INTERP == funcMgtBuiltins[funcId].type;




1,309,348,827✔





291



}










292












293



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




1,288,291,140✔





294












295



bool fmIsForecastFunc(int32_t funcId) {




1,256,554,985✔





296



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




1,256,554,985✔





297



    return false;




423,301✔





298



  }










299



  return FUNCTION_TYPE_FORECAST == funcMgtBuiltins[funcId].type;




1,256,135,189✔





300



}










301












302



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




1,291,404,983✔





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




75,666,307✔





315



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




75,666,307✔





316



    return false;




10✔





317



  }










318



  return FUNCTION_TYPE_LAST_ROW == funcMgtBuiltins[funcId].type;




75,667,896✔





319



}










320












321



bool fmIsLastFunc(int32_t funcId) {




13,590✔





322



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




13,590✔





323



    return false;




×







324



  }










325



  return FUNCTION_TYPE_LAST == funcMgtBuiltins[funcId].type;




13,590✔





326



}










327












328



bool fmIsNotNullOutputFunc(int32_t funcId) {




484,938,330✔





329



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




484,938,330✔





330



    return false;




109,501✔





331



  }










332



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




484,836,264✔





333



         FUNCTION_TYPE_CACHE_LAST == funcMgtBuiltins[funcId].type ||




467,129,488✔





334



         FUNCTION_TYPE_LAST_PARTIAL == funcMgtBuiltins[funcId].type ||




465,771,530✔





335



         FUNCTION_TYPE_LAST_MERGE == funcMgtBuiltins[funcId].type ||




456,196,924✔





336



         FUNCTION_TYPE_FIRST == funcMgtBuiltins[funcId].type ||




452,277,499✔





337



         FUNCTION_TYPE_FIRST_PARTIAL == funcMgtBuiltins[funcId].type ||




440,914,749✔





338



         FUNCTION_TYPE_FIRST_MERGE == funcMgtBuiltins[funcId].type ||




435,748,056✔





339



         FUNCTION_TYPE_COUNT == funcMgtBuiltins[funcId].type ||




433,586,025✔





340



         FUNCTION_TYPE_HYPERLOGLOG == funcMgtBuiltins[funcId].type ||




378,112,117✔





341



         FUNCTION_TYPE_HYPERLOGLOG_PARTIAL == funcMgtBuiltins[funcId].type ||




1,325,978,377✔





342



         FUNCTION_TYPE_HYPERLOGLOG_MERGE == funcMgtBuiltins[funcId].type;




374,112,701✔





343



}










344












345



bool fmIsSelectValueFunc(int32_t funcId) {




362,880,235✔





346



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




362,880,235✔





347



    return false;




×







348



  }










349



  return FUNCTION_TYPE_SELECT_VALUE == funcMgtBuiltins[funcId].type;




362,880,888✔





350



}










351












352



bool fmIsGroupKeyFunc(int32_t funcId) {




275,433,262✔





353



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




275,433,262✔





354



    return false;




1,535✔





355



  }










356



  return FUNCTION_TYPE_GROUP_KEY == funcMgtBuiltins[funcId].type;




275,431,727✔





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




19,019,575✔





367



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




19,019,575✔





368



    return false;




×







369



  }










370



  return FUNCTION_TYPE_GROUP_CONST_VALUE == funcMgtBuiltins[funcId].type;




19,019,575✔





371



}










372












373



bool fmIsElapsedFunc(int32_t funcId) {




11,661,294✔





374



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




11,661,294✔





375



    return false;




×







376



  }










377



  return FUNCTION_TYPE_ELAPSED == funcMgtBuiltins[funcId].type;




11,661,294✔





378



}










379












380



bool fmIsBlockDistFunc(int32_t funcId) {




638,900,434✔





381



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




638,900,434✔





382



    return false;




194,262✔





383



  }










384



  return FUNCTION_TYPE_BLOCK_DIST == funcMgtBuiltins[funcId].type;




638,713,898✔





385



}










386












387



bool fmIsDBUsageFunc(int32_t funcId) {




638,895,419✔





388



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




638,895,419✔





389



    return false;




200,016✔





390



  }










391



  return FUNCTION_TYPE_DB_USAGE == funcMgtBuiltins[funcId].type;




638,700,283✔





392



}










393












394



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




864,420,807✔





395












396



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




933,860,527✔





397












398



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




37,431,121✔





399












400



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




280,753✔





401












402



void fmFuncMgtDestroy() {




1,636,773✔





403



  void* m = gFunMgtService.pFuncNameHashTable;




1,636,773✔





404



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




1,636,773✔





405



    taosHashCleanup(m);




1,636,705✔





406



  }










407



}




1,636,773✔





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




52,375,259✔





421



  bool res = false;




52,375,259✔





422



  switch (funcMgtBuiltins[funcId].type) {




52,375,259✔





423



    case FUNCTION_TYPE_MAX:




20,828,008✔





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,828,008✔





433



      break;




20,828,008✔





434



    default:




31,547,251✔





435



      break;




31,547,251✔





436



  }










437



  return res;




52,375,259✔





438



}










439












440



bool fmIsConstantResFunc(SFunctionNode* pFunc) {




15,872,177✔





441



  SNode* pNode;










442



  FOREACH(pNode, pFunc->pParameterList) {




15,964,997✔





443



    if (nodeType(pNode) != QUERY_NODE_VALUE) {




225,312✔





444



      return false;




132,492✔





445



    }










446



  }










447



  return true;




15,739,685✔





448



}










449












450



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




47,648,062✔





451












452



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




555,935,053✔





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




740,104✔





457



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




740,104✔





458



    return false;




×







459



  }










460



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




1,242,401✔





461



          funcMgtBuiltins[funcId].type == FUNCTION_TYPE_WDURATION);




502,297✔





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




167,539,077✔





471



  char msg[128] = {0};




167,539,077✔





472



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




167,539,077✔





473



}










474












475



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




10,981,670✔





476



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




10,981,670✔





477



  if (NULL == *ppFunc) {




10,981,670✔





478



    return code;




×







479



  }










480



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




10,981,670✔





481



  (*ppFunc)->pParameterList = pParameterList;




10,981,670✔





482



  code = getFuncInfo((*ppFunc));




10,981,670✔





483



  if (TSDB_CODE_SUCCESS != code) {




10,981,670✔





484



    (*ppFunc)->pParameterList = NULL;




×







485



    nodesDestroyNode((SNode*)*ppFunc);




×







486



    *ppFunc = NULL;




×







487



    return code;




×







488



  }










489



  return code;




10,981,670✔





490



}










491












492



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




156,561,457✔





493



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




156,561,457✔





494



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




25,085,531✔





495



    return;




25,085,597✔





496



  }










497



}










498












499



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




156,559,873✔





500



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




156,559,873✔





501



  if (NULL == *ppFunc) {




156,569,170✔





502



    return code;




×







503



  }










504












505



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




156,569,170✔





506



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




156,569,170✔





507



  (*ppFunc)->pSrcFuncRef = pSrcFunc;




156,569,170✔





508












509



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




156,569,170✔





510



  (*ppFunc)->pParameterList = pParameterList;




156,569,170✔





511



  code = getFuncInfo((*ppFunc));




156,569,170✔





512



  if (TSDB_CODE_SUCCESS != code) {




156,563,648✔





513



    (*ppFunc)->pParameterList = NULL;




×







514



    nodesDestroyNode((SNode*)*ppFunc);




×







515



    *ppFunc = NULL;




×







516



    return code;




×







517



  }










518



  resetOutputChangedFunc(*ppFunc, pSrcFunc);




156,563,648✔





519



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




156,565,130✔





520



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




156,565,066✔





521



  return code;




156,565,130✔





522



}










523












524



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




104,175,980✔





525



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




104,175,980✔





526



  if (NULL == *ppCol) {




104,182,710✔





527



    return code;




×







528



  }










529



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




104,182,710✔





530



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




104,182,710✔





531



  return TSDB_CODE_SUCCESS;




104,182,644✔





532



}










533












534



bool fmIsDistExecFunc(int32_t funcId) {




404,758,620✔





535



  if (fmIsUserDefinedFunc(funcId)) {




404,758,620✔





536



    return false;




122,076✔





537



  }










538



  if (!fmIsVectorFunc(funcId)) {




404,676,065✔





539



    return true;




556,613✔





540



  }










541



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




404,129,912✔





542



}










543












544



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




52,377,700✔





545



  SNodeList* pParameterList = NULL;




52,377,700✔





546



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




52,377,700✔





547



  if (NULL == pParameterList) {




52,382,483✔





548



    return code;




×







549



  }










550



  code =










551



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




52,382,483✔





552



  if (TSDB_CODE_SUCCESS != code) {




52,380,898✔





553



    nodesDestroyList(pParameterList);




4,336✔





554



    return code;




×







555



  }










556



  (*pPartialFunc)->hasOriginalFunc = true;




52,376,562✔





557



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




52,376,498✔





558



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




52,376,562✔





559












560



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




52,376,562✔





561



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




52,382,254✔





562



    return TSDB_CODE_FAILED;




×







563



  }










564



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




52,382,254✔





565



  return TSDB_CODE_SUCCESS;




52,382,254✔





566



}










567












568



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




104,175,750✔





569



                                   SNodeList** pParameterList) {










570



  SNode*  pRes = NULL;




104,175,750✔





571



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




104,175,750✔





572



  if (TSDB_CODE_SUCCESS != code) {




104,182,584✔





573



    return code;




×







574



  }










575



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




104,182,584✔





576



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




835,898✔





577



  } else {










578



    return nodesListMakeStrictAppend(pParameterList, pRes);




103,346,686✔





579



  }










580



}










581












582



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




51,793,549✔





583



                                 SFunctionNode** pMidFunc) {










584



  SNodeList*     pParameterList = NULL;




51,793,549✔





585



  SFunctionNode* pFunc = NULL;




51,793,549✔





586












587



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




51,793,549✔





588



  if (TSDB_CODE_SUCCESS == code) {




51,802,313✔





589



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




51,802,327✔





590



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




5,895,340✔





591



    }else{










592



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




45,906,987✔





593



    }










594



  }










595



  if (TSDB_CODE_SUCCESS == code) {




51,801,654✔





596



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




51,802,320✔





597



  }










598












599



  if (TSDB_CODE_SUCCESS == code) {




51,801,654✔





600



    *pMidFunc = pFunc;




51,801,654✔





601



  } else {










602



    nodesDestroyList(pParameterList);




×







603



  }










604



  return code;




51,801,897✔





605



}










606












607



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




52,382,867✔





608



                                   SFunctionNode** pMergeFunc) {










609



  SNodeList*     pParameterList = NULL;




52,382,867✔





610



  SFunctionNode* pFunc = NULL;




52,382,867✔





611












612



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




52,382,801✔





613



  if (TSDB_CODE_SUCCESS == code) {




52,382,782✔





614



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




52,382,782✔





615



  }










616



  if (TSDB_CODE_SUCCESS == code) {




52,388,433✔





617



    pFunc->hasOriginalFunc = true;




52,382,571✔





618



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




52,382,571✔





619



    // overwrite function restype set by translate function










620



    if (fmIsSameInOutType(pSrcFunc->funcId)) {




52,382,505✔





621



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




20,828,177✔





622



    }










623



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




52,375,547✔





624



  }










625












626



  if (TSDB_CODE_SUCCESS == code) {




52,381,343✔





627



    *pMergeFunc = pFunc;




52,381,343✔





628



  } else {










629



    nodesDestroyList(pParameterList);




×







630



  }










631



  return code;




52,381,451✔





632



}










633












634



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




52,373,025✔





635



                        SFunctionNode** pMergeFunc) {










636



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




52,373,025✔





637



    return TSDB_CODE_FAILED;




×







638



  }










639












640



  int32_t code = createPartialFunction(pFunc, pPartialFunc);




52,382,969✔





641



  if (TSDB_CODE_SUCCESS == code && pMidFunc) {




52,377,749✔





642



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




51,796,423✔





643



  }










644



  if (TSDB_CODE_SUCCESS == code) {




52,383,157✔





645



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




52,382,695✔





646



  }










647












648



  if (TSDB_CODE_SUCCESS != code) {




52,382,555✔





649



    nodesDestroyNode((SNode*)*pPartialFunc);




×







650



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




×







651



    nodesDestroyNode((SNode*)*pMergeFunc);




×







652



  }










653












654



  return code;




52,381,398✔





655



}










656












657



const char* fmGetFuncName(int32_t funcId) {




362,782✔





658



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




362,782✔





659



    return "invalid function";




×







660



  }










661



  return funcMgtBuiltins[funcId].name;




362,782✔





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




8,594✔





667



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




8,594✔





668



    SNodeList* pParams = NULL;




8,594✔





669



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




8,594✔





670



    if (!pParams) return code;




8,594✔





671



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




8,594✔





672



    if (TSDB_CODE_SUCCESS != code) {




8,594✔





673



      nodesDestroyList(pParams);




×







674



      return code;




×







675



    }










676



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




8,594✔





677



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




8,594✔





678



  }










679



  return TSDB_CODE_SUCCESS;




8,594✔





680



}










681












682



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




1,460,795✔





683












684



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




145,370✔





685












686



int32_t fmCreateStateFuncs(SNodeList* pFuncs) {




3,795✔





687



  int32_t code;










688



  SNode*  pNode;










689



  char    buf[128] = {0};




3,795✔





690



  FOREACH(pNode, pFuncs) {




12,389✔





691



    SFunctionNode* pFunc = (SFunctionNode*)pNode;




8,594✔





692



    code = fmGetFuncInfo(pFunc, buf, 128);




8,594✔





693



    if (code) break;




8,594✔





694



    if (fmIsTSMASupportedFunc(pFunc->funcId)) {




8,594✔





695



      SFunctionNode* pNewFunc = NULL;




8,594✔





696



      code = fmCreateStateFunc(pFunc, &pNewFunc);




8,594✔





697



      if (code) {




8,594✔





698



        // error










699



        break;




×







700



      } else if (!pNewFunc) {




8,594✔





701



        // no need state func










702



        continue;




×







703



      } else {










704



        REPLACE_NODE(pNewFunc);




8,594✔





705



        nodesDestroyNode(pNode);




8,594✔





706



      }










707



    }










708



  }










709



  return code;




3,795✔





710



}










711












712



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




1,881✔





713



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




1,881✔





714



    SNodeList* pParams = NULL;




1,539✔





715



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




1,539✔





716



    if (!pParams) return code;




1,539✔





717



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




1,539✔





718



    if (TSDB_CODE_SUCCESS != code) {




1,539✔





719



      nodesDestroyList(pParams);




×







720



      return code;




×







721



    }










722



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




1,539✔





723



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




1,539✔





724



  }










725



  return TSDB_CODE_SUCCESS;




1,881✔





726



}










727












728



int32_t fmCreateStateMergeFuncs(SNodeList* pFuncs) {




855✔





729



  int32_t code;










730



  SNode*  pNode;










731



  char    buf[128] = {0};




855✔





732



  FOREACH(pNode, pFuncs) {




2,736✔





733



    SFunctionNode* pFunc = (SFunctionNode*)pNode;




1,881✔





734



    if (fmIsTSMASupportedFunc(pFunc->funcId)) {




1,881✔





735



      SFunctionNode* pNewFunc = NULL;




1,881✔





736



      code = fmCreateStateMergeFunc(pFunc, &pNewFunc);




1,881✔





737



      if (code) {




1,881✔





738



        // error










739



        break;




×







740



      } else if (!pNewFunc) {




1,881✔





741



        // no state merge func










742



        continue;




342✔





743



      } else {










744



        REPLACE_NODE(pNewFunc);




1,539✔





745



        nodesDestroyNode(pNode);




1,539✔





746



      }










747



    }










748



  }










749



  return code;




855✔





750



}










751












752



int32_t fmGetFuncId(const char* name) {




8,761,451✔





753



  if (NULL != gFunMgtService.pFuncNameHashTable) {




8,761,451✔





754



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




8,761,451✔





755



    if (NULL != pVal) {




8,761,451✔





756



      return *(int32_t*)pVal;




8,761,451✔





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,840,261✔





769



  static int32_t twstartFuncId = -2;










770



  if (twstartFuncId < 0) {




1,840,261✔





771



    twstartFuncId = fmGetFuncId("_twstart");




1,636,705✔





772



  }










773



  return twstartFuncId;




1,840,261✔





774



}










775












776



int32_t fmGetTwendFuncId() {




1,673,090✔





777



  static int32_t twendFuncId = -2;










778



  if (twendFuncId < 0) {




1,673,090✔





779



    twendFuncId = fmGetFuncId("_twend");




1,636,705✔





780



  }










781



  return twendFuncId;




1,673,090✔





782



}










783












784



int32_t fmGetTwdurationFuncId() {




1,637,162✔





785



  static int32_t twdurationFuncId = -2;










786



  if (twdurationFuncId < 0) {




1,637,162✔





787



    twdurationFuncId = fmGetFuncId("_twduration");




1,636,705✔





788



  }










789



  return twdurationFuncId;




1,637,162✔





790



}










791












792



int32_t fmGetExternalWindowColumnFuncId() {




1,685,067✔





793



  static int32_t externalWindowColumnFuncId = -2;










794



  if (externalWindowColumnFuncId < 0) {




1,685,067✔





795



    externalWindowColumnFuncId = fmGetFuncId("_external_window_column");




1,636,705✔





796



  }










797



  return externalWindowColumnFuncId;




1,685,067✔





798



}










799












800



bool fmIsMyStateFunc(int32_t funcId, int32_t stateFuncId) {




2,503,611✔





801



  const SBuiltinFuncDefinition* pFunc = &funcMgtBuiltins[funcId];




2,503,611✔





802



  const SBuiltinFuncDefinition* pStateFunc = &funcMgtBuiltins[stateFuncId];




2,503,611✔





803



  if (!pFunc->pStateFunc) {




2,503,611✔





804



    return false;




×







805



  }










806



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




2,503,611✔





807



  int32_t stateMergeFuncId = fmGetFuncId(pFunc->pStateFunc);




915,021✔





808



  if (stateMergeFuncId == -1) {




915,021✔





809



    return false;




×







810



  }










811



  const SBuiltinFuncDefinition* pStateMergeFunc = &funcMgtBuiltins[stateMergeFuncId];




915,021✔





812



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




915,021✔





813



}










814












815



bool fmIsCountLikeFunc(int32_t funcId) {




630,395,942✔





816



  return isSpecificClassifyFunc(funcId, FUNC_MGT_COUNT_LIKE_FUNC);




630,395,942✔





817



}










818












819



bool fmIsRowTsOriginFunc(int32_t funcId) {




5,827,267✔





820



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




5,827,267✔





821



    return false;




×







822



  }










823



  return FUNCTION_TYPE_IROWTS_ORIGIN == funcMgtBuiltins[funcId].type;




5,827,267✔





824



}










825












826



bool fmIsGroupIdFunc(int32_t funcId) {




2,580,994✔





827



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




2,580,994✔





828



    return false;




×







829



  }










830



  return FUNCTION_TYPE_GROUP_ID == funcMgtBuiltins[funcId].type;




2,580,994✔





831



}










832












833



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




11,345,190✔





834



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




11,345,190✔





835



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




11,364,368✔





836



    return NULL;




×







837



  }










838



  return taosArrayGet(pParams->pExternalWindowData, index);




11,365,260✔





839



}










840












841



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




440,233,442✔





842



  switch (funcMgtBuiltins[funcId].type) {




440,233,442✔





843



    case FUNCTION_TYPE_TGRPID:




155,144✔





844



      return &pStreamRuntimeFuncInfo->groupId;




155,144✔





845



    case FUNCTION_TYPE_PLACEHOLDER_COLUMN:




1,026,250✔





846



      return pStreamRuntimeFuncInfo->pStreamPartColVals;




1,026,250✔





847



    case FUNCTION_TYPE_PLACEHOLDER_TBNAME:




1,950,746✔





848



      return pStreamRuntimeFuncInfo->pStreamPartColVals;




1,950,746✔





849



    default:




437,186,454✔





850



      break;




437,186,454✔





851



  }










852












853



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




437,186,454✔





854



  switch (funcMgtBuiltins[funcId].type) {




437,227,935✔





855



    case FUNCTION_TYPE_TPREV_TS:




×







856



      return &pParams->prevTs;




×







857



    case FUNCTION_TYPE_TCURRENT_TS:




2,985,336✔





858



      return &pParams->currentTs;




2,985,336✔





859



    case FUNCTION_TYPE_TNEXT_TS:




×







860



      return &pParams->nextTs;




×







861



    case FUNCTION_TYPE_TWSTART:




376,581,609✔





862



      return &pParams->wstart;




376,581,609✔





863



    case FUNCTION_TYPE_TWEND:




19,717,164✔





864



      return &pParams->wend;




19,717,164✔





865



    case FUNCTION_TYPE_TWDURATION:




1,244,539✔





866



      return &pParams->wduration;




1,244,539✔





867



    case FUNCTION_TYPE_TWROWNUM:




35,148,928✔





868



      return &pParams->wrownum;




35,148,928✔





869



    case FUNCTION_TYPE_TPREV_LOCALTIME:




293,512✔





870



      return &pParams->prevLocalTime;




293,512✔





871



    case FUNCTION_TYPE_TLOCALTIME:




793,263✔





872



      return &pParams->triggerTime;




793,263✔





873



    case FUNCTION_TYPE_TNEXT_LOCALTIME:




451,278✔





874



      return &pParams->nextLocalTime;




451,278✔





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:




4,563✔





882



      return &pParams->idlestart;




4,563✔





883



    case FUNCTION_TYPE_TIDLEEND:




4,563✔





884



      return &pParams->idleend;




4,563✔





885



    default:




×







886



      break;




×







887



  }










888



  return NULL;




×







889



}










890












891



bool fmIsStreamPesudoColVal(int32_t funcId) {




623,630✔





892



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




623,630✔





893



    return false;




9,150✔





894



  }










895



  return funcMgtBuiltins[funcId].type == FUNCTION_TYPE_PLACEHOLDER_COLUMN




614,480✔





896



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




614,480✔





897



}










898












899



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




7,689,201✔





900



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




7,689,201✔





901



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




×







902



    return TSDB_CODE_INTERNAL_ERROR;




×







903



  }










904












905



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




7,689,839✔





906



  if (QUERY_NODE_VALUE != firstParamType) {




7,689,209✔





907



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




×







908



    return TSDB_CODE_INTERNAL_ERROR;




×







909



  }










910












911



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




7,689,209✔





912



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




7,689,201✔





913












914



  return TSDB_CODE_SUCCESS;




7,689,839✔





915



}










916












917












918



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




451,568,821✔





919



  if (!pStreamRuntimeInfo) {




451,568,821✔





920



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




×







921



    return TSDB_CODE_INTERNAL_ERROR;




×







922



  }










923



  int32_t code = 0;




451,568,821✔





924



  SArray *pVals1 = NULL;




451,568,821✔





925



  SNode* pFirstParam = nodesListGetNode(pParamNodes, 0);




451,568,821✔





926



  if (nodeType(pFirstParam) != QUERY_NODE_VALUE) {




451,622,934✔





927



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




×







928



    return TSDB_CODE_INTERNAL_ERROR;




×







929



  }










930












931



  int32_t t = funcMgtBuiltins[funcId].type;




451,659,829✔





932



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




451,611,744✔





933



  if (FUNCTION_TYPE_TGRPID == t) {




451,641,233✔





934



    SValue v = {0};




155,144✔





935



    v.type = TSDB_DATA_TYPE_BIGINT;




155,144✔





936



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




155,144✔





937



    










938



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




155,144✔





939



    if (code != 0) {




155,144✔






UNCOV

940



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




×







941



      return code;




×







942



    }










943



  } else if (FUNCTION_TYPE_PLACEHOLDER_COLUMN == t) {




451,486,089✔





944



    SNode* pSecondParam = nodesListGetNode(pParamNodes, 1);




1,026,545✔





945



    if (nodeType(pSecondParam) != QUERY_NODE_VALUE) {




1,026,545✔





946



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




×







947



      return TSDB_CODE_INTERNAL_ERROR;




×







948



    }










949



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




1,026,545✔





950



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




1,026,545✔





951



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




1,026,545✔





952



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




295✔





953



      return TSDB_CODE_INTERNAL_ERROR;




×







954



    }










955



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




1,026,250✔





956



    if (pValue == NULL) {




1,026,250✔





957



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




×







958



      return TSDB_CODE_INTERNAL_ERROR;




×







959



    }










960



    if (!pValue->isNull){




1,026,250✔





961



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




1,018,810✔





962



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




×







963



        return TSDB_CODE_INTERNAL_ERROR;




×







964



      }










965



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




1,018,810✔





966



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




701,971✔





967



        if (tmp == NULL) {




702,266✔





968



          return TSDB_CODE_OUT_OF_MEMORY;




×







969



        }










970



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




702,266✔





971



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




702,266✔





972



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




702,266✔





973



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




702,266✔





974



      } else {










975



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




316,544✔





976



      }










977



    }










978



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




1,026,545✔





979



  } else if (FUNCTION_TYPE_PLACEHOLDER_TBNAME == t) {




450,459,544✔





980



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




1,893,880✔





981



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




2,384,106✔





982



      SStreamGroupValue* pValue = taosArrayGet(pVal, i);




2,383,793✔





983



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




2,384,114✔





984



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




1,894,823✔





985



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




1,893,876✔





986



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




1,894,506✔





987



          return terrno;




×







988



        }










989












990



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




1,894,193✔





991



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




1,894,823✔





992



        break;




1,894,823✔





993



      }










994



    }










995



  } else if(FUNCTION_TYPE_EXTERNAL_WINDOW_COLUMN == t) {




448,565,664✔





996



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




11,355,002✔





997



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




4,460✔





998



             pParamNodes ? LIST_LENGTH(pParamNodes) : 0);










999



      return TSDB_CODE_INTERNAL_ERROR;




×







1000



    }










1001












1002



    SNode* pParamNode = nodesListGetNode(pParamNodes, 1);




11,353,218✔





1003



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




11,359,462✔





1004



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




2,676✔





1005



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










1006



      return TSDB_CODE_INTERNAL_ERROR;




×







1007



    }










1008












1009



    const SStreamGroupValue* pVal =










1010



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




11,357,678✔





1011



    if (!pVal) {




11,364,814✔





1012



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




×







1013



      return TSDB_CODE_INTERNAL_ERROR;




×







1014



    }










1015



    if (pVal->isNull) {




11,364,814✔





1016



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




892✔





1017



    } else {










1018



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




11,358,570✔





1019



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




11,364,368✔





1020



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










1021



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










1022



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




10,722✔





1023



        if (tmp == NULL) {




9,830✔





1024



          return TSDB_CODE_OUT_OF_MEMORY;




×







1025



        }










1026



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




9,830✔





1027



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




9,830✔





1028



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




9,830✔





1029



      } else {










1030



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




11,353,646✔





1031



      }










1032



    }










1033



    if (code != 0) {




11,355,894✔





1034



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




×







1035



      return code;




×







1036



    }










1037



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




874,428,064✔





1038



    // twstart, twend










1039



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




437,233,420✔





1040



    if (!pVal) {




437,225,700✔





1041



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




×







1042



      return TSDB_CODE_INTERNAL_ERROR;




×







1043



    }










1044



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




437,225,700✔





1045



    if (code != 0) {




437,232,487✔





1046



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




15,085✔





1047



      return code;




×







1048



    }










1049



  } else {










1050



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




43,250✔





1051



    return TSDB_CODE_INTERNAL_ERROR;




×







1052



  }










1053



  










1054



  return code;




451,661,533✔





1055



}










1056


























    

  • 

    •