taosdata / TDengine / #4969

coverage: 67.69% (+0.8%) from 66.902%
#4969

push

travis-ci

web-flow 
merge: from main to 3.0 #34603

15 of 58 new or added lines in 2 files covered. (25.86%)

5075 existing lines in 154 files now uncovered.

208337 of 307781 relevant lines covered (67.69%)

129686642.38 hits per line

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

83.24
/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 doInitFunctionTable() {




1,271,614✔





37



  gFunMgtService.pFuncNameHashTable =




1,271,614✔





38



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




1,271,614✔





39



  if (NULL == gFunMgtService.pFuncNameHashTable) {




1,271,614✔





40



    initFunctionCode = terrno;




×







41



    return;




×







42



  }










43












44



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




286,113,150✔





45



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




284,841,536✔





46



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




284,841,536✔





47



      initFunctionCode = terrno;




×







48



      return;




×







49



    }










50



  }










51



}










52












53



static bool isSpecificClassifyFunc(int32_t funcId, uint64_t classification) {




2,147,483,647✔





54



  if (fmIsUserDefinedFunc(funcId)) {




2,147,483,647✔





55



    return FUNC_MGT_AGG_FUNC == classification










56



               ? FUNC_AGGREGATE_UDF_ID == funcId










57



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




7,020,550✔





58



  }










59



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




2,147,483,647✔





60



    return false;




2,147,483,647✔





61



  }










62



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




2,147,483,647✔





63



}










64












65



int32_t fmFuncMgtInit() {




1,271,614✔





66



  (void)taosThreadOnce(&functionHashTableInit, doInitFunctionTable);




1,271,614✔





67



  return initFunctionCode;




1,271,614✔





68



}










69












70



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




760,173,675✔





71



  if (NULL != gFunMgtService.pFuncNameHashTable) {




760,173,675✔





72



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




760,027,623✔





73



    if (NULL != pVal) {




760,076,373✔





74



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




759,920,456✔





75



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




759,920,923✔





76



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




759,921,142✔





77



    }










78



    return TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION;




155,917✔





79



  }










80



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




3,090,959✔





81



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




3,091,872✔





82



      pFunc->funcId = i;




166,278✔





83



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




166,278✔





84



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




166,278✔





85



    }










86



  }











UNCOV

87



  return TSDB_CODE_FUNC_NOT_BUILTIN_FUNTION;




×







88



}










89












90



EFuncReturnRows fmGetFuncReturnRows(SFunctionNode* pFunc) {




16,355,694✔





91



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




16,355,694✔





92



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




11,556,543✔





93



  }










94



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




4,799,151✔





95



                                                                                     : FUNC_RETURN_ROWS_NORMAL;




4,799,151✔





96



}










97












98



bool fmIsBuiltinFunc(const char* pFunc) {




11,846✔





99



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




11,846✔





100



}










101












102



EFunctionType fmGetFuncType(const char* pFunc) {




619,912,679✔





103



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




619,912,679✔





104



  if (NULL != pVal) {




619,975,241✔





105



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




619,755,398✔





106



  }










107



  return FUNCTION_TYPE_UDF;




219,843✔





108



}










109












110



EFunctionType fmGetFuncTypeFromId(int32_t funcId) {




2,802,856✔





111



  if (funcId < funcMgtBuiltinsNum) {




2,802,856✔





112



    return funcMgtBuiltins[funcId].type;




2,802,856✔





113



  }










114



  return FUNCTION_TYPE_UDF;




×







115



}










116












117



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




42,538,081✔





118



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




42,538,081✔





119



    return FUNC_DATA_REQUIRED_DATA_LOAD;




1,205✔





120



  }










121



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




42,547,254✔





122



    return FUNC_DATA_REQUIRED_DATA_LOAD;




×







123



  }










124



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




42,547,294✔





125



}










126












127



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




2,147,483,647✔





128



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




2,147,483,647✔





129



    return FUNC_DATA_REQUIRED_DATA_LOAD;




659,830✔





130



  }










131












132



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




2,147,483,647✔





133



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




2,147,483,647✔





134



    return FUNC_DATA_REQUIRED_NOT_LOAD;




632,240✔





135



    ;










136



  }










137












138



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




2,147,483,647✔





139



    return FUNC_DATA_REQUIRED_DATA_LOAD;




72,332,973✔





