add test cases

include/util/taoserror.h

@@ -239,6 +239,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_INVALID_FUNC_COMMENT      TAOS_DEF_ERROR_CODE(0, 0x03C4)
 #define TSDB_CODE_MND_INVALID_FUNC_CODE         TAOS_DEF_ERROR_CODE(0, 0x03C5)
 #define TSDB_CODE_MND_INVALID_FUNC_BUFSIZE      TAOS_DEF_ERROR_CODE(0, 0x03C6)
+#define TSDB_CODE_MND_INVALID_FUNC_RETRIEVE     TAOS_DEF_ERROR_CODE(0, 0x03C7)
 
 // mnode-trans
 #define TSDB_CODE_MND_TRANS_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x03D0)

include/util/tdef.h

@@ -173,6 +173,7 @@ do { \
 #define TSDB_FUNC_BUF_SIZE        512
 #define TSDB_FUNC_TYPE_SCALAR     1
 #define TSDB_FUNC_TYPE_AGGREGATE  2
+#define TSDB_FUNC_MAX_RETRIEVE    1024
 
 #define TSDB_TYPE_STR_MAX_LEN     32
 #define TSDB_TABLE_FNAME_LEN      (TSDB_DB_FNAME_LEN + TSDB_TABLE_NAME_LEN + TSDB_NAME_DELIMITER_LEN)

source/dnode/mgmt/impl/test/sut/inc/sut.h

@@ -96,6 +96,15 @@ class Testbase {
 #define CheckBinary(val, len) \
   { EXPECT_STREQ(test.GetShowBinary(len), val); }
 
+#define CheckBinaryByte(b, len)                   \
+  {                                               \
+    char* bytes = (char*)calloc(1, len);          \
+    for (int32_t i = 0; i < len - 1; ++i) {       \
+      bytes[i] = b;                             \
+    }                                             \
+    EXPECT_STREQ(test.GetShowBinary(len), bytes); \
+  }
+
 #define CheckInt8(val) \
   { EXPECT_EQ(test.GetShowInt8(), val); }
 

source/dnode/mnode/impl/src/mndFunc.c

@@ -152,6 +152,8 @@ static int32_t mndFuncActionInsert(SSdb *pSdb, SFuncObj *pFunc) {
 
 static int32_t mndFuncActionDelete(SSdb *pSdb, SFuncObj *pFunc) {
   mTrace("func:%s, perform delete action, row:%p", pFunc->name, pFunc);
+  tfree(pFunc->pCode);
+  tfree(pFunc->pComment);
   return 0;
 }
 
@@ -278,7 +280,7 @@ static int32_t mndProcessCreateFuncReq(SMnodeMsg *pReq) {
       mError("func:%s, failed to create since %s", pCreate->name, terrstr());
       return -1;
     }
-  } else if (terrno != TSDB_CODE_MND_FUNC_ALREADY_EXIST) {
+  } else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) {
     mError("stb:%s, failed to create since %s", pCreate->name, terrstr());
     return -1;
   }
@@ -307,7 +309,7 @@ static int32_t mndProcessCreateFuncReq(SMnodeMsg *pReq) {
     return -1;
   }
 
-  if (pCreate->bufSize < 0 || pCreate->bufSize > TSDB_FUNC_BUF_SIZE) {
+  if (pCreate->bufSize <= 0 || pCreate->bufSize > TSDB_FUNC_BUF_SIZE) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
     mError("func:%s, failed to create since %s", pCreate->name, terrstr());
     return -1;
@@ -363,6 +365,10 @@ static int32_t mndProcessRetrieveFuncReq(SMnodeMsg *pReq) {
 
   SRetrieveFuncReq *pRetrieve = pReq->rpcMsg.pCont;
   pRetrieve->numOfFuncs = htonl(pRetrieve->numOfFuncs);
+  if (pRetrieve->numOfFuncs <= 0 || pRetrieve->numOfFuncs > TSDB_FUNC_MAX_RETRIEVE) {
+    terrno = TSDB_CODE_MND_INVALID_FUNC_RETRIEVE;
+    return -1;
+  }
 
   int32_t fsize = sizeof(SFuncInfo) + TSDB_FUNC_CODE_LEN + TSDB_FUNC_COMMENT_LEN;
   int32_t size = sizeof(SRetrieveFuncRsp) + fsize * pRetrieve->numOfFuncs;

source/dnode/mnode/impl/test/CMakeLists.txt

@@ -12,3 +12,4 @@ add_subdirectory(dnode)
 add_subdirectory(mnode)
 add_subdirectory(db)
 add_subdirectory(stb)
+add_subdirectory(func)

source/dnode/mnode/impl/test/func/CMakeLists.txt

@@ -0,0 +1,11 @@
+aux_source_directory(. FUNC_SRC)
+add_executable(mnode_test_func ${FUNC_SRC})
+target_link_libraries(
+    mnode_test_func
+    PUBLIC sut
+)
+
+add_test(
+    NAME mnode_test_func
+    COMMAND mnode_test_func
+)

source/dnode/mnode/impl/test/func/func.cpp

@@ -0,0 +1,607 @@
+/**
+ * @file func.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief MNODE module func tests
+ * @version 1.0
+ * @date 2022-01-24
+ *
+ * @copyright Copyright (c) 2022
+ *
+ */
+
+#include "sut.h"
+
+class MndTestFunc : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() { test.Init("/tmp/mnode_test_func", 9038); }
+  static void TearDownTestSuite() { test.Cleanup(); }
+
+  static Testbase test;
+
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+};
+
+Testbase MndTestFunc::test;
+
+TEST_F(MndTestFunc, 01_Show_Func) {
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+  CHECK_META("show functions", 7);
+
+  CHECK_SCHEMA(0, TSDB_DATA_TYPE_BINARY, TSDB_FUNC_NAME_LEN + VARSTR_HEADER_SIZE, "name");
+  CHECK_SCHEMA(1, TSDB_DATA_TYPE_BINARY, PATH_MAX + VARSTR_HEADER_SIZE, "comment");
+  CHECK_SCHEMA(2, TSDB_DATA_TYPE_INT, 4, "aggregate");
+  CHECK_SCHEMA(3, TSDB_DATA_TYPE_BINARY, TSDB_TYPE_STR_MAX_LEN + VARSTR_HEADER_SIZE, "outputtype");
+  CHECK_SCHEMA(4, TSDB_DATA_TYPE_TIMESTAMP, 8, "create_time");
+  CHECK_SCHEMA(5, TSDB_DATA_TYPE_INT, 4, "code_len");
+  CHECK_SCHEMA(6, TSDB_DATA_TYPE_INT, 4, "bufsize");
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 0);
+}
+
+TEST_F(MndTestFunc, 02_Create_Func) {
+  {
+    int32_t contLen = sizeof(SCreateFuncReq);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "");
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_NAME);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+    pReq->commentSize = htonl(TSDB_FUNC_COMMENT_LEN + 1);
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+    pReq->commentSize = htonl(TSDB_FUNC_COMMENT_LEN);
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+    pReq->commentSize = htonl(TSDB_FUNC_COMMENT_LEN);
+    pReq->codeSize = htonl(TSDB_FUNC_CODE_LEN - 1);
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq) + 24;
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+    pReq->commentSize = htonl(TSDB_FUNC_COMMENT_LEN);
+    pReq->codeSize = htonl(TSDB_FUNC_CODE_LEN);
+    pReq->pCont[0] = 0;
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq) + 24;
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+    pReq->commentSize = htonl(TSDB_FUNC_COMMENT_LEN);
+    pReq->codeSize = htonl(TSDB_FUNC_CODE_LEN);
+    pReq->pCont[0] = 'a';
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_BUFSIZE);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq) + 24;
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+    pReq->commentSize = htonl(TSDB_FUNC_COMMENT_LEN);
+    pReq->codeSize = htonl(TSDB_FUNC_CODE_LEN);
+    pReq->pCont[0] = 'a';
+    pReq->bufSize = htonl(TSDB_FUNC_BUF_SIZE + 1);
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_BUFSIZE);
+  }
+
+  for (int32_t i = 0; i < 3; ++i) {
+    int32_t contLen = sizeof(SCreateFuncReq);
+    int32_t commentSize = TSDB_FUNC_COMMENT_LEN;
+    int32_t codeSize = TSDB_FUNC_CODE_LEN;
+    contLen = (contLen + codeSize + commentSize);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+    pReq->igExists = 0;
+    if (i == 2) pReq->igExists = 1;
+    pReq->funcType = 1;
+    pReq->scriptType = 2;
+    pReq->outputType = TSDB_DATA_TYPE_SMALLINT;
+    pReq->outputLen = htonl(12);
+    pReq->bufSize = htonl(4);
+    pReq->signature = htobe64(5);
+    pReq->commentSize = htonl(commentSize);
+    pReq->codeSize = htonl(codeSize);
+    for (int32_t i = 0; i < commentSize - 1; ++i) {
+      pReq->pCont[i] = 'm';
+    }
+    for (int32_t i = commentSize; i < commentSize + codeSize - 1; ++i) {
+      pReq->pCont[i] = 'd';
+    }
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    if (i == 0 || i == 2) {
+      ASSERT_EQ(pRsp->code, 0);
+    } else {
+      ASSERT_EQ(pRsp->code, TSDB_CODE_MND_FUNC_ALREADY_EXIST);
+    }
+  }
+
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+  CHECK_META("show functions", 7);
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 1);
+
+  CheckBinary("f1", TSDB_FUNC_NAME_LEN);
+  CheckBinaryByte('m', TSDB_FUNC_COMMENT_LEN);
+  CheckInt32(0);
+  CheckBinary("SMALLINT", TSDB_TYPE_STR_MAX_LEN);
+  CheckTimestamp();
+  CheckInt32(TSDB_FUNC_CODE_LEN);
+  CheckInt32(4);
+}
+
+TEST_F(MndTestFunc, 03_Retrieve_Func) {
+  {
+    int32_t contLen = sizeof(SRetrieveFuncReq);
+    int32_t numOfFuncs = 1;
+    contLen = (contLen + numOfFuncs * TSDB_FUNC_NAME_LEN);
+
+    SRetrieveFuncReq* pReq = (SRetrieveFuncReq*)rpcMallocCont(contLen);
+    pReq->numOfFuncs = htonl(1);
+    strcpy(pReq->pFuncNames, "f1");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+
+    SRetrieveFuncRsp* pRetrieveRsp = (SRetrieveFuncRsp*)pRsp->pCont;
+    pRetrieveRsp->numOfFuncs = htonl(pRetrieveRsp->numOfFuncs);
+
+    SFuncInfo* pFuncInfo = (SFuncInfo*)(pRetrieveRsp->pFuncInfos);
+    pFuncInfo->outputLen = htonl(pFuncInfo->outputLen);
+    pFuncInfo->bufSize = htonl(pFuncInfo->bufSize);
+    pFuncInfo->signature = htobe64(pFuncInfo->signature);
+    pFuncInfo->commentSize = htonl(pFuncInfo->commentSize);
+    pFuncInfo->codeSize = htonl(pFuncInfo->codeSize);
+
+    EXPECT_STREQ(pFuncInfo->name, "f1");
+    EXPECT_EQ(pFuncInfo->funcType, 1);
+    EXPECT_EQ(pFuncInfo->scriptType, 2);
+    EXPECT_EQ(pFuncInfo->outputType, TSDB_DATA_TYPE_SMALLINT);
+    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* pComment = pFuncInfo->pCont;
+    char* pCode = pFuncInfo->pCont + pFuncInfo->commentSize;
+    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(pComment, comments);
+    EXPECT_STREQ(pCode, codes);
+  }
+
+  {
+    int32_t contLen = sizeof(SRetrieveFuncReq);
+    int32_t numOfFuncs = 0;
+    contLen = (contLen + numOfFuncs * TSDB_FUNC_NAME_LEN);
+
+    SRetrieveFuncReq* pReq = (SRetrieveFuncReq*)rpcMallocCont(contLen);
+    pReq->numOfFuncs = htonl(numOfFuncs);
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_RETRIEVE);
+  }
+
+  {
+    int32_t contLen = sizeof(SRetrieveFuncReq);
+    int32_t numOfFuncs = TSDB_FUNC_MAX_RETRIEVE + 1;
+    contLen = (contLen + numOfFuncs * TSDB_FUNC_NAME_LEN);
+
+    SRetrieveFuncReq* pReq = (SRetrieveFuncReq*)rpcMallocCont(contLen);
+    pReq->numOfFuncs = htonl(numOfFuncs);
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_RETRIEVE);
+  }
+
+  {
+    int32_t contLen = sizeof(SRetrieveFuncReq);
+    int32_t numOfFuncs = 1;
+    contLen = (contLen + numOfFuncs * TSDB_FUNC_NAME_LEN);
+
+    SRetrieveFuncReq* pReq = (SRetrieveFuncReq*)rpcMallocCont(contLen);
+    pReq->numOfFuncs = htonl(numOfFuncs);
+    strcpy(pReq->pFuncNames, "f2");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq);
+    int32_t commentSize = 1024;
+    int32_t codeSize = 9527;
+    contLen = (contLen + codeSize + commentSize);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f2");
+    pReq->igExists = 1;
+    pReq->funcType = 2;
+    pReq->scriptType = 3;
+    pReq->outputType = TSDB_DATA_TYPE_BINARY;
+    pReq->outputLen = htonl(24);
+    pReq->bufSize = htonl(6);
+    pReq->signature = htobe64(18);
+    pReq->commentSize = htonl(commentSize);
+    pReq->codeSize = htonl(codeSize);
+    for (int32_t i = 0; i < commentSize - 1; ++i) {
+      pReq->pCont[i] = 'p';
+    }
+    for (int32_t i = commentSize; i < commentSize + codeSize - 1; ++i) {
+      pReq->pCont[i] = 'q';
+    }
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+
+    test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+    CHECK_META("show functions", 7);
+
+    test.SendShowRetrieveReq();
+    EXPECT_EQ(test.GetShowRows(), 2);
+  }
+
+  {
+    int32_t contLen = sizeof(SRetrieveFuncReq);
+    int32_t numOfFuncs = 1;
+    contLen = (contLen + numOfFuncs * TSDB_FUNC_NAME_LEN);
+
+    SRetrieveFuncReq* pReq = (SRetrieveFuncReq*)rpcMallocCont(contLen);
+    pReq->numOfFuncs = htonl(1);
+    strcpy(pReq->pFuncNames, "f2");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+
+    SRetrieveFuncRsp* pRetrieveRsp = (SRetrieveFuncRsp*)pRsp->pCont;
+    pRetrieveRsp->numOfFuncs = htonl(pRetrieveRsp->numOfFuncs);
+
+    SFuncInfo* pFuncInfo = (SFuncInfo*)(pRetrieveRsp->pFuncInfos);
+    pFuncInfo->outputLen = htonl(pFuncInfo->outputLen);
+    pFuncInfo->bufSize = htonl(pFuncInfo->bufSize);
+    pFuncInfo->signature = htobe64(pFuncInfo->signature);
+    pFuncInfo->commentSize = htonl(pFuncInfo->commentSize);
+    pFuncInfo->codeSize = htonl(pFuncInfo->codeSize);
+
+    EXPECT_STREQ(pFuncInfo->name, "f2");
+    EXPECT_EQ(pFuncInfo->funcType, 2);
+    EXPECT_EQ(pFuncInfo->scriptType, 3);
+    EXPECT_EQ(pFuncInfo->outputType, TSDB_DATA_TYPE_BINARY);
+    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* pComment = pFuncInfo->pCont;
+    char* pCode = pFuncInfo->pCont + pFuncInfo->commentSize;
+    char* comments = (char*)calloc(1, 1024);
+    for (int32_t i = 0; i < 1024 - 1; ++i) {
+      comments[i] = 'p';
+    }
+    char* codes = (char*)calloc(1, 9527);
+    for (int32_t i = 0; i < 9527 - 1; ++i) {
+      codes[i] = 'q';
+    }
+    EXPECT_STREQ(pComment, comments);
+    EXPECT_STREQ(pCode, codes);
+    free(comments);
+    free(codes);
+  }
+
+  {
+    int32_t contLen = sizeof(SRetrieveFuncReq);
+    int32_t numOfFuncs = 2;
+    contLen = (contLen + numOfFuncs * TSDB_FUNC_NAME_LEN);
+
+    SRetrieveFuncReq* pReq = (SRetrieveFuncReq*)rpcMallocCont(contLen);
+    pReq->numOfFuncs = htonl(1);
+    strcpy(pReq->pFuncNames, "f2");
+    strcpy((char*)pReq->pFuncNames + TSDB_FUNC_NAME_LEN, "f1");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+
+    SRetrieveFuncRsp* pRetrieveRsp = (SRetrieveFuncRsp*)pRsp->pCont;
+    pRetrieveRsp->numOfFuncs = htonl(pRetrieveRsp->numOfFuncs);
+
+    {
+      SFuncInfo* pFuncInfo = (SFuncInfo*)(pRetrieveRsp->pFuncInfos);
+      pFuncInfo->outputLen = htonl(pFuncInfo->outputLen);
+      pFuncInfo->bufSize = htonl(pFuncInfo->bufSize);
+      pFuncInfo->signature = htobe64(pFuncInfo->signature);
+      pFuncInfo->commentSize = htonl(pFuncInfo->commentSize);
+      pFuncInfo->codeSize = htonl(pFuncInfo->codeSize);
+
+      EXPECT_STREQ(pFuncInfo->name, "f2");
+      EXPECT_EQ(pFuncInfo->funcType, 2);
+      EXPECT_EQ(pFuncInfo->scriptType, 3);
+      EXPECT_EQ(pFuncInfo->outputType, TSDB_DATA_TYPE_BINARY);
+      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* pComment = pFuncInfo->pCont;
+      char* pCode = pFuncInfo->pCont + pFuncInfo->commentSize;
+      char* comments = (char*)calloc(1, 1024);
+      for (int32_t i = 0; i < 1024 - 1; ++i) {
+        comments[i] = 'p';
+      }
+      char* codes = (char*)calloc(1, 9527);
+      for (int32_t i = 0; i < 9527 - 1; ++i) {
+        codes[i] = 'q';
+      }
+      EXPECT_STREQ(pComment, comments);
+      EXPECT_STREQ(pCode, codes);
+      free(comments);
+      free(codes);
+    }
+
+    {
+      SFuncInfo* pFuncInfo = (SFuncInfo*)(pRetrieveRsp->pFuncInfos + sizeof(SFuncInfo) + 1024 + 9527);
+      pFuncInfo->outputLen = htonl(pFuncInfo->outputLen);
+      pFuncInfo->bufSize = htonl(pFuncInfo->bufSize);
+      pFuncInfo->signature = htobe64(pFuncInfo->signature);
+      pFuncInfo->commentSize = htonl(pFuncInfo->commentSize);
+      pFuncInfo->codeSize = htonl(pFuncInfo->codeSize);
+      EXPECT_STREQ(pFuncInfo->name, "f1");
+      EXPECT_EQ(pFuncInfo->funcType, 1);
+      EXPECT_EQ(pFuncInfo->scriptType, 2);
+      EXPECT_EQ(pFuncInfo->outputType, TSDB_DATA_TYPE_SMALLINT);
+      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* pComment = pFuncInfo->pCont;
+      // char* pCode = pFuncInfo->pCont + pFuncInfo->commentSize;
+      // 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(pComment, comments);
+      // EXPECT_STREQ(pCode, codes);
+    }
+  }
+}
+
+#if 0
+
+TEST_F(MndTestFunc, 04_Drop_Func) {
+  {
+    int32_t contLen = sizeof(SDropFuncReq);
+
+    SDropFuncReq* pReq = (SDropFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->user, "");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_FORMAT);
+  }
+
+  {
+    int32_t contLen = sizeof(SDropFuncReq);
+
+    SDropFuncReq* pReq = (SDropFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->user, "u4");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_FUNC_NOT_EXIST);
+  }
+
+  {
+    int32_t contLen = sizeof(SDropFuncReq);
+
+    SDropFuncReq* pReq = (SDropFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->user, "u1");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+  CHECK_META("show functions", 4);
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 1);
+}
+
+TEST_F(MndTestFunc, 05_Create_Drop_Alter_Func) {
+  {
+    int32_t contLen = sizeof(SCreateFuncReq);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->user, "u1");
+    strcpy(pReq->pass, "p1");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  {
+    int32_t contLen = sizeof(SCreateFuncReq);
+
+    SCreateFuncReq* pReq = (SCreateFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->user, "u2");
+    strcpy(pReq->pass, "p2");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+  CHECK_META("show functions", 4);
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 3);
+
+  CheckBinary("u1", TSDB_FUNC_LEN);
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("u2", TSDB_FUNC_LEN);
+  CheckBinary("normal", 10);
+  CheckBinary("super", 10);
+  CheckBinary("normal", 10);
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("root", TSDB_FUNC_LEN);
+
+  {
+    int32_t contLen = sizeof(SAlterFuncReq);
+
+    SAlterFuncReq* pReq = (SAlterFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->user, "u1");
+    strcpy(pReq->pass, "p2");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+  CHECK_META("show functions", 4);
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 3);
+
+  CheckBinary("u1", TSDB_FUNC_LEN);
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("u2", TSDB_FUNC_LEN);
+  CheckBinary("normal", 10);
+  CheckBinary("super", 10);
+  CheckBinary("normal", 10);
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("root", TSDB_FUNC_LEN);
+
+  {
+    int32_t contLen = sizeof(SDropFuncReq);
+
+    SDropFuncReq* pReq = (SDropFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->user, "u1");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+  CHECK_META("show functions", 4);
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 2);
+
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("u2", TSDB_FUNC_LEN);
+  CheckBinary("super", 10);
+  CheckBinary("normal", 10);
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("root", TSDB_FUNC_LEN);
+
+  // restart
+  test.Restart();
+
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+  CHECK_META("show functions", 4);
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 2);
+
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("u2", TSDB_FUNC_LEN);
+  CheckBinary("super", 10);
+  CheckBinary("normal", 10);
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckBinary("root", TSDB_FUNC_LEN);
+  CheckBinary("root", TSDB_FUNC_LEN);
+}
+
+#endif

source/util/src/terror.c

@@ -248,6 +248,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_NAME,        "Invalid func name")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_COMMENT,     "Invalid func comment")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_CODE,        "Invalid func code")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_BUFSIZE,     "Invalid func bufSize")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_FUNC_RETRIEVE,     "Invalid func retrieve msg")
 
 // mnode-trans
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_ALREADY_EXIST,       "Transaction already exists")