refactor(cluster): make the comment and code of udf to variable length

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<SQuerySubDesc>
+  SArray*  subDesc;  // SArray<SQuerySubDesc>
 } SQueryDesc;
 
 typedef struct {
-  uint32_t   connId;
-  int32_t    pid;
-  char       app[TSDB_APP_NAME_LEN];
-  SArray*    queryDesc;   // SArray<SQueryDesc>
+  uint32_t connId;
+  int32_t  pid;
+  char     app[TSDB_APP_NAME_LEN];
+  SArray*  queryDesc;  // SArray<SQueryDesc>
 } 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);

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

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);

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);

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,25 +78,12 @@ TEST_F(MndTestFunc, 02_Create_Func) {
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_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_COMMENT);
-  }
-
-  {
-    SCreateFuncReq createReq = {0};
-    strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
+    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,27 +93,29 @@ 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;
+    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);
-    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT);
   }
 
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
-    createReq.commentSize = TSDB_FUNC_COMMENT_LEN;
-    createReq.codeSize = TSDB_FUNC_CODE_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);
@@ -118,13 +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;
-    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);