diff --git a/include/util/tutil.h b/include/util/tutil.h index f1f2914eed..1ee3bb0e83 100644 --- a/include/util/tutil.h +++ b/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) { - resLen += snprintf(p, 3, "%02x", ctx.digest[i]); - p += 2; - } - return resLen; + 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], + ctx.digest[2], ctx.digest[3], ctx.digest[4], ctx.digest[5], ctx.digest[6], ctx.digest[7], + ctx.digest[8], ctx.digest[9], ctx.digest[10], ctx.digest[11], ctx.digest[12], ctx.digest[13], + ctx.digest[14], ctx.digest[15]); } static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen, int32_t method, int32_t prefix, diff --git a/source/libs/function/src/functionMgt.c b/source/libs/function/src/functionMgt.c index 49d700e8c8..e50dbf8b14 100644 --- a/source/libs/function/src/functionMgt.c +++ b/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; diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index cd7cda01e0..fab58814d5 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/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'; } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 7a2a73d013..3ca31fc573 100755 --- a/source/libs/parser/src/parTranslater.c +++ b/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 diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c index 27d3e80ef0..c7ce9aed76 100644 --- a/source/libs/planner/src/planOptimizer.c +++ b/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; diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c index d75e02bc6b..e50e574f01 100644 --- a/source/libs/planner/src/planPhysiCreater.c +++ b/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) { - int32_t len = 0; +static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char** ppKey, int32_t *pLen) { + 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); - return taosCreateMD5Hash(pKey, len); + *ppKey = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1 + TSDB_COL_NAME_LEN + 1); + 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); - return taosCreateMD5Hash(pKey, len); + *ppKey = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1 + TSDB_COL_NAME_LEN + 1); + 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); - return taosCreateMD5Hash(pKey, len); + *ppKey = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1 + TSDB_COL_NAME_LEN + 1); + 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); - return taosCreateMD5Hash(pKey, len); + *ppKey = taosMemoryCalloc(1, strlen(pVal->literal) + 1 + TSDB_COL_NAME_LEN + 1); + 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); - return taosCreateMD5Hash(pKey, len); + *ppKey = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1 + TSDB_COL_NAME_LEN + 1); + 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) { - return putSlotToHashImpl(dataBlockId, slotId, pName, strlen(pName), 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, 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}; - (void)getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); - code = nodesListStrictAppend(pDataBlockDesc->pSlots, createSlotDesc(pCxt, name, pNode, slotId, true, false)); + char* name = NULL; + int32_t len = 0; + 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}; - int32_t len = getSlotKey(pExpr, pStmtName, name, TSDB_COL_FNAME_LEN); - SSlotIndex* pIndex = taosHashGet(pHash, name, len); - if (NULL == pIndex) { - code = + char *name = NULL; + int32_t len = 0; + code = getSlotKey(pExpr, pStmtName, &name, &len); + if (TSDB_CODE_SUCCESS == 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) { - code = putSlotToHashImpl(pDataBlockDesc->dataBlockId, nextSlotId, name, len, pHash); + if (TSDB_CODE_SUCCESS == code) { + 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}; - int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); + char *name = NULL; + 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); - code = tSimpleHashPut(pHash, name, len, &pCol, POINTER_BYTES); + char *pName = NULL; + 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); - SNode** p = tSimpleHashGet(pHash, name, len); - if (p) { - code = nodesListStrictAppend(pJoin->pTargets, *p); - if (TSDB_CODE_SUCCESS != code) { - break; - } - code = tSimpleHashRemove(pHash, name, len); - if (TSDB_CODE_SUCCESS != code) { - break; + int32_t len = 0; + code = getSlotKey(pNode, NULL, &pName, &len); + if (TSDB_CODE_SUCCESS == code) { + SNode** p = tSimpleHashGet(pHash, pName, len); + if (p) { + code = nodesListStrictAppend(pJoin->pTargets, *p); + if (TSDB_CODE_SUCCESS == code) { + code = tSimpleHashRemove(pHash, pName, len); + } } } + 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); - SNode** p = tSimpleHashGet(pHash, name, len); - if (p) { - code = nodesListStrictAppend(pJoin->pTargets, *p); - if (TSDB_CODE_SUCCESS != code) { - break; - } - code = tSimpleHashRemove(pHash, name, len); - if (TSDB_CODE_SUCCESS != code) { - break; + int32_t len = 0; + code = getSlotKey(pNode, NULL, &pName, &len); + if (TSDB_CODE_SUCCESS == code) { + SNode** p = tSimpleHashGet(pHash, pName, len); + if (p) { + code = nodesListStrictAppend(pJoin->pTargets, *p); + if (TSDB_CODE_SUCCESS == code) { + code = tSimpleHashRemove(pHash, pName, len); + } } } + taosMemoryFree(pName); + if (TSDB_CODE_SUCCESS != code) { + break; + } } } if (TSDB_CODE_SUCCESS == code) { diff --git a/source/libs/planner/src/planSpliter.c b/source/libs/planner/src/planSpliter.c index efbcd79b69..706394507a 100644 --- a/source/libs/planner/src/planSpliter.c +++ b/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); diff --git a/source/libs/planner/src/planUtil.c b/source/libs/planner/src/planUtil.c index 91dc36b99f..e1e98f221f 100644 --- a/source/libs/planner/src/planUtil.c +++ b/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); } }