140



  } else {










141



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




2,147,483,647✔





142



  }










143



}










144












145



int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {




257,336,939✔





146



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




257,336,939✔





147



    return TSDB_CODE_FAILED;




17,793✔





148



  }










149



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




257,326,085✔





150



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




257,309,902✔





151



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




257,328,426✔





152



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




257,286,266✔





153



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




257,302,257✔





154



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




257,315,202✔





155



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




257,334,922✔





156



  return TSDB_CODE_SUCCESS;




257,322,321✔





157



}










158












159



int32_t fmGetUdafExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {




53,736✔





160



#ifdef USE_UDF










161



  if (!fmIsUserDefinedFunc(funcId)) {




53,736✔





162



    return TSDB_CODE_FAILED;




×







163



  }










164



  pFpSet->getEnv = udfAggGetEnv;




53,736✔





165



  pFpSet->init = udfAggInit;




53,736✔





166



  pFpSet->process = udfAggProcess;




53,736✔





167



  pFpSet->finalize = udfAggFinalize;




53,736✔





168



  return TSDB_CODE_SUCCESS;




53,736✔





169



#else










170



  TAOS_RETURN(TSDB_CODE_OPS_NOT_SUPPORT);










171



#endif










172



}










173












174



int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet) {




988,551,236✔





175



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




988,551,236✔





176



    return TSDB_CODE_FAILED;




135,884✔





177



  }










178



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




988,543,110✔





179



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




988,545,231✔





180



  return TSDB_CODE_SUCCESS;




988,597,184✔





181



}










182












183



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




1,987,222,934✔





184












185



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




2,147,483,647✔





186












187



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




1,188,333,074✔





188












189



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




119,510,834✔





190












191



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




1,657,632,254✔





192












193



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




1,045,163,945✔





194












195



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




528,825,644✔





196












197



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




1,920,646,715✔





198












199



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




2,147,483,647✔





200












201



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




1,243,624,438✔





202












203



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




61,163,051✔





204












205



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




380,090✔





206












207



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




9,486✔





208












209



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




1,408,360,754✔





210












211



bool fmIsSpecialDataRequiredFunc(int32_t funcId) {




93,864,584✔





212



  return isSpecificClassifyFunc(funcId, FUNC_MGT_SPECIAL_DATA_REQUIRED);




93,864,584✔





213



}










214












215



bool fmIsDynamicScanOptimizedFunc(int32_t funcId) {




44,627,422✔





216



  return isSpecificClassifyFunc(funcId, FUNC_MGT_DYNAMIC_SCAN_OPTIMIZED);




44,627,422✔





217



}










218












219



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




1,104,909,151✔





220












221



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




1,056,344,979✔





222












223



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




2,147,483,647✔





224












225



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




529,059,709✔





226












227



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




57,651,686✔





228












229



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




531,822,512✔





230












231



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




2,147,483,647✔





232












233



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




531,565,316✔





234












235



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




1,053,974,785✔





236












237



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




606,597,389✔





238












239



bool fmIsKeepOrderFunc(SFunctionNode* pFunc) {




612,259,222✔





240



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




612,259,222✔





241



      pFunc->funcType == FUNCTION_TYPE_SAMPLE) {




608,792,626✔





242



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




5,679,600✔





243



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




5,694,378✔





244



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




5,694,378✔





245



        SValueNode* pConst = (SValueNode*)pParam;




5,694,378✔





246



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




5,694,378✔





247



          return true;




695,139✔





248



        }










249



      }










250



    }










251



    return false;




4,993,215✔





252



  }










253



  return fmIsKeepOrderFuncId(pFunc->funcId);




606,624,245✔





254



}










255












256



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




121,686,501✔





257












258



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




528,982,806✔





259












260



bool fmIsInterpFunc(int32_t funcId) {




1,085,136,690✔





261



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




1,085,136,690✔





262



    return false;




263,176✔





263



  }










264



  return FUNCTION_TYPE_INTERP == funcMgtBuiltins[funcId].type;




1,084,886,971✔





265



}










266












267



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




1,069,093,202✔





268












269



bool fmIsForecastFunc(int32_t funcId) {




1,039,766,378✔





270



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




1,039,766,378✔





271



    return false;




282,492✔





272



  }










273



  return FUNCTION_TYPE_FORECAST == funcMgtBuiltins[funcId].type;




