feat: the function manager adds an interface for manually configuring the...

feat: the function manager adds an interface for manually configuring the parameters of the merge function

source/libs/function/inc/builtins.h

@@ -24,6 +24,7 @@ extern "C" {
 
 typedef int32_t (*FTranslateFunc)(SFunctionNode* pFunc, char* pErrBuf, int32_t len);
 typedef EFuncDataRequired (*FFuncDataRequired)(SFunctionNode* pFunc, STimeWindow* pTimeWindow);
+typedef int32_t (*FCreateMergeFuncParameters)(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters);
 
 typedef struct SBuiltinFuncDefinition {
   const char*                name;
@@ -40,6 +41,7 @@ typedef struct SBuiltinFuncDefinition {
   FExecCombine               combineFunc;
   const char*                pPartialFunc;
   const char*                pMergeFunc;
+  FCreateMergeFuncParameters createMergeParaFuc;
 } SBuiltinFuncDefinition;
 
 extern const SBuiltinFuncDefinition funcMgtBuiltins[];

source/libs/function/inc/functionMgtInt.h

@@ -51,8 +51,6 @@ extern "C" {
 
 #define FUNC_UDF_ID_START 5000
 
-extern const int funcMgtUdfNum;
-
 #ifdef __cplusplus
 }
 #endif

source/libs/function/src/builtins.c

@@ -419,6 +419,14 @@ static int32_t translateTopBot(SFunctionNode* pFunc, char* pErrBuf, int32_t len)
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t topCreateMergePara(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) {
+  int32_t code = nodesListMakeAppend(pParameters, pPartialRes);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = nodesListStrictAppend(*pParameters, nodesCloneNode(nodesListGetNode(pRawParameters, 1)));
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t translateTopBotImpl(SFunctionNode* pFunc, char* pErrBuf, int32_t len, bool isPartial) {
   int32_t numOfParams = LIST_LENGTH(pFunc->pParameterList);
 
@@ -1728,7 +1736,8 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = {
     .finalizeFunc = topBotFinalize,
     .combineFunc  = topCombine,
     .pPartialFunc = "_top_partial",
-    .pMergeFunc   = "_top_merge"
+    .pMergeFunc   = "_top_merge",
+    .createMergeParaFuc = topCreateMergePara
   },
   {
     .name = "_top_partial",

source/libs/function/src/builtinsimpl.c

@@ -2360,12 +2360,10 @@ int32_t apercentileCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx)
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t getFirstLastInfoSize(int32_t resBytes) {
-  return sizeof(SFirstLastRes) + resBytes + sizeof(int64_t);
-}
+int32_t getFirstLastInfoSize(int32_t resBytes) { return sizeof(SFirstLastRes) + resBytes + sizeof(int64_t); }
 
 bool getFirstLastFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
-  SColumnNode* pNode = (SColumnNode *)nodesListGetNode(pFunc->pParameterList, 0);
+  SColumnNode* pNode = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
   pEnv->calcMemSize = sizeof(SFirstLastRes) + pNode->node.resType.bytes + sizeof(int64_t);
   return true;
 }
@@ -2390,7 +2388,7 @@ int32_t firstFunction(SqlFunctionCtx* pCtx) {
   int32_t numOfElems = 0;
 
   SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
-  SFirstLastRes *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);
 
   SInputColumnInfoData* pInput = &pCtx->input;
   SColumnInfoData*      pInputCol = pInput->pData[0];
@@ -2488,7 +2486,7 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) {
   int32_t numOfElems = 0;
 
   SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
-  SFirstLastRes *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);
 
   SInputColumnInfoData* pInput = &pCtx->input;
   SColumnInfoData*      pInputCol = pInput->pData[0];
@@ -2567,8 +2565,8 @@ static void firstLastTransferInfo(SFirstLastRes* pInput, SFirstLastRes* pOutput,
     return;
   }
   pOutput->bytes = pInput->bytes;
-  TSKEY *tsIn = (TSKEY*)(pInput->buf + pInput->bytes);
-  TSKEY *tsOut = (TSKEY*)(pOutput->buf + pInput->bytes);
+  TSKEY* tsIn = (TSKEY*)(pInput->buf + pInput->bytes);
+  TSKEY* tsOut = (TSKEY*)(pOutput->buf + pInput->bytes);
   if (pOutput->hasResult) {
     if (isFirst) {
       if (*tsIn > *tsOut) {
@@ -2586,7 +2584,7 @@ static void firstLastTransferInfo(SFirstLastRes* pInput, SFirstLastRes* pOutput,
   return;
 }
 
-static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx *pCtx, bool isFirstQuery) {
+static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx* pCtx, bool isFirstQuery) {
   SInputColumnInfoData* pInput = &pCtx->input;
   SColumnInfoData*      pCol = pInput->pData[0];
   ASSERT(pCol->info.type == TSDB_DATA_TYPE_BINARY);
@@ -2595,7 +2593,7 @@ static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx *pCtx, bool isFirstQuer
 
   int32_t        start = pInput->startRowIndex;
   char*          data = colDataGetData(pCol, start);
-  SFirstLastRes* pInputInfo = (SFirstLastRes *)varDataVal(data);
+  SFirstLastRes* pInputInfo = (SFirstLastRes*)varDataVal(data);
 
   firstLastTransferInfo(pInputInfo, pInfo, isFirstQuery);
 
@@ -2604,13 +2602,9 @@ static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx *pCtx, bool isFirstQuer
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t firstFunctionMerge(SqlFunctionCtx *pCtx) {
-  return firstLastFunctionMergeImpl(pCtx, true);
-}
+int32_t firstFunctionMerge(SqlFunctionCtx* pCtx) { return firstLastFunctionMergeImpl(pCtx, true); }
 
-int32_t lastFunctionMerge(SqlFunctionCtx *pCtx) {
-  return firstLastFunctionMergeImpl(pCtx, false);
-}
+int32_t lastFunctionMerge(SqlFunctionCtx* pCtx) { return firstLastFunctionMergeImpl(pCtx, false); }
 
 int32_t firstLastFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
@@ -2629,7 +2623,7 @@ int32_t firstLastPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
   SFirstLastRes*       pRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
   int32_t              resultBytes = getFirstLastInfoSize(pRes->bytes);
-  char *res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
+  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
 
   memcpy(varDataVal(res), pRes, resultBytes);
   varDataSetLen(res, resultBytes);
@@ -5178,7 +5172,7 @@ int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
 typedef struct SDerivInfo {
   double  prevValue;       // previous value
   TSKEY   prevTs;          // previous timestamp
-  bool     ignoreNegative;// ignore the negative value
+  bool    ignoreNegative;  // ignore the negative value
   int64_t tsWindow;        // time window for derivative
   bool    valueSet;        // the value has been set already
 } SDerivInfo;
@@ -5188,7 +5182,7 @@ bool getDerivativeFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
   return true;
 }
 
-bool derivativeFuncSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResInfo) {
+bool derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
   if (!functionSetup(pCtx, pResInfo)) {
     return false;  // not initialized since it has been initialized
   }
@@ -5202,8 +5196,8 @@ bool derivativeFuncSetup(SqlFunctionCtx *pCtx, SResultRowEntryInfo* pResInfo) {
   return true;
 }
 
-int32_t derivativeFunction(SqlFunctionCtx *pCtx) {
-  SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
+int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
+  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
   SDerivInfo*          pDerivInfo = GET_ROWCELL_INTERBUF(pResInfo);
 
   SInputColumnInfoData* pInput = &pCtx->input;
@@ -5277,7 +5271,7 @@ int32_t derivativeFunction(SqlFunctionCtx *pCtx) {
   return numOfElems;
 }
 
-int32_t interpFunction(SqlFunctionCtx *pCtx) {
+int32_t interpFunction(SqlFunctionCtx* pCtx) {
 #if 0
   int32_t fillType = (int32_t) pCtx->param[2].i64;
   //bool ascQuery = (pCtx->order == TSDB_ORDER_ASC);

source/libs/function/src/functionMgt.c

@@ -261,14 +261,14 @@ static SFunctionNode* createFunction(const char* pName, SNodeList* pParameterLis
   return pFunc;
 }
 
-static SColumnNode* createColumnByFunc(const SFunctionNode* pFunc) {
+static SNode* createColumnByFunc(const SFunctionNode* pFunc) {
   SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
   if (NULL == pCol) {
     return NULL;
   }
   strcpy(pCol->colName, pFunc->node.aliasName);
   pCol->node.resType = pFunc->node.resType;
-  return pCol;
+  return (SNode*)pCol;
 }
 
 bool fmIsDistExecFunc(int32_t funcId) {
@@ -296,21 +296,45 @@ static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNod
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t createMergeFuncPara(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,
+                                   SNodeList** pParameterList) {
+  SNode* pRes = createColumnByFunc(pPartialFunc);
+  if (NULL != funcMgtBuiltins[pSrcFunc->funcId].createMergeParaFuc) {
+    return funcMgtBuiltins[pSrcFunc->funcId].createMergeParaFuc(pSrcFunc->pParameterList, pRes, pParameterList);
+  } else {
+    return nodesListMakeStrictAppend(pParameterList, pRes);
+  }
+}
+
 static int32_t createMergeFunction(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,
                                    SFunctionNode** pMergeFunc) {
   SNodeList*     pParameterList = NULL;
-  nodesListMakeStrictAppend(&pParameterList, (SNode*)createColumnByFunc(pPartialFunc));
-  *pMergeFunc = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pParameterList);
-  if (NULL == *pMergeFunc) {
-    nodesDestroyList(pParameterList);
-    return TSDB_CODE_OUT_OF_MEMORY;
+  SFunctionNode* pFunc = NULL;
+
+  int32_t code = createMergeFuncPara(pSrcFunc, pPartialFunc, &pParameterList);
+  if (TSDB_CODE_SUCCESS == code) {
+    pFunc = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pParameterList);
+    if (NULL == pFunc) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
     }
+  }
+  if (TSDB_CODE_SUCCESS == code) {
     // overwrite function restype set by translate function
     if (fmIsSameInOutType(pSrcFunc->funcId)) {
       (*pMergeFunc)->node.resType = pSrcFunc->node.resType;
     }
     strcpy((*pMergeFunc)->node.aliasName, pSrcFunc->node.aliasName);
-  return TSDB_CODE_SUCCESS;
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pMergeFunc = pFunc;
+  } else {
+    pFunc->pParameterList = NULL;
+    nodesDestroyNode((SNode*)pFunc);
+    nodesDestroyList(pParameterList);
+  }
+
+  return code;
 }
 
 int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMergeFunc) {