replace sprintf with strcat

include/util/tutil.h

@@ -80,6 +80,11 @@ static FORCE_INLINE void taosEncryptPass_c(uint8_t *inBuf, size_t len, char *tar
   (void)memcpy(target, buf, TSDB_PASSWORD_LEN);
 }
 
+static FORCE_INLINE int32_t taosHashBinary(char* pBuf, int32_t len) {
+  uint64_t hashVal = MurmurHash3_64(pBuf, len);
+  return sprintf(pBuf, "%" PRIu64, hashVal);
+}
+
 static FORCE_INLINE int32_t taosCreateMD5Hash(char *pBuf, int32_t len) {
   T_MD5_CTX ctx;
   tMD5Init(&ctx);
@@ -87,11 +92,10 @@ static FORCE_INLINE int32_t taosCreateMD5Hash(char *pBuf, int32_t len) {
   tMD5Final(&ctx);
   char   *p = pBuf;
   int32_t resLen = 0;
-  for (uint8_t i = 0; i < tListLen(ctx.digest); ++i) {
+  return sprintf(pBuf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", ctx.digest[0], ctx.digest[1],
-    resLen += snprintf(p, 3, "%02x", ctx.digest[i]);
+                 ctx.digest[2], ctx.digest[3], ctx.digest[4], ctx.digest[5], ctx.digest[6], ctx.digest[7],
-    p += 2;
+                 ctx.digest[8], ctx.digest[9], ctx.digest[10], ctx.digest[11], ctx.digest[12], ctx.digest[13],
-  }
+                 ctx.digest[14], ctx.digest[15]);
-  return resLen;
 }
 
 static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen, int32_t method, int32_t prefix,

source/libs/function/src/functionMgt.c

@@ -434,7 +434,7 @@ static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNod
   (*pPartialFunc)->originalFuncId = pSrcFunc->hasOriginalFunc ? pSrcFunc->originalFuncId : pSrcFunc->funcId;
   char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
   int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", (*pPartialFunc)->functionName, pSrcFunc);
-  (void)taosCreateMD5Hash(name, len);
+  (void)taosHashBinary(name, len);
   (void)strncpy((*pPartialFunc)->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
   (*pPartialFunc)->hasPk = pSrcFunc->hasPk;
   (*pPartialFunc)->pkBytes = pSrcFunc->pkBytes;

source/libs/parser/src/parAstCreater.c

@@ -325,6 +325,8 @@ SNode* releaseRawExprNode(SAstCreateContext* pCxt, SNode* pNode) {
         sprintf(p, "%02x", ctx.digest[i]);
         p += 2;
       }
+      uint64_t a = MurmurHash3_64(pRawExpr->p, pRawExpr->n);
+      sprintf(pExpr->aliasName, "%"PRIu64, a);
       strncpy(pExpr->userAlias, pRawExpr->p, len);
       pExpr->userAlias[len] = '\0';
     }

source/libs/parser/src/parTranslater.c

@@ -4805,7 +4805,7 @@ static int32_t createMultiResFunc(SFunctionNode* pSrcFunc, SExprNode* pExpr, SNo
       strcpy(pFunc->node.aliasName, pCol->colName);
     } else {
       len = snprintf(buf, sizeof(buf) - 1, "%s(%s.%s)", pSrcFunc->functionName, pCol->tableAlias, pCol->colName);
-      (void)taosCreateMD5Hash(buf, len);
+      (void)taosHashBinary(buf, len);
       strncpy(pFunc->node.aliasName, buf, TSDB_COL_NAME_LEN - 1);
       len = snprintf(buf, sizeof(buf) - 1, "%s(%s)", pSrcFunc->functionName, pCol->colName);
       // note: userAlias could be truncated here
@@ -4813,7 +4813,7 @@ static int32_t createMultiResFunc(SFunctionNode* pSrcFunc, SExprNode* pExpr, SNo
     }
   } else {
     len = snprintf(buf, sizeof(buf) - 1, "%s(%s)", pSrcFunc->functionName, pExpr->aliasName);
-    (void)taosCreateMD5Hash(buf, len);
+    (void)taosHashBinary(buf, len);
     strncpy(pFunc->node.aliasName, buf, TSDB_COL_NAME_LEN - 1);
     len = snprintf(buf, sizeof(buf) - 1, "%s(%s)", pSrcFunc->functionName, pExpr->userAlias);
     // note: userAlias could be truncated here

source/libs/planner/src/planOptimizer.c

@@ -3164,7 +3164,7 @@ static void partTagsSetAlias(char* pAlias, const char* pTableAlias, const char*
   char    name[TSDB_COL_FNAME_LEN + 1] = {0};
   int32_t len = snprintf(name, TSDB_COL_FNAME_LEN, "%s.%s", pTableAlias, pColName);
 
-  (void)taosCreateMD5Hash(name, len);
+  (void)taosHashBinary(name, len);
   strncpy(pAlias, name, TSDB_COL_NAME_LEN - 1);
 }
 
@@ -3827,7 +3827,7 @@ static int32_t rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNod
     int64_t pointer = (int64_t)pFunc;
     char    name[TSDB_FUNC_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
     int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pFunc->functionName, pointer);
-    (void)taosCreateMD5Hash(name, len);
+    (void)taosHashBinary(name, len);
     strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
   }
   SNode* pNew = NULL;
@@ -7197,7 +7197,7 @@ static int32_t tsmaOptCreateWStart(int8_t precision, SFunctionNode** pWStartOut)
   int64_t pointer = (int64_t)pWStart;
   char    name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
   int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWStart->functionName, pointer);