1,039,490,475✔





274



}










275












276



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




1,071,853,326✔





277












278



bool fmIsImputationCorrelationFunc(int32_t funcId) {




×







279



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




×







280



    return false;




×







281



  }










282












283



  int32_t type = funcMgtBuiltins[funcId].type;




×







284



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




×







285



         FUNCTION_TYPE_TLCC == type;










286



}










287












288



bool fmIsLastRowFunc(int32_t funcId) {




67,982,820✔





289



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




67,982,820✔





290



    return false;




2✔





291



  }










292



  return FUNCTION_TYPE_LAST_ROW == funcMgtBuiltins[funcId].type;




67,983,346✔





293



}










294












295



bool fmIsLastFunc(int32_t funcId) {




11,680✔





296



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




11,680✔





297



    return false;




×







298



  }










299



  return FUNCTION_TYPE_LAST == funcMgtBuiltins[funcId].type;




11,680✔





300



}










301












302



bool fmIsNotNullOutputFunc(int32_t funcId) {




400,572,581✔





303



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




400,572,581✔





304



    return false;




104,968✔





305



  }










306



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




400,474,385✔





307



         FUNCTION_TYPE_CACHE_LAST == funcMgtBuiltins[funcId].type ||




384,900,557✔





308



         FUNCTION_TYPE_LAST_PARTIAL == funcMgtBuiltins[funcId].type ||




384,515,846✔





309



         FUNCTION_TYPE_LAST_MERGE == funcMgtBuiltins[funcId].type ||




370,128,363✔





310



         FUNCTION_TYPE_FIRST == funcMgtBuiltins[funcId].type ||




365,052,332✔





311



         FUNCTION_TYPE_FIRST_PARTIAL == funcMgtBuiltins[funcId].type ||




355,049,285✔





312



         FUNCTION_TYPE_FIRST_MERGE == funcMgtBuiltins[funcId].type ||




347,248,478✔





313



         FUNCTION_TYPE_COUNT == funcMgtBuiltins[funcId].type ||




344,502,498✔





314



         FUNCTION_TYPE_HYPERLOGLOG == funcMgtBuiltins[funcId].type ||




295,775,437✔





315



         FUNCTION_TYPE_HYPERLOGLOG_PARTIAL == funcMgtBuiltins[funcId].type ||




1,077,545,176✔





316



         FUNCTION_TYPE_HYPERLOGLOG_MERGE == funcMgtBuiltins[funcId].type;




292,195,575✔





317



}










318












319



bool fmIsSelectValueFunc(int32_t funcId) {




87,900,246✔





320



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




87,900,246✔





321



    return false;




×







322



  }










323



  return FUNCTION_TYPE_SELECT_VALUE == funcMgtBuiltins[funcId].type;




87,900,246✔





324



}










325












326



bool fmIsGroupKeyFunc(int32_t funcId) {




245,841,166✔





327



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




245,841,166✔





328



    return false;




2✔





329



  }










330



  return FUNCTION_TYPE_GROUP_KEY == funcMgtBuiltins[funcId].type;




245,841,437✔





331



}










332












333



bool fmisSelectGroupConstValueFunc(int32_t funcId) {




10,386,866✔





334



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




10,386,866✔





335



    return false;




×







336



  }










337



  return FUNCTION_TYPE_GROUP_CONST_VALUE == funcMgtBuiltins[funcId].type;




10,386,866✔





338



}










339












340



bool fmIsElapsedFunc(int32_t funcId) {




10,253,271✔





341



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




10,253,271✔





342



    return false;




×







343



  }










344



  return FUNCTION_TYPE_ELAPSED == funcMgtBuiltins[funcId].type;




10,253,271✔





345



}










346












347



bool fmIsBlockDistFunc(int32_t funcId) {




528,806,015✔





348



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




528,806,015✔





349



    return false;




142,703✔





350



  }










351



  return FUNCTION_TYPE_BLOCK_DIST == funcMgtBuiltins[funcId].type;




528,666,121✔





352



}










353












354



bool fmIsDBUsageFunc(int32_t funcId) {




528,827,910✔





355



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




528,827,910✔





356



    return false;




126,352✔





357



  }










358



  return FUNCTION_TYPE_DB_USAGE == funcMgtBuiltins[funcId].type;




528,710,198✔





359



}










360












361



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




