diff --git a/include/common/tmsg.h b/include/common/tmsg.h index cab8fea374..968db0c2ad 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -70,11 +70,7 @@ typedef uint16_t tmsg_t; #define TSDB_IE_TYPE_DNODE_EXT 6 #define TSDB_IE_TYPE_DNODE_STATE 7 -enum { - CONN_TYPE__QUERY = 1, - CONN_TYPE__TMQ, - CONN_TYPE__MAX -}; +enum { CONN_TYPE__QUERY = 1, CONN_TYPE__TMQ, CONN_TYPE__MAX }; enum { HEARTBEAT_KEY_DBINFO = 1, @@ -342,13 +338,13 @@ int32_t tSerializeSConnectReq(void* buf, int32_t bufLen, SConnectReq* pReq); int32_t tDeserializeSConnectReq(void* buf, int32_t bufLen, SConnectReq* pReq); typedef struct { - int32_t acctId; - int64_t clusterId; + int32_t acctId; + int64_t clusterId; uint32_t connId; - int8_t superUser; - int8_t connType; - SEpSet epSet; - char sVersion[128]; + int8_t superUser; + int8_t connType; + SEpSet epSet; + char sVersion[128]; } SConnectRsp; int32_t tSerializeSConnectRsp(void* buf, int32_t bufLen, SConnectRsp* pRsp); @@ -663,14 +659,13 @@ typedef struct { int32_t outputLen; int32_t bufSize; int64_t signature; - int32_t commentSize; - int32_t codeSize; - char pComment[TSDB_FUNC_COMMENT_LEN]; - char pCode[TSDB_FUNC_CODE_LEN]; + char* pComment; + char* pCode; } SCreateFuncReq; int32_t tSerializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq); int32_t tDeserializeSCreateFuncReq(void* buf, int32_t bufLen, SCreateFuncReq* pReq); +void tFreeSCreateFuncReq(SCreateFuncReq* pReq); typedef struct { char name[TSDB_FUNC_NAME_LEN]; @@ -687,6 +682,7 @@ typedef struct { int32_t tSerializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq); int32_t tDeserializeSRetrieveFuncReq(void* buf, int32_t bufLen, SRetrieveFuncReq* pReq); +void tFreeSRetrieveFuncReq(SRetrieveFuncReq* pReq); typedef struct { char name[TSDB_FUNC_NAME_LEN]; @@ -698,8 +694,8 @@ typedef struct { int64_t signature; int32_t commentSize; int32_t codeSize; - char pComment[TSDB_FUNC_COMMENT_LEN]; - char pCode[TSDB_FUNC_CODE_LEN]; + char* pComment; + char* pCode; } SFuncInfo; typedef struct { @@ -709,6 +705,7 @@ typedef struct { int32_t tSerializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp); int32_t tDeserializeSRetrieveFuncRsp(void* buf, int32_t bufLen, SRetrieveFuncRsp* pRsp); +void tFreeSRetrieveFuncRsp(SRetrieveFuncRsp* pRsp); typedef struct { int32_t statusInterval; @@ -1213,12 +1210,12 @@ typedef struct { #define STREAM_TRIGGER_WINDOW_CLOSE 2 typedef struct { - char name[TSDB_TOPIC_FNAME_LEN]; - char outputSTbName[TSDB_TABLE_FNAME_LEN]; - int8_t igExists; - char* sql; - char* ast; - int8_t triggerType; + char name[TSDB_TOPIC_FNAME_LEN]; + char outputSTbName[TSDB_TABLE_FNAME_LEN]; + int8_t igExists; + char* sql; + char* ast; + int8_t triggerType; int64_t watermark; } SCMCreateStreamReq; @@ -1671,14 +1668,14 @@ typedef struct { int32_t pid; char fqdn[TSDB_FQDN_LEN]; int32_t subPlanNum; - SArray* subDesc; // SArray + SArray* subDesc; // SArray } SQueryDesc; typedef struct { - uint32_t connId; - int32_t pid; - char app[TSDB_APP_NAME_LEN]; - SArray* queryDesc; // SArray + uint32_t connId; + int32_t pid; + char app[TSDB_APP_NAME_LEN]; + SArray* queryDesc; // SArray } SQueryHbReqBasic; typedef struct { @@ -1742,7 +1739,7 @@ static FORCE_INLINE void tFreeClientHbReq(void* pReq) { } taosMemoryFreeClear(req->query); } - + if (req->info) { tFreeReqKvHash(req->info); taosHashCleanup(req->info); diff --git a/include/util/tdef.h b/include/util/tdef.h index 5fc30540ee..5b863f5920 100644 --- a/include/util/tdef.h +++ b/include/util/tdef.h @@ -128,17 +128,17 @@ extern const int32_t TYPE_BYTES[15]; #define TSDB_INS_TABLE_QUERIES "queries" #define TSDB_INS_TABLE_VNODES "vnodes" -#define TSDB_PERFORMANCE_SCHEMA_DB "performance_schema" -#define TSDB_PERFS_TABLE_CONNECTIONS "connections" -#define TSDB_PERFS_TABLE_QUERIES "queries" -#define TSDB_PERFS_TABLE_TOPICS "topics" -#define TSDB_PERFS_TABLE_CONSUMERS "consumers" -#define TSDB_PERFS_TABLE_SUBSCRIBES "subscribes" +#define TSDB_PERFORMANCE_SCHEMA_DB "performance_schema" +#define TSDB_PERFS_TABLE_CONNECTIONS "connections" +#define TSDB_PERFS_TABLE_QUERIES "queries" +#define TSDB_PERFS_TABLE_TOPICS "topics" +#define TSDB_PERFS_TABLE_CONSUMERS "consumers" +#define TSDB_PERFS_TABLE_SUBSCRIBES "subscribes" #define TSDB_INDEX_TYPE_SMA "SMA" #define TSDB_INDEX_TYPE_FULLTEXT "FULLTEXT" -#define TSDB_INS_USER_STABLES_DBNAME_COLID 2 +#define TSDB_INS_USER_STABLES_DBNAME_COLID 2 #define TSDB_TICK_PER_SECOND(precision) \ ((int64_t)((precision) == TSDB_TIME_PRECISION_MILLI ? 1e3L \ @@ -234,8 +234,8 @@ typedef enum ELogicConditionType { #define TSDB_DB_FNAME_LEN (TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN) #define TSDB_FUNC_NAME_LEN 65 -#define TSDB_FUNC_COMMENT_LEN 4096 -#define TSDB_FUNC_CODE_LEN (65535 - 512) +#define TSDB_FUNC_COMMENT_LEN 1024 * 1024 +#define TSDB_FUNC_CODE_LEN 10 * 1024 * 1024 #define TSDB_FUNC_BUF_SIZE 512 #define TSDB_FUNC_TYPE_SCALAR 1 #define TSDB_FUNC_TYPE_AGGREGATE 2 @@ -339,12 +339,12 @@ typedef enum ELogicConditionType { #define TSDB_MAX_TOTAL_BLOCKS 10000 #define TSDB_DEFAULT_TOTAL_BLOCKS 6 -#define TSDB_MIN_DAYS_PER_FILE 60 // unit minute +#define TSDB_MIN_DAYS_PER_FILE 60 // unit minute #define TSDB_MAX_DAYS_PER_FILE (3650 * 1440) #define TSDB_DEFAULT_DAYS_PER_FILE (10 * 1440) #define TSDB_MIN_KEEP (1 * 1440) // data in db to be reserved. unit minute -#define TSDB_MAX_KEEP (365000 * 1440) // data in db to be reserved. +#define TSDB_MAX_KEEP (365000 * 1440) // data in db to be reserved. #define TSDB_DEFAULT_KEEP (3650 * 1440) // ten years #define TSDB_MIN_MIN_ROW_FBLOCK 10 @@ -419,11 +419,11 @@ typedef enum ELogicConditionType { #define TSDB_DEFAULT_EXPLAIN_VERBOSE false -#define TSDB_MIN_EXPLAIN_RATIO 0 -#define TSDB_MAX_EXPLAIN_RATIO 1 -#define TSDB_DEFAULT_EXPLAIN_RATIO 0.001 +#define TSDB_MIN_EXPLAIN_RATIO 0 +#define TSDB_MAX_EXPLAIN_RATIO 1 +#define TSDB_DEFAULT_EXPLAIN_RATIO 0.001 -#define TSDB_EXPLAIN_RESULT_ROW_SIZE 1024 +#define TSDB_EXPLAIN_RESULT_ROW_SIZE 1024 #define TSDB_EXPLAIN_RESULT_COLUMN_NAME "QUERY PLAN" #define TSDB_MAX_JOIN_TABLE_NUM 10 @@ -509,13 +509,13 @@ enum { SND_WORKER_TYPE__UNIQUE, }; -#define MNODE_HANDLE -1 -#define QNODE_HANDLE 1 +#define MNODE_HANDLE -1 +#define QNODE_HANDLE 1 #define DEFAULT_HANDLE 0 -#define TSDB_CONFIG_OPTION_LEN 16 -#define TSDB_CONIIG_VALUE_LEN 48 -#define TSDB_CONFIG_NUMBER 8 +#define TSDB_CONFIG_OPTION_LEN 16 +#define TSDB_CONIIG_VALUE_LEN 48 +#define TSDB_CONFIG_NUMBER 8 #define QUERY_ID_SIZE 20 #define QUERY_OBJ_ID_SIZE 18 @@ -524,7 +524,6 @@ enum { #define MAX_NUM_STR_SIZE 40 - #ifdef __cplusplus } #endif diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 3adb0102ce..a21fc81bfa 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -142,10 +142,10 @@ static int32_t tSerializeSClientHbReq(SCoder *pEncoder, const SClientHbReq *pReq if (tEncodeU32(pEncoder, pReq->query->connId) < 0) return -1; if (tEncodeI32(pEncoder, pReq->query->pid) < 0) return -1; if (tEncodeCStr(pEncoder, pReq->query->app) < 0) return -1; - + int32_t num = taosArrayGetSize(pReq->query->queryDesc); if (tEncodeI32(pEncoder, num) < 0) return -1; - + for (int32_t i = 0; i < num; ++i) { SQueryDesc *desc = taosArrayGet(pReq->query->queryDesc, i); if (tEncodeCStr(pEncoder, desc->sql) < 0) return -1; @@ -169,7 +169,7 @@ static int32_t tSerializeSClientHbReq(SCoder *pEncoder, const SClientHbReq *pReq if (tEncodeI32(pEncoder, queryNum) < 0) return -1; } } - + int32_t kvNum = taosHashGetSize(pReq->info); if (tEncodeI32(pEncoder, kvNum) < 0) return -1; void *pIter = taosHashIterate(pReq->info, NULL); @@ -200,7 +200,7 @@ static int32_t tDeserializeSClientHbReq(SCoder *pDecoder, SClientHbReq *pReq) { if (num > 0) { pReq->query->queryDesc = taosArrayInit(num, sizeof(SQueryDesc)); if (NULL == pReq->query->queryDesc) return -1; - + for (int32_t i = 0; i < num; ++i) { SQueryDesc desc = {0}; if (tDecodeCStrTo(pDecoder, desc.sql) < 0) return -1; @@ -217,7 +217,7 @@ static int32_t tDeserializeSClientHbReq(SCoder *pDecoder, SClientHbReq *pReq) { if (snum > 0) { desc.subDesc = taosArrayInit(snum, sizeof(SQuerySubDesc)); if (NULL == desc.subDesc) return -1; - + for (int32_t m = 0; m < snum; ++m) { SQuerySubDesc sDesc = {0}; if (tDecodeI64(pDecoder, &sDesc.tid) < 0) return -1; @@ -254,7 +254,7 @@ static int32_t tSerializeSClientHbRsp(SCoder *pEncoder, const SClientHbRsp *pRsp int32_t queryNum = 0; if (pRsp->query) { queryNum = 1; - if (tEncodeI32(pEncoder, queryNum) < 0) return -1; + if (tEncodeI32(pEncoder, queryNum) < 0) return -1; if (tEncodeU32(pEncoder, pRsp->query->connId) < 0) return -1; if (tEncodeU64(pEncoder, pRsp->query->killRid) < 0) return -1; if (tEncodeI32(pEncoder, pRsp->query->totalDnodes) < 0) return -1; @@ -262,9 +262,9 @@ static int32_t tSerializeSClientHbRsp(SCoder *pEncoder, const SClientHbRsp *pRsp if (tEncodeI8(pEncoder, pRsp->query->killConnection) < 0) return -1; if (tEncodeSEpSet(pEncoder, &pRsp->query->epSet) < 0) return -1; } else { - if (tEncodeI32(pEncoder, queryNum) < 0) return -1; + if (tEncodeI32(pEncoder, queryNum) < 0) return -1; } - + int32_t kvNum = taosArrayGetSize(pRsp->info); if (tEncodeI32(pEncoder, kvNum) < 0) return -1; for (int32_t i = 0; i < kvNum; i++) { @@ -1492,10 +1492,25 @@ int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq if (tEncodeI32(&encoder, pReq->outputLen) < 0) return -1; if (tEncodeI32(&encoder, pReq->bufSize) < 0) return -1; if (tEncodeI64(&encoder, pReq->signature) < 0) return -1; - if (tEncodeI32(&encoder, pReq->commentSize) < 0) return -1; - if (tEncodeI32(&encoder, pReq->codeSize) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1; - if (tEncodeCStr(&encoder, pReq->pCode) < 0) return -1; + + int32_t codeSize = 0; + if (pReq->pCode != NULL) { + codeSize = strlen(pReq->pCode) + 1; + } + if (tEncodeI32(&encoder, codeSize) < 0) return -1; + if (pReq->pCode != NULL) { + if (tEncodeCStr(&encoder, pReq->pCode) < 0) return -1; + } + + int32_t commentSize = 0; + if (pReq->pComment != NULL) { + commentSize = strlen(pReq->pComment) + 1; + } + if (tEncodeI32(&encoder, commentSize) < 0) return -1; + if (pReq->pComment != NULL) { + if (tEncodeCStr(&encoder, pReq->pComment) < 0) return -1; + } + tEndEncode(&encoder); int32_t tlen = encoder.pos; @@ -1516,16 +1531,40 @@ int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pR if (tDecodeI32(&decoder, &pReq->outputLen) < 0) return -1; if (tDecodeI32(&decoder, &pReq->bufSize) < 0) return -1; if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->commentSize) < 0) return -1; - if (tDecodeI32(&decoder, &pReq->codeSize) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1; - if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1; + + int32_t codeSize = 0; + if (tDecodeI32(&decoder, &codeSize) < 0) return -1; + if (codeSize > 0) { + pReq->pCode = taosMemoryCalloc(1, codeSize); + if (pReq->pCode == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + if (tDecodeCStrTo(&decoder, pReq->pCode) < 0) return -1; + } + + int32_t commentSize = 0; + if (tDecodeI32(&decoder, &commentSize) < 0) return -1; + if (commentSize > 0) { + pReq->pComment = taosMemoryCalloc(1, commentSize); + if (pReq->pComment == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + if (tDecodeCStrTo(&decoder, pReq->pComment) < 0) return -1; + } + tEndDecode(&decoder); tCoderClear(&decoder); return 0; } +void tFreeSCreateFuncReq(SCreateFuncReq *pReq) { + taosMemoryFree(pReq->pCode); + taosMemoryFree(pReq->pComment); +} + int32_t tSerializeSDropFuncReq(void *buf, int32_t bufLen, SDropFuncReq *pReq) { SCoder encoder = {0}; tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); @@ -1594,6 +1633,8 @@ int32_t tDeserializeSRetrieveFuncReq(void *buf, int32_t bufLen, SRetrieveFuncReq return 0; } +void tFreeSRetrieveFuncReq(SRetrieveFuncReq *pReq) { taosArrayDestroy(pReq->pFuncNames); } + int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp *pRsp) { SCoder encoder = {0}; tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); @@ -1612,10 +1653,10 @@ int32_t tSerializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp * if (tEncodeI32(&encoder, pInfo->outputLen) < 0) return -1; if (tEncodeI32(&encoder, pInfo->bufSize) < 0) return -1; if (tEncodeI64(&encoder, pInfo->signature) < 0) return -1; - if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1; if (tEncodeI32(&encoder, pInfo->codeSize) < 0) return -1; - if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1; + if (tEncodeI32(&encoder, pInfo->commentSize) < 0) return -1; if (tEncodeCStr(&encoder, pInfo->pCode) < 0) return -1; + if (tEncodeCStr(&encoder, pInfo->pComment) < 0) return -1; } tEndEncode(&encoder); @@ -1644,10 +1685,17 @@ int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp if (tDecodeI32(&decoder, &fInfo.outputLen) < 0) return -1; if (tDecodeI32(&decoder, &fInfo.bufSize) < 0) return -1; if (tDecodeI64(&decoder, &fInfo.signature) < 0) return -1; - if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1; if (tDecodeI32(&decoder, &fInfo.codeSize) < 0) return -1; - if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1; + if (tDecodeI32(&decoder, &fInfo.commentSize) < 0) return -1; + fInfo.pCode = taosMemoryCalloc(1, fInfo.codeSize); + fInfo.pComment = taosMemoryCalloc(1, fInfo.commentSize); + if (fInfo.pCode == NULL || fInfo.pComment == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return -1; + } + if (tDecodeCStrTo(&decoder, fInfo.pCode) < 0) return -1; + if (tDecodeCStrTo(&decoder, fInfo.pComment) < 0) return -1; taosArrayPush(pRsp->pFuncInfos, &fInfo); } tEndDecode(&decoder); @@ -1656,6 +1704,16 @@ int32_t tDeserializeSRetrieveFuncRsp(void *buf, int32_t bufLen, SRetrieveFuncRsp return 0; } +void tFreeSRetrieveFuncRsp(SRetrieveFuncRsp *pRsp) { + int32_t size = taosArrayGetSize(pRsp->pFuncInfos); + for (int32_t i = 0; i < size; ++i) { + SFuncInfo *pInfo = taosArrayGet(pRsp->pFuncInfos, i); + taosMemoryFree(pInfo->pCode); + taosMemoryFree(pInfo->pComment); + } + taosArrayDestroy(pRsp->pFuncInfos); +} + int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) { SCoder encoder = {0}; tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER); diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c index a18afbea73..26c7b4d200 100644 --- a/source/dnode/mnode/impl/src/mndFunc.c +++ b/source/dnode/mnode/impl/src/mndFunc.c @@ -34,7 +34,7 @@ static int32_t mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc); static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq); static int32_t mndProcessDropFuncReq(SNodeMsg *pReq); static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq); -static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows); +static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static void mndCancelGetNextFunc(SMnode *pMnode, void *pIter); int32_t mndInitFunc(SMnode *pMnode) { @@ -63,28 +63,28 @@ static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) { int32_t size = pFunc->commentSize + pFunc->codeSize + sizeof(SFuncObj) + SDB_FUNC_RESERVE_SIZE; SSdbRaw *pRaw = sdbAllocRaw(SDB_FUNC, SDB_FUNC_VER, size); - if (pRaw == NULL) goto FUNC_ENCODE_OVER; + if (pRaw == NULL) goto _OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_ENCODE_OVER) - SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, FUNC_ENCODE_OVER) - SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, FUNC_ENCODE_OVER) - SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, FUNC_ENCODE_OVER) - SDB_SET_INT8(pRaw, dataPos, pFunc->align, FUNC_ENCODE_OVER) - SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, FUNC_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, FUNC_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, FUNC_ENCODE_OVER) - SDB_SET_INT64(pRaw, dataPos, pFunc->signature, FUNC_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, FUNC_ENCODE_OVER) - SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, FUNC_ENCODE_OVER) - SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_ENCODE_OVER) - SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_ENCODE_OVER) - SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_ENCODE_OVER) - SDB_SET_DATALEN(pRaw, dataPos, FUNC_ENCODE_OVER); + SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, _OVER) + SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, _OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, _OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, _OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->align, _OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, _OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, _OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, _OVER) + SDB_SET_INT64(pRaw, dataPos, pFunc->signature, _OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, _OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER) + SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER) + SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER) + SDB_SET_DATALEN(pRaw, dataPos, _OVER); terrno = 0; -FUNC_ENCODE_OVER: +_OVER: if (terrno != 0) { mError("func:%s, failed to encode to raw:%p since %s", pFunc->name, pRaw, terrstr()); sdbFreeRaw(pRaw); @@ -99,45 +99,45 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) { terrno = TSDB_CODE_OUT_OF_MEMORY; int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto FUNC_DECODE_OVER; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER; if (sver != SDB_FUNC_VER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - goto FUNC_DECODE_OVER; + goto _OVER; } SSdbRow *pRow = sdbAllocRow(sizeof(SFuncObj)); - if (pRow == NULL) goto FUNC_DECODE_OVER; + if (pRow == NULL) goto _OVER; SFuncObj *pFunc = sdbGetRowObj(pRow); - if (pFunc == NULL) goto FUNC_DECODE_OVER; + if (pFunc == NULL) goto _OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_DECODE_OVER) - SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, FUNC_DECODE_OVER) - SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, FUNC_DECODE_OVER) - SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, FUNC_DECODE_OVER) - SDB_GET_INT8(pRaw, dataPos, &pFunc->align, FUNC_DECODE_OVER) - SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, FUNC_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, FUNC_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, FUNC_DECODE_OVER) - SDB_GET_INT64(pRaw, dataPos, &pFunc->signature, FUNC_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, FUNC_DECODE_OVER) - SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, FUNC_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, _OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, _OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, _OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->align, _OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pFunc->signature, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, _OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, _OVER) pFunc->pComment = taosMemoryCalloc(1, pFunc->commentSize); pFunc->pCode = taosMemoryCalloc(1, pFunc->codeSize); if (pFunc->pComment == NULL || pFunc->pCode == NULL) { - goto FUNC_DECODE_OVER; + goto _OVER; } - SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_DECODE_OVER) - SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_DECODE_OVER) - SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER) + SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER) + SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER) terrno = 0; -FUNC_DECODE_OVER: +_OVER: if (terrno != 0) { mError("func:%s, failed to decode from raw:%p since %s", pFunc->name, pRaw, terrstr()); taosMemoryFreeClear(pRow); @@ -192,40 +192,40 @@ static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCr func.outputLen = pCreate->outputLen; func.bufSize = pCreate->bufSize; func.signature = pCreate->signature; - func.commentSize = pCreate->commentSize; - func.codeSize = pCreate->codeSize; + func.commentSize = strlen(pCreate->pComment) + 1; + func.codeSize = strlen(pCreate->pCode) + 1; func.pComment = taosMemoryMalloc(func.commentSize); func.pCode = taosMemoryMalloc(func.codeSize); if (func.pCode == NULL || func.pCode == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - goto CREATE_FUNC_OVER; + goto _OVER; } - memcpy(func.pComment, pCreate->pComment, pCreate->commentSize); + memcpy(func.pComment, pCreate->pComment, func.commentSize); memcpy(func.pCode, pCreate->pCode, func.codeSize); pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_FUNC, &pReq->rpcMsg); - if (pTrans == NULL) goto CREATE_FUNC_OVER; + if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to create func:%s", pTrans->id, pCreate->name); SSdbRaw *pRedoRaw = mndFuncActionEncode(&func); - if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto CREATE_FUNC_OVER; - if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto CREATE_FUNC_OVER; + if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER; + if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto _OVER; SSdbRaw *pUndoRaw = mndFuncActionEncode(&func); - if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto CREATE_FUNC_OVER; - if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto CREATE_FUNC_OVER; + if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER; + if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto _OVER; SSdbRaw *pCommitRaw = mndFuncActionEncode(&func); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto CREATE_FUNC_OVER; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto CREATE_FUNC_OVER; + if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER; + if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto _OVER; - if (mndTransPrepare(pMnode, pTrans) != 0) goto CREATE_FUNC_OVER; + if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; -CREATE_FUNC_OVER: +_OVER: taosMemoryFree(func.pCode); taosMemoryFree(func.pComment); mndTransDrop(pTrans); @@ -235,27 +235,27 @@ CREATE_FUNC_OVER: static int32_t mndDropFunc(SMnode *pMnode, SNodeMsg *pReq, SFuncObj *pFunc) { int32_t code = -1; STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_DROP_FUNC, &pReq->rpcMsg); - if (pTrans == NULL) goto DROP_FUNC_OVER; + if (pTrans == NULL) goto _OVER; mDebug("trans:%d, used to drop user:%s", pTrans->id, pFunc->name); SSdbRaw *pRedoRaw = mndFuncActionEncode(pFunc); - if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto DROP_FUNC_OVER; + if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER; sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING); SSdbRaw *pUndoRaw = mndFuncActionEncode(pFunc); - if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto DROP_FUNC_OVER; + if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER; sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY); SSdbRaw *pCommitRaw = mndFuncActionEncode(pFunc); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto DROP_FUNC_OVER; + if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER; sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED); - if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_FUNC_OVER; + if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; code = 0; -DROP_FUNC_OVER: +_OVER: mndTransDrop(pTrans); return code; } @@ -269,7 +269,7 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) { if (tDeserializeSCreateFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto CREATE_FUNC_OVER; + goto _OVER; } mDebug("func:%s, start to create", createReq.name); @@ -279,60 +279,66 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) { if (createReq.igExists) { mDebug("func:%s, already exist, ignore exist is set", createReq.name); code = 0; - goto CREATE_FUNC_OVER; + goto _OVER; } else { terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST; - goto CREATE_FUNC_OVER; + goto _OVER; } } else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) { - goto CREATE_FUNC_OVER; + goto _OVER; } if (createReq.name[0] == 0) { terrno = TSDB_CODE_MND_INVALID_FUNC_NAME; - goto CREATE_FUNC_OVER; + goto _OVER; } - if (createReq.commentSize <= 0 || createReq.commentSize > TSDB_FUNC_COMMENT_LEN) { + if (createReq.pComment == NULL) { terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT; - goto CREATE_FUNC_OVER; + goto _OVER; } - if (createReq.codeSize <= 0 || createReq.codeSize > TSDB_FUNC_CODE_LEN) { + if (createReq.pComment[0] == 0) { + terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT; + goto _OVER; + } + + if (createReq.pCode == NULL) { terrno = TSDB_CODE_MND_INVALID_FUNC_CODE; - goto CREATE_FUNC_OVER; + goto _OVER; } if (createReq.pCode[0] == 0) { terrno = TSDB_CODE_MND_INVALID_FUNC_CODE; - goto CREATE_FUNC_OVER; + goto _OVER; } if (createReq.bufSize <= 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) { terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE; - goto CREATE_FUNC_OVER; + goto _OVER; } pUser = mndAcquireUser(pMnode, pReq->user); if (pUser == NULL) { terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; - goto CREATE_FUNC_OVER; + goto _OVER; } if (mndCheckFuncAuth(pUser)) { - goto CREATE_FUNC_OVER; + goto _OVER; } code = mndCreateFunc(pMnode, pReq, &createReq); if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; -CREATE_FUNC_OVER: +_OVER: if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { mError("func:%s, failed to create since %s", createReq.name, terrstr()); } mndReleaseFunc(pMnode, pFunc); mndReleaseUser(pMnode, pUser); + tFreeSCreateFuncReq(&createReq); return code; } @@ -346,14 +352,14 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) { if (tDeserializeSDropFuncReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) { terrno = TSDB_CODE_INVALID_MSG; - goto DROP_FUNC_OVER; + goto _OVER; } mDebug("func:%s, start to drop", dropReq.name); if (dropReq.name[0] == 0) { terrno = TSDB_CODE_MND_INVALID_FUNC_NAME; - goto DROP_FUNC_OVER; + goto _OVER; } pFunc = mndAcquireFunc(pMnode, dropReq.name); @@ -361,27 +367,27 @@ static int32_t mndProcessDropFuncReq(SNodeMsg *pReq) { if (dropReq.igNotExists) { mDebug("func:%s, not exist, ignore not exist is set", dropReq.name); code = 0; - goto DROP_FUNC_OVER; + goto _OVER; } else { terrno = TSDB_CODE_MND_FUNC_NOT_EXIST; - goto DROP_FUNC_OVER; + goto _OVER; } } pUser = mndAcquireUser(pMnode, pReq->user); if (pUser == NULL) { terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; - goto DROP_FUNC_OVER; + goto _OVER; } if (mndCheckFuncAuth(pUser)) { - goto DROP_FUNC_OVER; + goto _OVER; } code = mndDropFunc(pMnode, pReq, pFunc); if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS; -DROP_FUNC_OVER: +_OVER: if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { mError("func:%s, failed to drop since %s", dropReq.name, terrstr()); } @@ -434,6 +440,12 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) { funcInfo.signature = pFunc->signature; funcInfo.commentSize = pFunc->commentSize; funcInfo.codeSize = pFunc->codeSize; + funcInfo.pCode = taosMemoryCalloc(1, sizeof(funcInfo.codeSize)); + funcInfo.pComment = taosMemoryCalloc(1, sizeof(funcInfo.commentSize)); + if (funcInfo.pCode == NULL || funcInfo.pComment == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + goto RETRIEVE_FUNC_OVER; + } memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize); memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize); taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo); @@ -455,8 +467,8 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) { code = 0; RETRIEVE_FUNC_OVER: - taosArrayDestroy(retrieveReq.pFuncNames); - taosArrayDestroy(retrieveRsp.pFuncInfos); + tFreeSRetrieveFuncReq(&retrieveReq); + tFreeSRetrieveFuncRsp(&retrieveRsp); return code; } @@ -479,7 +491,7 @@ static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t le return tDataTypes[type].name; } -static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows) { +static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) { SMnode *pMnode = pReq->pNode; SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; @@ -496,34 +508,35 @@ static int32_t mndRetrieveFuncs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pB char b1[tListLen(pFunc->name) + VARSTR_HEADER_SIZE] = {0}; STR_WITH_MAXSIZE_TO_VARSTR(b1, pFunc->name, pShow->bytes[cols]); - SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) b1, false); + SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)b1, false); - char* b2 = taosMemoryCalloc(1, pShow->bytes[cols]); + char *b2 = taosMemoryCalloc(1, pShow->bytes[cols]); STR_WITH_MAXSIZE_TO_VARSTR(b2, pFunc->pComment, pShow->bytes[cols]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) b2, false); + colDataAppend(pColInfo, numOfRows, (const char *)b2, false); int32_t isAgg = (pFunc->funcType == TSDB_FUNC_TYPE_AGGREGATE) ? 1 : 0; pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &isAgg, false); + colDataAppend(pColInfo, numOfRows, (const char *)&isAgg, false); char b3[TSDB_TYPE_STR_MAX_LEN] = {0}; - STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen), pShow->bytes[cols]); + STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen), + pShow->bytes[cols]); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) b3, false); + colDataAppend(pColInfo, numOfRows, (const char *)b3, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->createdTime, false); + colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->createdTime, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->codeSize, false); + colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->codeSize, false); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataAppend(pColInfo, numOfRows, (const char*) &pFunc->bufSize, false); + colDataAppend(pColInfo, numOfRows, (const char *)&pFunc->bufSize, false); numOfRows++; sdbRelease(pSdb, pFunc); diff --git a/source/dnode/mnode/impl/test/func/func.cpp b/source/dnode/mnode/impl/test/func/func.cpp index 6b9c410738..22b0387d8b 100644 --- a/source/dnode/mnode/impl/test/func/func.cpp +++ b/source/dnode/mnode/impl/test/func/func.cpp @@ -21,10 +21,25 @@ class MndTestFunc : public ::testing::Test { public: void SetUp() override {} void TearDown() override {} + + void SetCode(SCreateFuncReq* pReq, const char* pCode); + void SetComment(SCreateFuncReq* pReq, const char* pComment); }; Testbase MndTestFunc::test; +void MndTestFunc::SetCode(SCreateFuncReq* pReq, const char* pCode) { + int32_t len = strlen(pCode); + pReq->pCode = (char*)taosMemoryCalloc(1, len + 1); + strcpy(pReq->pCode, pCode); +} + +void MndTestFunc::SetComment(SCreateFuncReq* pReq, const char* pComment) { + int32_t len = strlen(pComment); + pReq->pComment = (char*)taosMemoryCalloc(1, len + 1); + strcpy(pReq->pComment, pComment); +} + TEST_F(MndTestFunc, 01_Show_Func) { test.SendShowReq(TSDB_MGMT_TABLE_FUNC, "user_functions", ""); EXPECT_EQ(test.GetShowRows(), 0); @@ -38,6 +53,7 @@ TEST_F(MndTestFunc, 02_Create_Func) { int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -47,10 +63,12 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); + SetCode(&createReq, "code1"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -60,11 +78,28 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN + 1; + SetComment(&createReq, "comment1"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); + + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); + ASSERT_NE(pRsp, nullptr); + ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE); + } + + { + SCreateFuncReq createReq = {0}; + strcpy(createReq.name, "f1"); + SetCode(&createReq, "code1"); + SetComment(&createReq, ""); + + int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); + void* pReq = rpcMallocCont(contLen); + tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -74,11 +109,13 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; + SetCode(&createReq, ""); + SetComment(&createReq, "comment1"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -88,43 +125,13 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN + 1; - - int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); - void* pReq = rpcMallocCont(contLen); - tSerializeSCreateFuncReq(pReq, contLen, &createReq); - - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); - ASSERT_NE(pRsp, nullptr); - ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE); - } - - { - SCreateFuncReq createReq = {0}; - strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN; - - int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); - void* pReq = rpcMallocCont(contLen); - tSerializeSCreateFuncReq(pReq, contLen, &createReq); - - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); - ASSERT_NE(pRsp, nullptr); - ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE); - } - - { - SCreateFuncReq createReq = {0}; - strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN; - createReq.pCode[0] = 'a'; + SetCode(&createReq, "code1"); + SetComment(&createReq, "comment1"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -134,14 +141,14 @@ TEST_F(MndTestFunc, 02_Create_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN; - createReq.pCode[0] = 'a'; + SetCode(&createReq, "code1"); + SetComment(&createReq, "comment1"); createReq.bufSize = TSDB_FUNC_BUF_SIZE + 1; int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -151,9 +158,8 @@ TEST_F(MndTestFunc, 02_Create_Func) { for (int32_t i = 0; i < 3; ++i) { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f1"); - createReq.commentSize = TSDB_FUNC_COMMENT_LEN; - createReq.codeSize = TSDB_FUNC_CODE_LEN; - createReq.pCode[0] = 'a'; + SetCode(&createReq, "code1"); + SetComment(&createReq, "comment1"); createReq.bufSize = TSDB_FUNC_BUF_SIZE + 1; createReq.igExists = 0; if (i == 2) createReq.igExists = 1; @@ -163,16 +169,11 @@ TEST_F(MndTestFunc, 02_Create_Func) { createReq.outputLen = 12; createReq.bufSize = 4; createReq.signature = 5; - for (int32_t i = 0; i < createReq.commentSize - 1; ++i) { - createReq.pComment[i] = 'm'; - } - for (int32_t i = 0; i < createReq.codeSize - 1; ++i) { - createReq.pCode[i] = 'd'; - } int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -197,7 +198,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -217,20 +218,10 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { EXPECT_EQ(pFuncInfo->outputLen, 12); EXPECT_EQ(pFuncInfo->bufSize, 4); EXPECT_EQ(pFuncInfo->signature, 5); - EXPECT_EQ(pFuncInfo->commentSize, TSDB_FUNC_COMMENT_LEN); - EXPECT_EQ(pFuncInfo->codeSize, TSDB_FUNC_CODE_LEN); + EXPECT_STREQ("comment1", pFuncInfo->pComment); + EXPECT_STREQ("code1", pFuncInfo->pCode); - char comments[TSDB_FUNC_COMMENT_LEN] = {0}; - for (int32_t i = 0; i < TSDB_FUNC_COMMENT_LEN - 1; ++i) { - comments[i] = 'm'; - } - char codes[TSDB_FUNC_CODE_LEN] = {0}; - for (int32_t i = 0; i < TSDB_FUNC_CODE_LEN - 1; ++i) { - codes[i] = 'd'; - } - EXPECT_STREQ(comments, pFuncInfo->pComment); - EXPECT_STREQ(codes, pFuncInfo->pCode); - taosArrayDestroy(retrieveRsp.pFuncInfos); + tFreeSRetrieveFuncRsp(&retrieveRsp); } { @@ -241,7 +232,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -259,7 +250,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -275,7 +266,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -285,8 +276,6 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { { SCreateFuncReq createReq = {0}; strcpy(createReq.name, "f2"); - createReq.commentSize = 1024; - createReq.codeSize = 9527; createReq.igExists = 1; createReq.funcType = 2; createReq.scriptType = 3; @@ -294,16 +283,13 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { createReq.outputLen = 24; createReq.bufSize = 6; createReq.signature = 18; - for (int32_t i = 0; i < createReq.commentSize - 1; ++i) { - createReq.pComment[i] = 'p'; - } - for (int32_t i = 0; i < createReq.codeSize - 1; ++i) { - createReq.pCode[i] = 'q'; - } + SetCode(&createReq, "code2"); + SetComment(&createReq, "comment2"); int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq); void* pReq = rpcMallocCont(contLen); tSerializeSCreateFuncReq(pReq, contLen, &createReq); + tFreeSCreateFuncReq(&createReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -322,7 +308,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -342,21 +328,13 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { EXPECT_EQ(pFuncInfo->outputLen, 24); EXPECT_EQ(pFuncInfo->bufSize, 6); EXPECT_EQ(pFuncInfo->signature, 18); - EXPECT_EQ(pFuncInfo->commentSize, 1024); - EXPECT_EQ(pFuncInfo->codeSize, 9527); + EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1); + EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1); - char comments[TSDB_FUNC_COMMENT_LEN] = {0}; - for (int32_t i = 0; i < 1024 - 1; ++i) { - comments[i] = 'p'; - } - char codes[TSDB_FUNC_CODE_LEN] = {0}; - for (int32_t i = 0; i < 9527 - 1; ++i) { - codes[i] = 'q'; - } + EXPECT_STREQ("comment2", pFuncInfo->pComment); + EXPECT_STREQ("code2", pFuncInfo->pCode); - EXPECT_STREQ(comments, pFuncInfo->pComment); - EXPECT_STREQ(codes, pFuncInfo->pCode); - taosArrayDestroy(retrieveRsp.pFuncInfos); + tFreeSRetrieveFuncRsp(&retrieveRsp); } { @@ -369,7 +347,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr); @@ -389,20 +367,10 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { EXPECT_EQ(pFuncInfo->outputLen, 24); EXPECT_EQ(pFuncInfo->bufSize, 6); EXPECT_EQ(pFuncInfo->signature, 18); - EXPECT_EQ(pFuncInfo->commentSize, 1024); - EXPECT_EQ(pFuncInfo->codeSize, 9527); - - char comments[TSDB_FUNC_COMMENT_LEN] = {0}; - for (int32_t i = 0; i < 1024 - 1; ++i) { - comments[i] = 'p'; - } - char codes[TSDB_FUNC_CODE_LEN] = {0}; - for (int32_t i = 0; i < 9527 - 1; ++i) { - codes[i] = 'q'; - } - - EXPECT_STREQ(comments, pFuncInfo->pComment); - EXPECT_STREQ(codes, pFuncInfo->pCode); + EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1); + EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1); + EXPECT_STREQ("comment2", pFuncInfo->pComment); + EXPECT_STREQ("code2", pFuncInfo->pCode); } { @@ -414,21 +382,11 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { EXPECT_EQ(pFuncInfo->outputLen, 12); EXPECT_EQ(pFuncInfo->bufSize, 4); EXPECT_EQ(pFuncInfo->signature, 5); - EXPECT_EQ(pFuncInfo->commentSize, TSDB_FUNC_COMMENT_LEN); - EXPECT_EQ(pFuncInfo->codeSize, TSDB_FUNC_CODE_LEN); - - char comments[TSDB_FUNC_COMMENT_LEN] = {0}; - for (int32_t i = 0; i < TSDB_FUNC_COMMENT_LEN - 1; ++i) { - comments[i] = 'm'; - } - char codes[TSDB_FUNC_CODE_LEN] = {0}; - for (int32_t i = 0; i < TSDB_FUNC_CODE_LEN - 1; ++i) { - codes[i] = 'd'; - } - EXPECT_STREQ(comments, pFuncInfo->pComment); - EXPECT_STREQ(codes, pFuncInfo->pCode); + EXPECT_STREQ("comment1", pFuncInfo->pComment); + EXPECT_STREQ("code1", pFuncInfo->pCode); } - taosArrayDestroy(retrieveRsp.pFuncInfos); + + tFreeSRetrieveFuncRsp(&retrieveRsp); } { @@ -441,7 +399,7 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) { int32_t contLen = tSerializeSRetrieveFuncReq(NULL, 0, &retrieveReq); void* pReq = rpcMallocCont(contLen); tSerializeSRetrieveFuncReq(pReq, contLen, &retrieveReq); - taosArrayDestroy(retrieveReq.pFuncNames); + tFreeSRetrieveFuncReq(&retrieveReq); SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen); ASSERT_NE(pRsp, nullptr);