-  (void)taosCreateMD5Hash(name, len);
+  (void)taosHashBinary(name, len);
   strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
   pWStart->node.resType.precision = precision;
 

source/libs/planner/src/planPhysiCreater.c

@@ -39,47 +39,101 @@ typedef struct SPhysiPlanContext {
   bool          hasSysScan;
 } SPhysiPlanContext;
 
-static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char* pKey, int32_t keyBufSize) {
+static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int32_t *pLen) {
-  int32_t len = 0;
+  int32_t code = 0;
   if (QUERY_NODE_COLUMN == nodeType(pNode)) {
     SColumnNode* pCol = (SColumnNode*)pNode;
     if (NULL != pStmtName) {
       if ('\0' != pStmtName[0]) {
-        len = snprintf(pKey, keyBufSize, "%s.%s", pStmtName, pCol->node.aliasName);
+        *ppKey = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1 + TSDB_COL_NAME_LEN + 1);
-        return taosCreateMD5Hash(pKey, len);
+        if (!*ppKey) {
+          return terrno;
+        }
+        strcat(*ppKey, pStmtName);
+        strcat(*ppKey, ".");
+        strcat(*ppKey, pCol->node.aliasName);
+        *pLen = taosHashBinary(*ppKey, strlen(*ppKey));
+        return code;
       } else {
-        return snprintf(pKey, keyBufSize, "%s", pCol->node.aliasName);
+        *ppKey = taosMemoryCalloc(1, TSDB_COL_NAME_LEN + 1);
+        if (!*ppKey) {
+          return terrno;
+        }
+        strcat(*ppKey, pCol->node.aliasName);
+        *pLen = strlen(*ppKey);
+        return code;
       }
     }
     if ('\0' == pCol->tableAlias[0]) {
-      return snprintf(pKey, keyBufSize, "%s", pCol->colName);
+      *ppKey = taosMemoryCalloc(1, TSDB_COL_NAME_LEN + 1);
+      if (!*ppKey) {
+        return terrno;
+      }
+      strcat(*ppKey, pCol->colName);
+      *pLen = strlen(*ppKey);
+      return code;
     }
 
-    len = snprintf(pKey, keyBufSize, "%s.%s", pCol->tableAlias, pCol->colName);
+    *ppKey = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1 + TSDB_COL_NAME_LEN + 1);
-    return taosCreateMD5Hash(pKey, len);
+    if (!*ppKey) {
+      return terrno;
+    }
+    strcat(*ppKey, pCol->tableAlias);
+    strcat(*ppKey, ".");
+    strcat(*ppKey, pCol->colName);
+    *pLen = taosHashBinary(*ppKey, strlen(*ppKey));
+    return code;
   } else if (QUERY_NODE_FUNCTION == nodeType(pNode)) {
     SFunctionNode* pFunc = (SFunctionNode*)pNode;
     if (FUNCTION_TYPE_TBNAME == pFunc->funcType) {
       SValueNode* pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 0);
       if (pVal) {
         if (NULL != pStmtName && '\0' != pStmtName[0]) {
-          len = snprintf(pKey, keyBufSize, "%s.%s", pStmtName, ((SExprNode*)pNode)->aliasName);
+          *ppKey = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1 + TSDB_COL_NAME_LEN + 1);
-          return taosCreateMD5Hash(pKey, len);
+          if (!*ppKey) {
+            return terrno;
+          }
+          strcat(*ppKey, pStmtName);
+          strcat(*ppKey, ".");
+          strcat(*ppKey, ((SExprNode*)pNode)->aliasName);
+          *pLen = taosHashBinary(*ppKey, strlen(*ppKey));
+          return code;
         }
-        len = snprintf(pKey, keyBufSize, "%s.%s", pVal->literal, ((SExprNode*)pNode)->aliasName);
+        *ppKey = taosMemoryCalloc(1, strlen(pVal->literal) + 1 + TSDB_COL_NAME_LEN + 1);
-        return taosCreateMD5Hash(pKey, len);
+        if (!*ppKey) {
+          return terrno;
+        }
+        strcat(*ppKey, pVal->literal);
+        strcat(*ppKey, ".");
+        strcat(*ppKey, ((SExprNode*)pNode)->aliasName);
+        *pLen = taosHashBinary(*ppKey, strlen(*ppKey));
+        return code;
       }
     }
   }
 
   if (NULL != pStmtName && '\0' != pStmtName[0]) {
-    len = snprintf(pKey, keyBufSize, "%s.%s", pStmtName, ((SExprNode*)pNode)->aliasName);
+    *ppKey = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1 + TSDB_COL_NAME_LEN + 1);
-    return taosCreateMD5Hash(pKey, len);
+    if (!*ppKey) {
+      return terrno;
+    }
+    strcat(*ppKey, pStmtName);
+    strcat(*ppKey, ".");
+    strcat(*ppKey, ((SExprNode*)pNode)->aliasName);
+    *pLen = taosHashBinary(*ppKey, strlen(*ppKey));
+    return code;
   }
 