570,609,465✔





362












363



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




280,516✔





364












365



void fmFuncMgtDestroy() {




1,271,671✔





366



  void* m = gFunMgtService.pFuncNameHashTable;




1,271,671✔





367



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




1,271,671✔





368



    taosHashCleanup(m);




1,271,614✔





369



  }










370



}




1,271,671✔





371












372



#ifdef BUILD_NO_CALL










373



int32_t fmSetNormalFunc(int32_t funcId, SFuncExecFuncs* pFpSet) {










374



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










375



    return TSDB_CODE_FAILED;










376



  }










377



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










378



  return TSDB_CODE_SUCCESS;










379



}










380



#endif










381












382



// function has same input/output type










383



bool fmIsSameInOutType(int32_t funcId) {




45,544,453✔





384



  bool res = false;




45,544,453✔





385



  switch (funcMgtBuiltins[funcId].type) {




45,544,453✔





386



    case FUNCTION_TYPE_MAX:




15,170,584✔





387



    case FUNCTION_TYPE_MIN:










388



    case FUNCTION_TYPE_TOP:










389



    case FUNCTION_TYPE_BOTTOM:










390



    case FUNCTION_TYPE_FIRST:










391



    case FUNCTION_TYPE_LAST:










392



    case FUNCTION_TYPE_SAMPLE:










393



    case FUNCTION_TYPE_TAIL:










394



    case FUNCTION_TYPE_UNIQUE:










395



      res = true;




15,170,584✔





396



      break;




15,170,584✔





397



    default:




30,373,919✔





398



      break;




30,373,919✔





399



  }










400



  return res;




45,544,503✔





401



}










402












403



bool fmIsConstantResFunc(SFunctionNode* pFunc) {




15,102,522✔





404



  SNode* pNode;










405



  FOREACH(pNode, pFunc->pParameterList) {




15,181,302✔





406



    if (nodeType(pNode) != QUERY_NODE_VALUE) {




246,105✔





407



      return false;




167,325✔





408



    }










409



  }










410



  return true;




14,935,197✔





411



}










412












413



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




44,619,417✔





414












415



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




525,106,021✔





416












417



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




2,147,483,647✔





418












419



void getLastCacheDataType(SDataType* pType, int32_t pkBytes) {




×







420



  // TODO: do it later.










421



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




×







422



  pType->type = TSDB_DATA_TYPE_BINARY;




×







423



}




×







424












425



static int32_t getFuncInfo(SFunctionNode* pFunc) {




145,045,342✔





426



  char msg[128] = {0};




145,045,342✔





427



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




145,045,388✔





428



}










429












430



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




8,752,876✔





431



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




8,752,876✔





432



  if (NULL == *ppFunc) {




8,752,876✔





433



    return code;




×







434



  }










435



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




8,752,876✔





436



  (*ppFunc)->pParameterList = pParameterList;




8,752,876✔





437



  code = getFuncInfo((*ppFunc));




8,752,876✔





438



  if (TSDB_CODE_SUCCESS != code) {




8,752,876✔





439



    (*ppFunc)->pParameterList = NULL;




×







440



    nodesDestroyNode((SNode*)*ppFunc);




×







441



    *ppFunc = NULL;




×







442



    return code;




×







443



  }










444



  return code;




8,752,876✔





445



}










446












447



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




136,295,212✔





448



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




136,295,212✔





449



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




17,272,376✔





450



    return;




17,272,334✔





451



  }










452



}










453












454



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




136,292,676✔





455



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




136,292,676✔





456



  if (NULL == *ppFunc) {




136,305,661✔





457



    return code;




×







458



  }










459












460



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




136,305,665✔





461



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




136,305,623✔





462



  (*ppFunc)->pSrcFuncRef = pSrcFunc;




136,305,669✔





463












464



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




136,305,623✔





465



  (*ppFunc)->pParameterList = pParameterList;




136,305,569✔





466



  code = getFuncInfo((*ppFunc));




136,305,661✔





467



  if (TSDB_CODE_SUCCESS != code) {




136,299,081✔





468



    (*ppFunc)->pParameterList = NULL;




×







469



    nodesDestroyNode((SNode*)*ppFunc);




×







470



    *ppFunc = NULL;




×







471



    return code;




×







472



  }










473



  resetOutputChangedFunc(*ppFunc, pSrcFunc);




136,299,081✔





474



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




136,301,421✔





475



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




136,301,437✔





476



  return code;




136,301,475✔





477



}










478












479



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




90,733,769✔





480



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




90,733,769✔





481



  if (NULL == *ppCol) {




90,747,931✔





482



    return code;




×







483



  }










484



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




90,747,973✔





485



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




90,747,919✔





486



  return TSDB_CODE_SUCCESS;




90,747,843✔





487



}










488












489



bool fmIsDistExecFunc(int32_t funcId) {




290,269,260✔





490



  if (fmIsUserDefinedFunc(funcId)) {




290,269,260✔





491



    return false;




75,083✔





492



  }










493



  if (!fmIsVectorFunc(funcId)) {




290,237,846✔





494



    return true;




205,733✔





495



  }










496



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




290,049,573✔





497



}










498












499



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




45,550,076✔





500



  SNodeList* pParameterList = NULL;




45,550,076✔





501



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




45,550,084✔





502



  if (NULL == pParameterList) {




45,554,769✔





503



    return code;




×







504



  }










505



  code =










506



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




45,554,769✔





507



  if (TSDB_CODE_SUCCESS != code) {




45,553,715✔





508



    nodesDestroyList(pParameterList);




3,826✔





509



    return code;




×







510



  }










511



  (*pPartialFunc)->hasOriginalFunc = true;




45,549,889✔





512



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




45,549,931✔





513



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




45,549,935✔





514












515



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




45,549,897✔





516



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




45,552,756✔





517



    return TSDB_CODE_FAILED;




×







518



  }










519



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




45,552,756✔





520



  return TSDB_CODE_SUCCESS;




45,552,794✔





521



}










522












523



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




90,732,434✔





524



                                   SNodeList** pParameterList) {










525



  SNode*  pRes = NULL;




90,732,434✔





526



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




90,732,434✔





527



  if (TSDB_CODE_SUCCESS != code) {




90,746,752✔





528



    return code;




×







529



  }










530



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




90,746,752✔





531



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




603,610✔





532



  } else {










533



    return nodesListMakeStrictAppend(pParameterList, pRes);




90,143,180✔





534



  }










535



}










536












537



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




45,182,175✔





538



                                 SFunctionNode** pMidFunc) {










539



  SNodeList*     pParameterList = NULL;




45,182,175✔





540



  SFunctionNode* pFunc = NULL;




45,182,175✔





541












542



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




45,182,301✔





543



  if (TSDB_CODE_SUCCESS == code) {




45,195,166✔





544



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




45,195,160✔





545



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




6,680,871✔





546



    }else{










547



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




38,514,247✔





548



    }










549



  }










550



  if (TSDB_CODE_SUCCESS == code) {




45,194,429✔





551



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




45,195,595✔





552



  }










553












554



  if (TSDB_CODE_SUCCESS == code) {




45,194,337✔





555



    *pMidFunc = pFunc;




45,194,337✔





556



  } else {










557



    nodesDestroyList(pParameterList);




×







558



  }










559



  return code;




45,194,183✔





560



}










561












562



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




45,549,854✔





563



                                   SFunctionNode** pMergeFunc) {










564



  SNodeList*     pParameterList = NULL;




45,549,854✔





565



  SFunctionNode* pFunc = NULL;




45,549,900✔





566












567



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




45,549,946✔





568



  if (TSDB_CODE_SUCCESS == code) {




45,555,231✔





569



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




45,555,185✔





570



  }










571



  if (TSDB_CODE_SUCCESS == code) {




45,561,007✔





572



    pFunc->hasOriginalFunc = true;




45,554,985✔





573



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




45,554,985✔





574



    // overwrite function restype set by translate function










575



    if (fmIsSameInOutType(pSrcFunc->funcId)) {




45,554,939✔





576



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




15,170,912✔





577



    }










578



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




45,545,498✔





579



  }










580












581



  if (TSDB_CODE_SUCCESS == code) {




45,551,440✔





582



    *pMergeFunc = pFunc;




45,551,440✔





583



  } else {










584



    nodesDestroyList(pParameterList);




×







585



  }










586



  return code;




45,553,026✔





587



}










588












589



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




45,541,396✔





590



                        SFunctionNode** pMergeFunc) {










591



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




45,541,396✔





592



    return TSDB_CODE_FAILED;




×







593



  }