-  return snprintf(pKey, keyBufSize, "%s", ((SExprNode*)pNode)->aliasName);
+  *ppKey = taosMemoryCalloc(1, TSDB_COL_NAME_LEN + 1);
+  if (!*ppKey) {
+    return terrno;
+  }
+  strcat(*ppKey, ((SExprNode*)pNode)->aliasName);
+  *pLen = strlen(*ppKey);
+  return code;
 }
 
+
 static SNode* createSlotDesc(SPhysiPlanContext* pCxt, const char* pName, const SNode* pNode, int16_t slotId,
                              bool output, bool reserve) {
   SSlotDescNode* pSlot = NULL;
@@ -132,8 +186,8 @@ static int32_t putSlotToHashImpl(int16_t dataBlockId, int16_t slotId, const char
   return taosHashPut(pHash, pName, len, &index, sizeof(SSlotIndex));
 }
 
-static int32_t putSlotToHash(const char* pName, int16_t dataBlockId, int16_t slotId, SNode* pNode, SHashObj* pHash) {
+static int32_t putSlotToHash(const char* pName, int32_t len, int16_t dataBlockId, int16_t slotId, SNode* pNode, SHashObj* pHash) {
-  return putSlotToHashImpl(dataBlockId, slotId, pName, strlen(pName), pHash);
+  return putSlotToHashImpl(dataBlockId, slotId, pName, len, pHash);
 }
 
 static int32_t createDataBlockDescHash(SPhysiPlanContext* pCxt, int32_t capacity, int16_t dataBlockId,
@@ -162,12 +216,16 @@ static int32_t buildDataBlockSlots(SPhysiPlanContext* pCxt, SNodeList* pList, SD
   int16_t slotId = 0;
   SNode*  pNode = NULL;
   FOREACH(pNode, pList) {
-    char name[TSDB_COL_FNAME_LEN + 1] = {0};
+    char* name = NULL;
-    (void)getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN);
+    int32_t len = 0;
-    code = nodesListStrictAppend(pDataBlockDesc->pSlots, createSlotDesc(pCxt, name, pNode, slotId, true, false));
+    code = getSlotKey(pNode, NULL, &name, &len);
     if (TSDB_CODE_SUCCESS == code) {
-      code = putSlotToHash(name, pDataBlockDesc->dataBlockId, slotId, pNode, pHash);
+      code = nodesListStrictAppend(pDataBlockDesc->pSlots, createSlotDesc(pCxt, name, pNode, slotId, true, false));
     }
+    if (TSDB_CODE_SUCCESS == code) {
+      code = putSlotToHash(name, len, pDataBlockDesc->dataBlockId, slotId, pNode, pHash);
+    }
+    taosMemoryFree(name);
     if (TSDB_CODE_SUCCESS == code) {
       pDataBlockDesc->totalRowSize += ((SExprNode*)pNode)->resType.bytes;
       pDataBlockDesc->outputRowSize += ((SExprNode*)pNode)->resType.bytes;
@@ -226,25 +284,29 @@ static int32_t addDataBlockSlotsImpl(SPhysiPlanContext* pCxt, SNodeList* pList,
   SNode*    pNode = NULL;
   FOREACH(pNode, pList) {
     SNode*      pExpr = QUERY_NODE_ORDER_BY_EXPR == nodeType(pNode) ? ((SOrderByExprNode*)pNode)->pExpr : pNode;
-    char        name[TSDB_COL_FNAME_LEN + 1] = {0};
+    char        *name = NULL;
-    int32_t     len = getSlotKey(pExpr, pStmtName, name, TSDB_COL_FNAME_LEN);
+    int32_t     len = 0;
-    SSlotIndex* pIndex = taosHashGet(pHash, name, len);
+    code = getSlotKey(pExpr, pStmtName, &name, &len);
-    if (NULL == pIndex) {
+    if (TSDB_CODE_SUCCESS == code) {
-      code =
+      SSlotIndex* pIndex = taosHashGet(pHash, name, len);
+      if (NULL == pIndex) {
+        code =
           nodesListStrictAppend(pDataBlockDesc->pSlots, createSlotDesc(pCxt, name, pExpr, nextSlotId, output, reserve));
-      if (TSDB_CODE_SUCCESS == code) {
+        if (TSDB_CODE_SUCCESS == code) {
-        code = putSlotToHashImpl(pDataBlockDesc->dataBlockId, nextSlotId, name, len, pHash);
+          code = putSlotToHashImpl(pDataBlockDesc->dataBlockId, nextSlotId, name, len, pHash);
+        }
+        pDataBlockDesc->totalRowSize += ((SExprNode*)pExpr)->resType.bytes;
+        if (output) {
+          pDataBlockDesc->outputRowSize += ((SExprNode*)pExpr)->resType.bytes;
+        }
+        slotId = nextSlotId;
+        ++nextSlotId;
+      } else {
+        slotId = getUnsetSlotId(pIndex->pSlotIdsInfo);
       }
-      pDataBlockDesc->totalRowSize += ((SExprNode*)pExpr)->resType.bytes;
-      if (output) {
-        pDataBlockDesc->outputRowSize += ((SExprNode*)pExpr)->resType.bytes;
-      }
-      slotId = nextSlotId;
-      ++nextSlotId;
-    } else {
-      slotId = getUnsetSlotId(pIndex->pSlotIdsInfo);
     }
 
+      taosMemoryFree(name);
     if (TSDB_CODE_SUCCESS == code) {
       SNode* pTarget = NULL;
       code = createTarget(pNode, pDataBlockDesc->dataBlockId, slotId, &pTarget);
@@ -315,8 +377,12 @@ static void dumpSlots(const char* pName, SHashObj* pHash) {
 static EDealRes doSetSlotId(SNode* pNode, void* pContext) {
   if (QUERY_NODE_COLUMN == nodeType(pNode) && 0 != strcmp(((SColumnNode*)pNode)->colName, "*")) {
     SSetSlotIdCxt* pCxt = (SSetSlotIdCxt*)pContext;
-    char           name[TSDB_COL_FNAME_LEN + 1] = {0};
+    char           *name = NULL;
-    int32_t        len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN);
+    int32_t        len = 0;
+    pCxt->errCode = getSlotKey(pNode, NULL, &name, &len);
+    if (TSDB_CODE_SUCCESS != pCxt->errCode) {
+      return DEAL_RES_ERROR;
+    }
     SSlotIndex*    pIndex = taosHashGet(pCxt->pLeftHash, name, len);
     if (NULL == pIndex) {
       pIndex = taosHashGet(pCxt->pRightHash, name, len);
@@ -327,8 +393,10 @@ static EDealRes doSetSlotId(SNode* pNode, void* pContext) {
       dumpSlots("left datablock desc", pCxt->pLeftHash);
       dumpSlots("right datablock desc", pCxt->pRightHash);
       pCxt->errCode = TSDB_CODE_PLAN_INTERNAL_ERROR;
+      taosMemoryFree(name);
       return DEAL_RES_ERROR;
     }
+    taosMemoryFree(name);
     ((SColumnNode*)pNode)->dataBlockId = pIndex->dataBlockId;
     ((SColumnNode*)pNode)->slotId = ((SSlotIdInfo*)taosArrayGet(pIndex->pSlotIdsInfo, 0))->slotId;
     return DEAL_RES_IGNORE_CHILD;
@@ -1174,7 +1242,6 @@ static int32_t createHashJoinColList(int16_t lBlkId, int16_t rBlkId, SNode* pEq1
 
 static int32_t sortHashJoinTargets(int16_t lBlkId, int16_t rBlkId, SHashJoinPhysiNode* pJoin) {
   SNode*  pNode = NULL;
-  char name[TSDB_COL_FNAME_LEN + 1] = {0};
   SSHashObj* pHash = tSimpleHashInit(pJoin->pTargets->length, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY));
   if (NULL == pHash) {
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -1185,8 +1252,13 @@ static int32_t sortHashJoinTargets(int16_t lBlkId, int16_t rBlkId, SHashJoinPhys
   if (TSDB_CODE_SUCCESS  == code) {
     FOREACH(pNode, pJoin->pTargets) {
       SColumnNode* pCol = (SColumnNode*)pNode;
-      int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN);
+      char *pName = NULL;
-      code = tSimpleHashPut(pHash, name, len, &pCol, POINTER_BYTES);
+      int32_t len = 0;
+      code = getSlotKey(pNode, NULL, &pName, &len);
+      if (TSDB_CODE_SUCCESS == code) {
+        code = tSimpleHashPut(pHash, pName, len, &pCol, POINTER_BYTES);
+      }
+      taosMemoryFree(pName);
       if (TSDB_CODE_SUCCESS  != code) {
         break;
       }
@@ -1197,36 +1269,44 @@ static int32_t sortHashJoinTargets(int16_t lBlkId, int16_t rBlkId, SHashJoinPhys
     pJoin->pTargets = pNew;
 
     FOREACH(pNode, pJoin->pOnLeft) {
+      char* pName = NULL;
       SColumnNode* pCol = (SColumnNode*)pNode;
-      int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN);
+      int32_t len = 0;
-      SNode** p = tSimpleHashGet(pHash, name, len);
+      code = getSlotKey(pNode, NULL, &pName, &len);
-      if (p) {
+      if (TSDB_CODE_SUCCESS == code) {
-        code = nodesListStrictAppend(pJoin->pTargets, *p);
+        SNode** p = tSimpleHashGet(pHash, pName, len);
-        if (TSDB_CODE_SUCCESS != code) {
+        if (p) {
-          break;
+          code = nodesListStrictAppend(pJoin->pTargets, *p);
-        }
+          if (TSDB_CODE_SUCCESS == code) {
-        code = tSimpleHashRemove(pHash, name, len);
+            code = tSimpleHashRemove(pHash, pName, len);
-        if (TSDB_CODE_SUCCESS != code) {
+          }
-          break;
         }
       }
+      taosMemoryFree(pName);
+      if (TSDB_CODE_SUCCESS != code) {
+        break;
+      }
     }
   }
   if (TSDB_CODE_SUCCESS == code) {
     FOREACH(pNode, pJoin->pOnRight) {
+      char* pName = NULL;
       SColumnNode* pCol = (SColumnNode*)pNode;
-      int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN);
+      int32_t len = 0;
-      SNode** p = tSimpleHashGet(pHash, name, len);
+      code = getSlotKey(pNode, NULL, &pName, &len);
-      if (p) {
+      if (TSDB_CODE_SUCCESS == code) {
-        code = nodesListStrictAppend(pJoin->pTargets, *p);
+        SNode** p = tSimpleHashGet(pHash, pName, len);
-        if (TSDB_CODE_SUCCESS != code) {
+        if (p) {
-          break;
+          code = nodesListStrictAppend(pJoin->pTargets, *p);
-        }
+          if (TSDB_CODE_SUCCESS == code) {
-        code = tSimpleHashRemove(pHash, name, len);
+            code = tSimpleHashRemove(pHash, pName, len);
-        if (TSDB_CODE_SUCCESS != code) {
+          }
-          break;
         }
       }
+      taosMemoryFree(pName);
+      if (TSDB_CODE_SUCCESS != code) {
+        break;
+      }
     }
   }
   if (TSDB_CODE_SUCCESS == code) {

source/libs/planner/src/planSpliter.c

@@ -432,7 +432,7 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr
   int64_t pointer = (int64_t)pWStart;
   char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
   int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWStart->functionName, pointer);
-  (void)taosCreateMD5Hash(name, len);
+  (void)taosHashBinary(name, len);
   strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
   pWStart->node.resType.precision = precision;
 
@@ -464,7 +464,7 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) {
   int64_t pointer = (int64_t)pWEnd;
   char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0};
   int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWEnd->functionName, pointer);
-  (void)taosCreateMD5Hash(name, len);
+  (void)taosHashBinary(name, len);
   strncpy(pWEnd->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
 
   code = fmGetFuncInfo(pWEnd, NULL, 0);

source/libs/planner/src/planUtil.c

@@ -631,7 +631,7 @@ SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) {
     if (TSDB_CODE_SUCCESS == code) {
       char    name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
       int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", pFunc->functionName, pFunc);
-      (void)taosCreateMD5Hash(name, len);
+      (void)taosHashBinary(name, len);
       strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
     }
   }