594












595



  int32_t code = createPartialFunction(pFunc, pPartialFunc);




45,554,866✔





596



  if (TSDB_CODE_SUCCESS == code && pMidFunc) {




45,546,313✔





597



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




45,186,952✔





598



  }










599



  if (TSDB_CODE_SUCCESS == code) {




45,553,625✔





600



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




45,554,741✔





601



  }










602












603



  if (TSDB_CODE_SUCCESS != code) {




45,552,655✔





604



    nodesDestroyNode((SNode*)*pPartialFunc);




×







605



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




×







606



    nodesDestroyNode((SNode*)*pMergeFunc);




×







607



  }










608












609



  return code;




45,553,899✔





610



}










611












612



const char* fmGetFuncName(int32_t funcId) {




323,568✔





613



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




323,568✔





614



    return "invalid function";




×







615



  }










616



  return funcMgtBuiltins[funcId].name;




323,568✔





617



}










618












619



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










620



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










621



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




5,336✔





622



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




5,336✔





623



    SNodeList* pParams = NULL;




5,336✔





624



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




5,336✔





625



    if (!pParams) return code;




5,336✔





626



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




5,336✔





627



    if (TSDB_CODE_SUCCESS != code) {




5,336✔





628



      nodesDestroyList(pParams);




×







629



      return code;




×







630



    }










631



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




5,336✔





632



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




5,336✔





633



  }










634



  return TSDB_CODE_SUCCESS;




5,336✔





635



}










636












637



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




953,056✔





638












639



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




122,087✔





640












641



int32_t fmCreateStateFuncs(SNodeList* pFuncs) {




2,204✔





642



  int32_t code;










643



  SNode*  pNode;










644



  char    buf[128] = {0};




2,204✔





645



  FOREACH(pNode, pFuncs) {




7,540✔





646



    SFunctionNode* pFunc = (SFunctionNode*)pNode;




5,336✔





647



    code = fmGetFuncInfo(pFunc, buf, 128);




5,336✔





648



    if (code) break;




5,336✔





649



    if (fmIsTSMASupportedFunc(pFunc->funcId)) {




5,336✔





650



      SFunctionNode* pNewFunc = NULL;




5,336✔





651



      code = fmCreateStateFunc(pFunc, &pNewFunc);




5,336✔





652



      if (code) {




5,336✔





653



        // error










654



        break;




×







655



      } else if (!pNewFunc) {




5,336✔





656



        // no need state func










657



        continue;




×







658



      } else {










659



        REPLACE_NODE(pNewFunc);




5,336✔





660



        nodesDestroyNode(pNode);




5,336✔





661



      }










662



    }










663



  }










664



  return code;




2,204✔





665



}










666












667



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




1,276✔





668



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




1,276✔





669



    SNodeList* pParams = NULL;




1,044✔





670



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




1,044✔





671



    if (!pParams) return code;




1,044✔





672



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




1,044✔





673



    if (TSDB_CODE_SUCCESS != code) {




1,044✔





674



      nodesDestroyList(pParams);




×







675



      return code;




×







676



    }










677



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




1,044✔





678



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




1,044✔





679



  }










680



  return TSDB_CODE_SUCCESS;




1,276✔





681



}










682












683



int32_t fmCreateStateMergeFuncs(SNodeList* pFuncs) {




580✔





684



  int32_t code;










685



  SNode*  pNode;










686



  char    buf[128] = {0};




580✔





687



  FOREACH(pNode, pFuncs) {




1,856✔





688



    SFunctionNode* pFunc = (SFunctionNode*)pNode;




1,276✔





689



    if (fmIsTSMASupportedFunc(pFunc->funcId)) {




1,276✔





690



      SFunctionNode* pNewFunc = NULL;




1,276✔





691



      code = fmCreateStateMergeFunc(pFunc, &pNewFunc);




1,276✔





692



      if (code) {




1,276✔





693



        // error










694



        break;




×







695



      } else if (!pNewFunc) {




1,276✔





696



        // no state merge func










697



        continue;




232✔





698



      } else {










699



        REPLACE_NODE(pNewFunc);




1,044✔





700



        nodesDestroyNode(pNode);




1,044✔





701



      }










702



    }










703



  }










704



  return code;




580✔





705



}










706












707



int32_t fmGetFuncId(const char* name) {




1,423,232✔





708



  if (NULL != gFunMgtService.pFuncNameHashTable) {




1,423,232✔





709



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




1,423,232✔





710



    if (NULL != pVal) {




1,423,232✔





711



      return *(int32_t*)pVal;




1,423,232✔





712



    }










713



    return -1;




×







714



  }










715



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




×







716



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




×







717



      return i;




×







718



    }










719



  }










720



  return -1;




×







721



}










722












723



bool fmIsMyStateFunc(int32_t funcId, int32_t stateFuncId) {




1,587,228✔





724



  const SBuiltinFuncDefinition* pFunc = &funcMgtBuiltins[funcId];




1,587,228✔





725



  const SBuiltinFuncDefinition* pStateFunc = &funcMgtBuiltins[stateFuncId];




1,587,228✔





726



  if (!pFunc->pStateFunc) {




1,587,228✔





727



    return false;




×







728



  }










729



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




1,587,228✔





730



  int32_t stateMergeFuncId = fmGetFuncId(pFunc->pStateFunc);




582,668✔





731



  if (stateMergeFuncId == -1) {




582,668✔





732



    return false;




×







733



  }










734



  const SBuiltinFuncDefinition* pStateMergeFunc = &funcMgtBuiltins[stateMergeFuncId];




582,668✔





735



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




582,668✔





736



}










737












738



bool fmIsCountLikeFunc(int32_t funcId) {




466,566,811✔





739



  return isSpecificClassifyFunc(funcId, FUNC_MGT_COUNT_LIKE_FUNC);




466,566,811✔





740



}










741












742



bool fmIsRowTsOriginFunc(int32_t funcId) {




4,975,253✔





743



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




4,975,253✔





744



    return false;




×







745



  }










746



  return FUNCTION_TYPE_IROWTS_ORIGIN == funcMgtBuiltins[funcId].type;




4,975,253✔





747



}










748












749



bool fmIsGroupIdFunc(int32_t funcId) {




×







750



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




×







751



    return false;




×







752



  }










753



  return FUNCTION_TYPE_GROUP_ID == funcMgtBuiltins[funcId].type;




×







754



}










755












756



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




41,529,943✔





757



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




41,529,943✔





758



  switch (funcMgtBuiltins[funcId].type) {




41,533,709✔





759



    case FUNCTION_TYPE_TPREV_TS:




×







760



      return &pParams->prevTs;




×







761



    case FUNCTION_TYPE_TCURRENT_TS:




1,930,875✔





762



      return &pParams->currentTs;




1,930,875✔





763



    case FUNCTION_TYPE_TNEXT_TS:




×







764



      return &pParams->nextTs;




×







765



    case FUNCTION_TYPE_TWSTART:




20,074,463✔





766



      return &pParams->wstart;




20,074,463✔





767



    case FUNCTION_TYPE_TWEND:




15,352,582✔





768



      return &pParams->wend;




15,352,582✔





769



    case FUNCTION_TYPE_TWDURATION:




843,626✔





770



      return &pParams->wduration;




843,626✔





771



    case FUNCTION_TYPE_TWROWNUM:




90,922✔





772



      return &pParams->wrownum;




90,922✔





773



    case FUNCTION_TYPE_TPREV_LOCALTIME:




140,181✔





774



      return &pParams->prevLocalTime;




140,181✔





775



    case FUNCTION_TYPE_TLOCALTIME:




397,342✔





776



      return &pParams->triggerTime;




397,342✔





777



    case FUNCTION_TYPE_TNEXT_LOCALTIME:




217,353✔





778



      return &pParams->nextLocalTime;




217,353✔





779



    case FUNCTION_TYPE_TGRPID:




110,351✔





780



      return &pStreamRuntimeFuncInfo->groupId;




110,351✔





781



    case FUNCTION_TYPE_PLACEHOLDER_COLUMN:




699,375✔





782



      return pStreamRuntimeFuncInfo->pStreamPartColVals;




699,375✔





783



    case FUNCTION_TYPE_PLACEHOLDER_TBNAME:




1,677,268✔





784



      return pStreamRuntimeFuncInfo->pStreamPartColVals;




1,677,268✔





785



    default:




×







786



      break;




×







787



  }










788



  return NULL;




×







789



}










790












791



bool fmIsStreamPesudoColVal(int32_t funcId) {




422,950✔





792



  return funcMgtBuiltins[funcId].type == FUNCTION_TYPE_PLACEHOLDER_COLUMN




422,950✔





793



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




422,950✔





794



}










795












796



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




6,201,371✔





797



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




6,201,371✔





798



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




288✔





799



    return TSDB_CODE_INTERNAL_ERROR;




×







800



  }










801












802



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




6,201,563✔





803



  if (QUERY_NODE_VALUE != firstParamType) {




6,201,826✔





804



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




×







805



    return TSDB_CODE_INTERNAL_ERROR;




×







806



  }










807












808



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




6,201,826✔





809



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




6,202,140✔





810












811



  return TSDB_CODE_SUCCESS;




6,202,332✔





812



}










813












814












815



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




41,514,652✔





816



  if (!pStreamRuntimeInfo) {




41,514,652✔





817



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




×







818



    return TSDB_CODE_INTERNAL_ERROR;




×







819



  }










820



  int32_t code = 0;




41,514,652✔





821



  SArray *pVals1 = NULL;




41,514,652✔





822



  SNode* pFirstParam = nodesListGetNode(pParamNodes, 0);




41,514,652✔





823



  if (nodeType(pFirstParam) != QUERY_NODE_VALUE) {




41,522,034✔





824



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




×







825



    return TSDB_CODE_INTERNAL_ERROR;




×







826



  }










827












828



  int32_t t = funcMgtBuiltins[funcId].type;




41,522,078✔





829



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




41,520,821✔





830



  if (FUNCTION_TYPE_TGRPID == t) {




41,533,240✔





831



    SValue v = {0};




110,351✔





832



    v.type = TSDB_DATA_TYPE_BIGINT;




110,351✔





833



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




110,351✔





834



    










835



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




110,351✔





836



    if (code != 0) {




110,351✔





837



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




×







838



      return code;




×







839



    }










840



  } else if (FUNCTION_TYPE_PLACEHOLDER_COLUMN == t) {




41,422,889✔





841



    SNode* pSecondParam = nodesListGetNode(pParamNodes, 1);




699,375✔





842



    if (nodeType(pSecondParam) != QUERY_NODE_VALUE) {




699,625✔





843



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




×







844



      return TSDB_CODE_INTERNAL_ERROR;




×







845



    }










846



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




699,375✔





847



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




699,375✔





848



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




699,375✔





849



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




×







850



      return TSDB_CODE_INTERNAL_ERROR;




×







851



    }










852



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




699,625✔





853



    if (pValue == NULL) {




699,375✔





854



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




×







855



      return TSDB_CODE_INTERNAL_ERROR;




×







856



    }










857



    if (!pValue->isNull){




699,375✔





858



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




693,570✔





859



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




×







860



        return TSDB_CODE_INTERNAL_ERROR;




×







861



      }










862



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




693,570✔





863



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




493,266✔





864



        if (tmp == NULL) {




493,093✔





865



          return TSDB_CODE_OUT_OF_MEMORY;




×







866



        }










867



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




493,093✔





868



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




493,093✔





869



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




493,093✔





870



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




493,093✔





871



      } else {










872



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




200,304✔





873



      }










874



    }










875



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




699,375✔





876



  } else if (FUNCTION_TYPE_PLACEHOLDER_TBNAME == t) {




40,723,514✔





877



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




1,676,243✔





878



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




2,011,854✔





879



      SStreamGroupValue* pValue = taosArrayGet(pVal, i);




2,011,337✔





880



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




2,011,593✔





881



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




1,678,024✔





882



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




1,677,774✔





883



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




1,676,753✔





884



          return terrno;




×







885



        }










886












887



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




1,676,737✔





888



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




1,677,518✔





889



        break;




1,678,024✔





890



      }










891



    }










892



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




78,089,135✔





893



    // twstart, twend










894



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




39,046,612✔





895



    if (!pVal) {




39,045,634✔





896



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




×







897



      return TSDB_CODE_INTERNAL_ERROR;




×







898



    }










899



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




39,045,634✔





900



    if (code != 0) {




39,042,838✔





901



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




974✔





902



      return code;




×







903



    }










904



  } else {










905



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




5,837✔





906



    return TSDB_CODE_INTERNAL_ERROR;




×







907



  }










908



  










909



  return code;




41,528,337✔





910



}










911












912












913


























    

  • 

    •