Merge remote-tracking branch 'origin/3.0' into feature/qnode

2.0/src/query/src/queryMain.c

@@ -461,7 +461,7 @@ int32_t qKillQuery(qinfo_t qinfo) {
   }
 
   qDebug("QInfo:0x%"PRIx64" query killed", pQInfo->qId);
-  setQueryKilled(pQInfo);
+  setTaskKilled(pQInfo);
 
   // Wait for the query executing thread being stopped/
   // Once the query is stopped, the owner of qHandle will be cleared immediately.
@@ -634,7 +634,7 @@ int32_t qKillQueryByQId(void* pMgmt, int64_t qId, int32_t waitMs, int32_t waitCo
     return TSDB_CODE_QRY_INVALID_QHANDLE;
   }
   qWarn("QId:0x%"PRIx64" be killed(no memory commit).", pQInfo->qId);
-  setQueryKilled(pQInfo);
+  setTaskKilled(pQInfo);
 
   // wait query stop
   int32_t loop = 0;

include/common/tmsg.h

@@ -107,7 +107,7 @@ typedef enum _mgmt_table {
   TSDB_MGMT_TABLE_CLUSTER,
   TSDB_MGMT_TABLE_STREAMTABLES,
   TSDB_MGMT_TABLE_TP,
-  TSDB_MGMT_TABLE_FUNCTION,
+  TSDB_MGMT_TABLE_FUNC,
   TSDB_MGMT_TABLE_MAX,
 } EShowType;
 
@@ -533,20 +533,21 @@ typedef struct {
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
+  int8_t  igExists;
   int8_t  funcType;
   int8_t  scriptType;
-  int8_t  align;
   int8_t  outputType;
   int32_t outputLen;
   int32_t bufSize;
-  int64_t sigature;
+  int64_t signature;
   int32_t commentSize;
   int32_t codeSize;
   char    pCont[];
 } SCreateFuncReq;
 
 typedef struct {
-  char name[TSDB_FUNC_NAME_LEN];
+  char   name[TSDB_FUNC_NAME_LEN];
+  int8_t igNotExists;
 } SDropFuncReq;
 
 typedef struct {
@@ -556,13 +557,13 @@ typedef struct {
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
+  int8_t  align;
   int8_t  funcType;
   int8_t  scriptType;
-  int8_t  align;
   int8_t  outputType;
   int32_t outputLen;
   int32_t bufSize;
-  int64_t sigature;
+  int64_t signature;
   int32_t commentSize;
   int32_t codeSize;
   char    pCont[];
@@ -1247,6 +1248,12 @@ typedef struct {
   char    data[];
 } SVShowTablesFetchRsp;
 
+typedef struct SMqCMGetSubEpReq {
+  int64_t consumerId;
+  int32_t epoch;
+  char    cgroup[TSDB_CONSUMER_GROUP_LEN];
+} SMqCMGetSubEpReq;
+
 #pragma pack(pop)
 
 static FORCE_INLINE int32_t tEncodeSMsgHead(void** buf, const SMsgHead* pMsg) {
@@ -1521,15 +1528,17 @@ static FORCE_INLINE void* taosDecodeSMqMsg(void* buf, SMqHbMsg* pMsg) {
 }
 
 typedef struct SMqSetCVgReq {
-  int32_t vgId;
-  int64_t oldConsumerId;
-  int64_t newConsumerId;
-  char    topicName[TSDB_TOPIC_FNAME_LEN];
-  char    cgroup[TSDB_CONSUMER_GROUP_LEN];
-  char*   sql;
-  char*   logicalPlan;
-  char*   physicalPlan;
-  SSubQueryMsg msg;
+  int32_t  vgId;
+  int64_t  oldConsumerId;
+  int64_t  newConsumerId;
+  char     topicName[TSDB_TOPIC_FNAME_LEN];
+  char     cgroup[TSDB_CONSUMER_GROUP_LEN];
+  char*    sql;
+  char*    logicalPlan;
+  char*    physicalPlan;
+  uint32_t qmsgLen;
+  void*    qmsg;
+  //SSubQueryMsg msg;
 } SMqSetCVgReq;
 
 static FORCE_INLINE int32_t tEncodeSSubQueryMsg(void** buf, const SSubQueryMsg* pMsg) {
@@ -1538,7 +1547,7 @@ static FORCE_INLINE int32_t tEncodeSSubQueryMsg(void** buf, const SSubQueryMsg*
   tlen += taosEncodeFixedU64(buf, pMsg->queryId);
   tlen += taosEncodeFixedU64(buf, pMsg->taskId);
   tlen += taosEncodeFixedU32(buf, pMsg->contentLen);
-  tlen += taosEncodeBinary(buf, pMsg->msg, pMsg->contentLen);
+  //tlen += taosEncodeBinary(buf, pMsg->msg, pMsg->contentLen);
   return tlen;
 }
 
@@ -1547,7 +1556,7 @@ static FORCE_INLINE void* tDecodeSSubQueryMsg(void* buf, SSubQueryMsg* pMsg) {
   buf = taosDecodeFixedU64(buf, &pMsg->queryId);
   buf = taosDecodeFixedU64(buf, &pMsg->taskId);
   buf = taosDecodeFixedU32(buf, &pMsg->contentLen);
-  buf = taosDecodeBinaryTo(buf, pMsg->msg, pMsg->contentLen);
+  //buf = taosDecodeBinaryTo(buf, pMsg->msg, pMsg->contentLen);
   return buf;
 }
 
@@ -1561,7 +1570,9 @@ static FORCE_INLINE int32_t tEncodeSMqSetCVgReq(void** buf, const SMqSetCVgReq*
   tlen += taosEncodeString(buf, pReq->sql);
   tlen += taosEncodeString(buf, pReq->logicalPlan);
   tlen += taosEncodeString(buf, pReq->physicalPlan);
-  tlen += tEncodeSSubQueryMsg(buf, &pReq->msg);
+  tlen += taosEncodeFixedU32(buf, pReq->qmsgLen);
+  tlen += taosEncodeString(buf, (char*)pReq->qmsg);
+  //tlen += tEncodeSSubQueryMsg(buf, &pReq->msg);
   return tlen;
 }
 
@@ -1574,15 +1585,18 @@ static FORCE_INLINE void* tDecodeSMqSetCVgReq(void* buf, SMqSetCVgReq* pReq) {
   buf = taosDecodeString(buf, &pReq->sql);
   buf = taosDecodeString(buf, &pReq->logicalPlan);
   buf = taosDecodeString(buf, &pReq->physicalPlan);
-  buf = tDecodeSSubQueryMsg(buf, &pReq->msg);
+  buf = taosDecodeFixedU32(buf, &pReq->qmsgLen);
+  buf = taosDecodeString(buf, (char**)&pReq->qmsg);
+  //buf = tDecodeSSubQueryMsg(buf, &pReq->msg);
   return buf;
 }
 
 typedef struct SMqSetCVgRsp {
-  int32_t vgId;
-  int64_t consumerId;
-  char    topicName[TSDB_TOPIC_FNAME_LEN];
-  char    cGroup[TSDB_CONSUMER_GROUP_LEN];
+  SMsgHead header;
+  int32_t  vgId;
+  int64_t  consumerId;
+  char     topicName[TSDB_TOPIC_FNAME_LEN];
+  char     cGroup[TSDB_CONSUMER_GROUP_LEN];
 } SMqSetCVgRsp;
 
 typedef struct SMqColData {
@@ -1634,6 +1648,92 @@ typedef struct SMqConsumeReq {
   char           topic[TSDB_TOPIC_FNAME_LEN];
 } SMqConsumeReq;
 
+typedef struct SMqSubVgEp {
+  int32_t vgId;
+  SEpSet  epSet;
+} SMqSubVgEp;
+
+typedef struct SMqSubTopicEp {
+  char    topic[TSDB_TOPIC_FNAME_LEN];
+  SArray* vgs;   // SArray<SMqSubVgEp>
+} SMqSubTopicEp;
+
+typedef struct SMqCMGetSubEpRsp {
+  int64_t consumerId;
+  char    cgroup[TSDB_CONSUMER_GROUP_LEN];
+  SArray* topics;  // SArray<SMqSubTopicEp>
+} SMqCMGetSubEpRsp;
+
+static FORCE_INLINE int32_t tEncodeSMqSubVgEp(void** buf, const SMqSubVgEp* pVgEp) {
+  int32_t tlen = 0;
+  tlen += taosEncodeFixedI16(buf, pVgEp->vgId);
+  tlen += taosEncodeSEpSet(buf, &pVgEp->epSet);
+  return tlen;
+}
+
+static FORCE_INLINE void* tDecodeSMqSubVgEp(void* buf, SMqSubVgEp* pVgEp) {
+  buf = taosDecodeFixedI32(buf, &pVgEp->vgId);
+  buf = taosDecodeSEpSet(buf, &pVgEp->epSet);
+  return buf;
+}
+
+static FORCE_INLINE int32_t tEncodeSMqSubTopicEp(void** buf, const SMqSubTopicEp* pTopicEp) {
+  int32_t tlen = 0;
+  tlen += taosEncodeString(buf, pTopicEp->topic);
+  int32_t sz = taosArrayGetSize(pTopicEp->vgs);
+  tlen += taosEncodeFixedI32(buf, sz);
+  for (int32_t i = 0; i < sz; i++) {
+    SMqSubVgEp* pVgEp = (SMqSubVgEp*)taosArrayGet(pTopicEp->vgs, i);
+    tlen += tEncodeSMqSubVgEp(buf, pVgEp);
+  }
+  return tlen;
+}
+
+static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicEp) {
+  buf = taosDecodeStringTo(buf, pTopicEp->topic);
+  int32_t sz;
+  buf = taosDecodeFixedI32(buf, &sz);
+  pTopicEp->vgs = taosArrayInit(sz, sizeof(SMqSubVgEp));
+  if (pTopicEp->vgs == NULL) {
+    return NULL;
+  }
+  for (int32_t i = 0; i < sz; i++) {
+    SMqSubVgEp vgEp;
+    buf = tDecodeSMqSubVgEp(buf, &vgEp);
+    taosArrayPush(pTopicEp->vgs, &vgEp);
+  }
+  return buf;
+}
+
+static FORCE_INLINE int32_t tEncodeSMqCMGetSubEpRsp(void** buf, const SMqCMGetSubEpRsp* pRsp) {
+  int32_t tlen = 0;
+  tlen += taosEncodeFixedI64(buf, pRsp->consumerId);
+  tlen += taosEncodeString(buf, pRsp->cgroup);
+  int32_t sz = taosArrayGetSize(pRsp->topics);
+  tlen += taosEncodeFixedI32(buf, sz);
+  for (int32_t i = 0; i < sz; i++) {
+    SMqSubTopicEp* pVgEp = (SMqSubTopicEp*)taosArrayGet(pRsp->topics, i);
+    tlen += tEncodeSMqSubTopicEp(buf, pVgEp);
+  }
+  return tlen;
+}
+
+static FORCE_INLINE void* tDecodeSMqCMGetSubEpRsp(void* buf, SMqCMGetSubEpRsp* pRsp) {
+  buf = taosDecodeFixedI64(buf, &pRsp->consumerId);
+  buf = taosDecodeStringTo(buf, pRsp->cgroup);
+  int32_t sz;
+  buf = taosDecodeFixedI32(buf, &sz);
+  pRsp->topics = taosArrayInit(sz, sizeof(SMqSubTopicEp));
+  if (pRsp->topics == NULL) {
+    return NULL;
+  }
+  for (int32_t i = 0; i < sz; i++) {
+    SMqSubTopicEp topicEp;
+    buf = tDecodeSMqSubTopicEp(buf, &topicEp);
+    taosArrayPush(pRsp->topics, &topicEp);
+  }
+  return buf;
+}
 
 #ifdef __cplusplus
 }

include/common/tmsgdef.h

@@ -119,9 +119,9 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_DB, "mnode-alter-db", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SYNC_DB, "mnode-sync-db", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_COMPACT_DB, "mnode-compact-db", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_FUNCTION, "mnode-create-function", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_RETRIEVE_FUNCTION, "mnode-retrieve-function", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_MND_DROP_FUNCTION, "mnode-drop-function", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_FUNC, "mnode-create-func", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_RETRIEVE_FUNC, "mnode-retrieve-func", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MND_DROP_FUNC, "mnode-drop-func", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_CREATE_STB, "mnode-create-stb", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_STB, "mnode-alter-stb", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_STB, "mnode-drop-stb", NULL, NULL)
@@ -140,6 +140,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_ALTER_TOPIC, "mnode-alter-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_TOPIC, "mnode-drop-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SUBSCRIBE, "mnode-subscribe", SCMSubscribeReq, SCMSubscribeRsp)
+  TD_DEF_MSG_TYPE(TDMT_MND_GET_SUB_EP, "mnode-get-sub-ep", SMqCMGetSubEpReq, SMqCMGetSubEpRsp)
   TD_DEF_MSG_TYPE(TDMT_MND_MQ_TIMER, "mnode-timer", SMqTmrMsg, SMqTmrMsg)
 
   // Requests handled by VNODE

include/libs/executor/executor.h

@@ -32,7 +32,7 @@ struct SSubplan;
   * @param streamReadHandle
   * @return
   */
-qTaskInfo_t qCreateStreamExecTaskInfo(SSubQueryMsg *pMsg, void* streamReadHandle);
+qTaskInfo_t qCreateStreamExecTaskInfo(void *msg, void* streamReadHandle);
 
 int32_t     qSetStreamInput(qTaskInfo_t tinfo, void* input);
 
@@ -45,7 +45,7 @@ int32_t     qSetStreamInput(qTaskInfo_t tinfo, void* input);
   * @param qId
   * @return
   */
-int32_t qCreateExecTask(void* readHandle, int32_t vgId, struct SSubplan* pPlan, qTaskInfo_t* pTaskInfo, DataSinkHandle* handle);
+int32_t qCreateExecTask(void* readHandle, int32_t vgId, uint64_t taskId, struct SSubplan* pPlan, qTaskInfo_t* pTaskInfo, DataSinkHandle* handle);
 
 /**
  * The main task execution function, including query on both table and multiple tables,

include/libs/parser/parser.h

@@ -74,6 +74,7 @@ void columnListCopy(SArray* dst, const SArray* src, uint64_t uid);
 void columnListDestroy(SArray* pColumnList);
 
 void dropAllExprInfo(SArray** pExprInfo, int32_t numOfLevel);
+void dropOneLevelExprInfo(SArray* pExprInfo);
 
 typedef struct SSourceParam {
   SArray    *pExprNodeList; //Array<struct tExprNode*>

include/os/os.h

@@ -51,6 +51,7 @@ extern "C" {
 #include <libgen.h>
 
 #include <sys/mman.h>
+#include <sys/prctl.h>
 
 #include "osAtomic.h"
 #include "osDef.h"

include/os/osDef.h

@@ -181,7 +181,8 @@ extern "C" {
   #endif
 #else
   // Windows
-  #define setThreadName(name)
+//  #define setThreadName(name)
+#define setThreadName(name) do { prctl(PR_SET_NAME, (name)); } while (0)
 #endif
 
 #if defined(_WIN32)

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)

include/util/tlist.h

@@ -34,6 +34,7 @@ extern "C" {
 #define TD_SLIST_HEAD(sl) ((sl)->sl_head_)
 #define TD_SLIST_NELES(sl) ((sl)->sl_neles_)
 #define TD_SLIST_NODE_NEXT(sln) ((sln)->sl_next_)
+#define TD_SLIST_NODE_NEXT_WITH_FIELD(sln, field) ((sln)->field.sl_next_)
 
 #define TD_SLIST_INIT(sl)  \
   do {                     \
@@ -48,12 +49,25 @@ extern "C" {
     TD_SLIST_NELES(sl) += 1;                     \
   } while (0)
 
+#define TD_SLIST_PUSH_WITH_FIELD(sl, sln, field)                   \
+  do {                                                             \
+    TD_SLIST_NODE_NEXT_WITH_FIELD(sln, field) = TD_SLIST_HEAD(sl); \
+    TD_SLIST_HEAD(sl) = (sln);                                     \
+    TD_SLIST_NELES(sl) += 1;                                       \
+  } while (0)
+
 #define TD_SLIST_POP(sl)                                       \
   do {                                                         \
     TD_SLIST_HEAD(sl) = TD_SLIST_NODE_NEXT(TD_SLIST_HEAD(sl)); \
     TD_SLIST_NELES(sl) -= 1;                                   \
   } while (0)
 
+#define TD_SLIST_POP_WITH_FIELD(sl, field)                                       \
+  do {                                                                           \
+    TD_SLIST_HEAD(sl) = TD_SLIST_NODE_NEXT_WITH_FIELD(TD_SLIST_HEAD(sl), field); \
+    TD_SLIST_NELES(sl) -= 1;                                                     \
+  } while (0)
+
 // Double linked list ================
 #define TD_DLIST_NODE(TYPE) \
   struct {                  \
@@ -70,6 +84,8 @@ extern "C" {
 
 #define TD_DLIST_NODE_PREV(dln) ((dln)->dl_prev_)
 #define TD_DLIST_NODE_NEXT(dln) ((dln)->dl_next_)
+#define TD_DLIST_NODE_PREV_WITH_FIELD(dln, field) ((dln)->field.dl_prev_)
+#define TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field) ((dln)->field.dl_next_)
 #define TD_DLIST_HEAD(dl) ((dl)->dl_head_)
 #define TD_DLIST_TAIL(dl) ((dl)->dl_tail_)
 #define TD_DLIST_NELES(dl) ((dl)->dl_neles_)
@@ -94,6 +110,20 @@ extern "C" {
     TD_DLIST_NELES(dl) += 1;                                    \
   } while (0)
 
+#define TD_DLIST_APPEND_WITH_FIELD(dl, dln, field)                                                  \
+  do {                                                                                              \
+    if (TD_DLIST_HEAD(dl) == NULL) {                                                                \
+      TD_DLIST_NODE_PREV_WITH_FIELD(dln, field) = TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field) = NULL; \
+      TD_DLIST_HEAD(dl) = TD_DLIST_TAIL(dl) = (dln);                                                \
+    } else {                                                                                        \
+      TD_DLIST_NODE_PREV_WITH_FIELD(dln, field) = TD_DLIST_TAIL(dl);                                \
+      TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field) = NULL;                                             \
+      TD_DLIST_NODE_NEXT_WITH_FIELD(TD_DLIST_TAIL(dl), field) = (dln);                              \
+      TD_DLIST_TAIL(dl) = (dln);                                                                    \
+    }                                                                                               \
+    TD_DLIST_NELES(dl) += 1;                                                                        \
+  } while (0)
+
 #define TD_DLIST_PREPEND(dl, dln)                               \
   do {                                                          \
     if (TD_DLIST_HEAD(dl) == NULL) {                            \
@@ -108,6 +138,20 @@ extern "C" {
     TD_DLIST_NELES(dl) += 1;                                    \
   } while (0)
 
+#define TD_DLIST_PREPEND_WITH_FIELD(dl, dln, field)                                                 \
+  do {                                                                                              \
+    if (TD_DLIST_HEAD(dl) == NULL) {                                                                \
+      TD_DLIST_NODE_PREV_WITH_FIELD(dln, field) = TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field) = NULL; \
+      TD_DLIST_HEAD(dl) = TD_DLIST_TAIL(dl) = (dln);                                                \
+    } else {                                                                                        \
+      TD_DLIST_NODE_PREV_WITH_FIELD(dln, field) = NULL;                                             \
+      TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field) = TD_DLIST_HEAD(dl);                                \
+      TD_DLIST_NODE_PREV_WITH_FIELD(TD_DLIST_HEAD(dl), field) = (dln);                              \
+      TD_DLIST_HEAD(dl) = (dln);                                                                    \
+    }                                                                                               \
+    TD_DLIST_NELES(dl) += 1;                                                                        \
+  } while (0)
+
 #define TD_DLIST_POP(dl, dln)                                                \
   do {                                                                       \
     if (TD_DLIST_HEAD(dl) == (dln)) {                                        \
@@ -126,6 +170,26 @@ extern "C" {
     TD_DLIST_NODE_PREV(dln) = TD_DLIST_NODE_NEXT(dln) = NULL;                \
   } while (0)
 
+#define TD_DLIST_POP_WITH_FIELD(dl, dln, field)                                                   \
+  do {                                                                                            \
+    if (TD_DLIST_HEAD(dl) == (dln)) {                                                             \
+      TD_DLIST_HEAD(dl) = TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field);                              \
+    }                                                                                             \
+    if (TD_DLIST_TAIL(dl) == (dln)) {                                                             \
+      TD_DLIST_TAIL(dl) = TD_DLIST_NODE_PREV_WITH_FIELD(dln, field);                              \
+    }                                                                                             \
+    if (TD_DLIST_NODE_PREV_WITH_FIELD(dln, field) != NULL) {                                      \
+      TD_DLIST_NODE_NEXT_WITH_FIELD(TD_DLIST_NODE_PREV_WITH_FIELD(dln, field), field) =           \
+          TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field);                                              \
+    }                                                                                             \
+    if (TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field) != NULL) {                                      \
+      TD_DLIST_NODE_PREV_WITH_FIELD(TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field), field) =           \
+          TD_DLIST_NODE_PREV_WITH_FIELD(dln, field);                                              \
+    }                                                                                             \
+    TD_DLIST_NELES(dl) -= 1;                                                                      \
+    TD_DLIST_NODE_PREV_WITH_FIELD(dln, field) = TD_DLIST_NODE_NEXT_WITH_FIELD(dln, field) = NULL; \
+  } while (0)
+
 // General double linked list
 typedef enum { TD_LIST_FORWARD, TD_LIST_BACKWARD } TD_LIST_DIRECTION_T;
 

include/util/tqueue.h

@@ -15,6 +15,7 @@
 
 #ifndef _TD_UTIL_QUEUE_H
 #define _TD_UTIL_QUEUE_H
+#include "os.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -40,13 +41,13 @@ shall be used to set up the protection.
 typedef struct STaosQueue STaosQueue;
 typedef struct STaosQset  STaosQset;
 typedef struct STaosQall  STaosQall;
-typedef void (*FProcessItem)(void *ahandle, void *pItem);
-typedef void (*FProcessItems)(void *ahandle, STaosQall *qall, int32_t numOfItems);
+typedef void (*FItem)(void *ahandle, void *pItem);
+typedef void (*FItems)(void *ahandle, STaosQall *qall, int32_t numOfItems);
 
 STaosQueue *taosOpenQueue();
 void        taosCloseQueue(STaosQueue *queue);
-void        taosSetQueueFp(STaosQueue *queue, FProcessItem itemFp, FProcessItems itemsFp);
-void       *taosAllocateQitem(int32_t size);
+void        taosSetQueueFp(STaosQueue *queue, FItem itemFp, FItems itemsFp);
+void *      taosAllocateQitem(int32_t size);
 void        taosFreeQitem(void *pItem);
 int32_t     taosWriteQitem(STaosQueue *queue, void *pItem);
 int32_t     taosReadQitem(STaosQueue *queue, void **ppItem);
@@ -66,8 +67,11 @@ int32_t    taosAddIntoQset(STaosQset *qset, STaosQueue *queue, void *ahandle);
 void       taosRemoveFromQset(STaosQset *qset, STaosQueue *queue);
 int32_t    taosGetQueueNumber(STaosQset *qset);
 
-int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, void **ahandle, FProcessItem *itemFp);
-int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, void **ahandle, FProcessItems *itemsFp);
+int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, void **ahandle, FItem *itemFp);
+int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, void **ahandle, FItems *itemsFp);
+
+int32_t taosReadQitemFromQsetByThread(STaosQset *qset, void **ppItem, void **ahandle, FItem *itemFp, int32_t threadId);
+void    taosResetQsetThread(STaosQset *qset, void *pItem);
 
 int32_t taosGetQueueItemsNumber(STaosQueue *queue);
 int32_t taosGetQsetItemsNumber(STaosQset *qset);

include/util/tworker.h

@@ -15,57 +15,61 @@
 
 #ifndef _TD_UTIL_WORKER_H
 #define _TD_UTIL_WORKER_H
-
 #include "tqueue.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef struct SWorkerPool  SWorkerPool;
-typedef struct SMWorkerPool SMWorkerPool;
+typedef struct SQWorkerPool SQWorkerPool;
+typedef struct SWWorkerPool SWWorkerPool;
 
-typedef struct SWorker {
-  int32_t      id;      // worker ID
-  pthread_t    thread;  // thread
-  SWorkerPool *pool;
-} SWorker;
+typedef struct SQWorker {
+  int32_t       id;      // worker ID
+  pthread_t     thread;  // thread
+  SQWorkerPool *pool;
+} SQWorker, SFWorker;
 
-typedef struct SWorkerPool {
+typedef struct SQWorkerPool {
   int32_t         max;  // max number of workers
   int32_t         min;  // min number of workers
   int32_t         num;  // current number of workers
-  STaosQset      *qset;
-  const char     *name;
-  SWorker        *workers;
+  STaosQset *     qset;
+  const char *    name;
+  SQWorker *      workers;
   pthread_mutex_t mutex;
-} SWorkerPool;
+} SQWorkerPool, SFWorkerPool;
 
-typedef struct SMWorker {
+typedef struct SWWorker {
   int32_t       id;      // worker id
   pthread_t     thread;  // thread
-  STaosQall    *qall;
-  STaosQset    *qset;  // queue set
-  SMWorkerPool *pool;
-} SMWorker;
+  STaosQall *   qall;
+  STaosQset *   qset;  // queue set
+  SWWorkerPool *pool;
+} SWWorker;
 
-typedef struct SMWorkerPool {
+typedef struct SWWorkerPool {
   int32_t         max;     // max number of workers
   int32_t         nextId;  // from 0 to max-1, cyclic
-  const char     *name;
-  SMWorker       *workers;
+  const char *    name;
+  SWWorker *      workers;
   pthread_mutex_t mutex;
-} SMWorkerPool;
+} SWWorkerPool;
+
+int32_t     tQWorkerInit(SQWorkerPool *pool);
+void        tQWorkerCleanup(SQWorkerPool *pool);
+STaosQueue *tQWorkerAllocQueue(SQWorkerPool *pool, void *ahandle, FItem fp);
+void        tQWorkerFreeQueue(SQWorkerPool *pool, STaosQueue *queue);
 
-int32_t     tWorkerInit(SWorkerPool *pool);
-void        tWorkerCleanup(SWorkerPool *pool);
-STaosQueue *tWorkerAllocQueue(SWorkerPool *pool, void *ahandle, FProcessItem fp);
-void        tWorkerFreeQueue(SWorkerPool *pool, STaosQueue *queue);
+int32_t     tFWorkerInit(SFWorkerPool *pool);
+void        tFWorkerCleanup(SFWorkerPool *pool);
+STaosQueue *tFWorkerAllocQueue(SFWorkerPool *pool, void *ahandle, FItem fp);
+void        tFWorkerFreeQueue(SFWorkerPool *pool, STaosQueue *queue);
 
-int32_t     tMWorkerInit(SMWorkerPool *pool);
-void        tMWorkerCleanup(SMWorkerPool *pool);
-STaosQueue *tMWorkerAllocQueue(SMWorkerPool *pool, void *ahandle, FProcessItems fp);
-void        tMWorkerFreeQueue(SMWorkerPool *pool, STaosQueue *queue);
+int32_t     tWWorkerInit(SWWorkerPool *pool);
+void        tWWorkerCleanup(SWWorkerPool *pool);
+STaosQueue *tWWorkerAllocQueue(SWWorkerPool *pool, void *ahandle, FItems fp);
+void        tWWorkerFreeQueue(SWWorkerPool *pool, STaosQueue *queue);
 
 #ifdef __cplusplus
 }

packaging/release.sh

+#!/bin/bash
+#
+# Generate the deb package for ubuntu, or rpm package for centos, or tar.gz package for other linux os
+
+set -e
+#set -x
+
+# set parameters by default value
+version="3.0.0.0"
+
+curr_dir=$(pwd)
+
+script_dir="$(dirname $(readlink -f $0))"
+top_dir="$(readlink -f ${script_dir}/..)"
+
+echo "=======================new version number: ${verNumber}======================================"
+
+build_time=$(date +"%F %R")
+
+echo "top_dir: ${top_dir}"
+
+cd ${top_dir}
+git pull || :
+
+echo "curr_dir: ${curr_dir}"
+
+# 2. cmake executable file
+compile_dir="${top_dir}/debug"
+if [ -d ${compile_dir} ]; then
+  rm -rf ${compile_dir}
+fi
+
+mkdir -p ${compile_dir}
+
+cd ${compile_dir}
+
+echo "compile_dir: ${compile_dir}"
+
+cmake ..
+make -j32
+
+release_dir="${top_dir}/release"
+if [ -d ${release_dir} ]; then
+  rm -rf ${release_dir}
+fi
+
+mkdir -p ${release_dir}
+cd ${release_dir}
+
+install_dir="${release_dir}/TDengine-server-${version}"
+mkdir -p ${install_dir}
+mkdir -p ${install_dir}/lib
+
+bin_files="${compile_dir}/source/dnode/mgmt/daemon/taosd ${compile_dir}/tools/shell/taos  ${compile_dir}/tests/test/c/create_table"
+cp ${bin_files} ${install_dir}/ && chmod a+x ${install_dir}/* || :
+
+
+cp ${compile_dir}/source/client/libtaos.so ${install_dir}/lib/
+cp ${compile_dir}/source/dnode/mnode/impl/libmnode.so ${install_dir}/lib/
+cp ${compile_dir}/source/dnode/qnode/libqnode.so ${install_dir}/lib/
+cp ${compile_dir}/source/dnode/snode/libsnode.so ${install_dir}/lib/
+cp ${compile_dir}/source/dnode/bnode/libbnode.so ${install_dir}/lib/
+cp ${compile_dir}/source/libs/wal/libwal.so ${install_dir}/lib/
+cp ${compile_dir}/source/libs/scheduler/libscheduler.so ${install_dir}/lib/
+cp ${compile_dir}/source/libs/planner/libplanner.so ${install_dir}/lib/
+cp ${compile_dir}/source/libs/parser/libparser.so ${install_dir}/lib/
+cp ${compile_dir}/source/libs/qcom/libqcom.so ${install_dir}/lib/
+cp ${compile_dir}/source/libs/transport/libtransport.so ${install_dir}/lib/
+cp ${compile_dir}/source/libs/function/libfunction.so ${install_dir}/lib/
+cp ${compile_dir}/source/common/libcommon.so ${install_dir}/lib/
+cp ${compile_dir}/source/os/libos.so ${install_dir}/lib/
+cp ${compile_dir}/source/dnode/mnode/sdb/libsdb.so ${install_dir}/lib/
+cp ${compile_dir}/source/libs/catalog/libcatalog.so ${install_dir}/lib/
+
+pkg_name=${install_dir}-Linux-x64
+
+tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files || :
+
+

source/client/src/clientImpl.c

@@ -218,6 +218,7 @@ int32_t getPlan(SRequestObj* pRequest, SQueryNode* pQueryNode, SQueryDag** pDag,
 
   if (pQueryNode->type == TSDB_SQL_SELECT) {
     setResSchemaInfo(&pRequest->body.resInfo, pSchema, numOfCols);
+    tfree(pSchema);
     pRequest->type = TDMT_VND_QUERY;
   } else {
     tfree(pSchema);
@@ -262,7 +263,7 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, SArray* pNodeList)
 
 typedef struct SMqClientVg {
   // statistics
-  int64_t consumeCnt;
+  int64_t pollCnt;
   // offset
   int64_t committedOffset;
   int64_t currentOffset;
@@ -313,10 +314,10 @@ tmq_conf_t* tmq_conf_new() {
 }
 
 int32_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value) {
-  if (strcmp(key, "group.id")) {
+  if (strcmp(key, "group.id") == 0) {
     strcpy(conf->groupId, value);
   }
-  if (strcmp(key, "client.id")) {
+  if (strcmp(key, "client.id") == 0) {
     strcpy(conf->clientId, value);
   }
   return 0;
@@ -344,6 +345,7 @@ tmq_t* taos_consumer_new(void* conn, tmq_conf_t* conf, char* errstr, int32_t err
   strcpy(pTmq->groupId, conf->groupId);
   pTmq->commit_cb = conf->commit_cb;
   pTmq->consumerId = generateRequestId() & ((uint64_t)-1 >> 1);
+  pTmq->clientTopics = taosArrayInit(0, sizeof(SMqClientTopic));
   return pTmq;
 }
 
@@ -364,7 +366,7 @@ tmq_list_t* tmq_list_new() {
 
 int32_t tmq_list_append(tmq_list_t* ptr, char* src) {
   if (ptr->cnt >= ptr->tot-1) return -1;
-  ptr->elems[ptr->cnt] = src;
+  ptr->elems[ptr->cnt] = strdup(src);
   ptr->cnt++;
   return 0;
 }
@@ -376,8 +378,23 @@ TAOS_RES* tmq_subscribe(tmq_t* tmq, tmq_list_t* topic_list) {
   int32_t sz = topic_list->cnt;
   tmq->clientTopics = taosArrayInit(sz, sizeof(void*));
   for (int i = 0; i < sz; i++) {
-    char* topicName = strdup(topic_list->elems[i]);
-    taosArrayPush(tmq->clientTopics, &topicName); 
+    char* topicName = topic_list->elems[i];
+
+    SName name = {0};
+    char* dbName = getDbOfConnection(tmq->pTscObj);
+    tNameSetDbName(&name, tmq->pTscObj->acctId, dbName, strlen(dbName));     
+    tNameFromString(&name, topicName, T_NAME_TABLE);
+
+    char* topicFname = calloc(1, TSDB_TOPIC_FNAME_LEN);
+    if (topicFname == NULL) {
+
+    }
+    tNameExtractFullName(&name, topicFname);
+    tscDebug("subscribe topic: %s", topicFname);
+    taosArrayPush(tmq->clientTopics, &topicFname); 
+    /*SMqClientTopic topic = {*/
+      /*.*/
+    /*};*/
   }
   SCMSubscribeReq req;
   req.topicNum = taosArrayGetSize(tmq->clientTopics);
@@ -395,13 +412,12 @@ TAOS_RES* tmq_subscribe(tmq_t* tmq, tmq_list_t* topic_list) {
   tSerializeSCMSubscribeReq(&abuf, &req);
   /*printf("formatted: %s\n", dagStr);*/
 
-  pRequest = createRequest(tmq->pTscObj, NULL, NULL, TSDB_SQL_SELECT);
+  pRequest = createRequest(tmq->pTscObj, NULL, NULL, TDMT_MND_SUBSCRIBE);
   if (pRequest == NULL) {
     tscError("failed to malloc sqlObj");
   }
 
   pRequest->body.requestMsg = (SDataBuf){ .pData = buf, .len = tlen };
-  pRequest->type = TDMT_MND_CREATE_TOPIC;
 
   SMsgSendInfo* body = buildMsgInfoImpl(pRequest);
   SEpSet epSet = getEpSet_s(&tmq->pTscObj->pAppInfo->mgmtEp);
@@ -529,7 +545,7 @@ TAOS_RES *taos_create_topic(TAOS* taos, const char* topicName, const char* sql,
 
   SCMCreateTopicReq req = {
     .name         = (char*) topicFname,
-    .igExists     = 0,
+    .igExists     = 1,
     .physicalPlan = (char*) pStr,
     .sql          = (char*) sql,
     .logicalPlan  = "no logic plan",
@@ -575,6 +591,37 @@ struct tmq_message_t {
   SMqConsumeRsp rsp;
 };
 
+int32_t tmq_poll_cb_inner(void* param, const SDataBuf* pMsg, int32_t code) {
+  return 0;
+}
+
+int32_t tmq_ask_ep_cb(void* param, const SDataBuf* pMsg, int32_t code) {
+  tmq_t* tmq = (tmq_t*)param;
+  SMqCMGetSubEpRsp rsp;
+  tDecodeSMqCMGetSubEpRsp(pMsg->pData, &rsp);
+  int32_t sz = taosArrayGetSize(rsp.topics);
+  // TODO: lock
+  tmq->clientTopics = taosArrayInit(sz, sizeof(SMqClientTopic));
+  for (int32_t i = 0; i < sz; i++) {
+    SMqClientTopic topic = {0};
+    SMqSubTopicEp* pTopicEp = taosArrayGet(rsp.topics, i);
+    topic.topicName = strdup(pTopicEp->topic);
+    int32_t vgSz = taosArrayGetSize(pTopicEp->vgs);
+    topic.vgs = taosArrayInit(vgSz, sizeof(SMqClientVg));
+    for (int32_t j = 0; j < vgSz; j++) {
+      SMqSubVgEp* pVgEp = taosArrayGet(pTopicEp->vgs, j);
+      SMqClientVg clientVg = {
+        .vgId = pVgEp->vgId,
+        .epSet = pVgEp->epSet
+      };
+      taosArrayPush(topic.vgs, &clientVg);
+    }
+    taosArrayPush(tmq->clientTopics, &topic);
+  }
+  // unlock
+  return 0;
+}
+
 tmq_message_t* tmq_consume_poll(tmq_t* tmq, int64_t blocking_time) {
   if (tmq->clientTopics == NULL || taosArrayGetSize(tmq->clientTopics) == 0) {
     return NULL;
@@ -584,9 +631,38 @@ tmq_message_t* tmq_consume_poll(tmq_t* tmq, int64_t blocking_time) {
   req.reqType = 1;
   req.blockingTime = blocking_time;
   req.consumerId = tmq->consumerId;
+  tmq_message_t* tmq_message = NULL;
   strcpy(req.cgroup, tmq->groupId);
 
-  SMqClientTopic* pTopic = taosArrayGet(tmq->clientTopics, tmq->nextTopicIdx);
+  if (taosArrayGetSize(tmq->clientTopics) == 0) {
+    int32_t tlen = sizeof(SMqCMGetSubEpReq);
+    SMqCMGetSubEpReq* buf = malloc(tlen);
+    if (buf == NULL) {
+      tscError("failed to malloc get subscribe ep buf");
+    }
+    buf->consumerId = htobe64(buf->consumerId);
+    
+    pRequest = createRequest(tmq->pTscObj, NULL, NULL, TDMT_MND_GET_SUB_EP);
+    if (pRequest == NULL) {
+      tscError("failed to malloc subscribe ep request");
+    }
+
+    pRequest->body.requestMsg = (SDataBuf){ .pData = buf, .len = tlen };
+
+    SMsgSendInfo* sendInfo = buildMsgInfoImpl(pRequest);
+    sendInfo->requestObjRefId = 0;
+    sendInfo->param = tmq;
+    sendInfo->fp = tmq_ask_ep_cb;
+
+    SEpSet epSet = getEpSet_s(&tmq->pTscObj->pAppInfo->mgmtEp);
+
+    int64_t transporterId = 0;
+    asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, sendInfo);
+
+    tsem_wait(&pRequest->body.rspSem);
+  }
+
+  SMqClientTopic* pTopic = taosArrayGetP(tmq->clientTopics, tmq->nextTopicIdx);
   tmq->nextTopicIdx = (tmq->nextTopicIdx + 1) % taosArrayGetSize(tmq->clientTopics);
   strcpy(req.topic, pTopic->topicName);
   int32_t nextVgIdx = pTopic->nextVgIdx;
@@ -597,14 +673,17 @@ tmq_message_t* tmq_consume_poll(tmq_t* tmq, int64_t blocking_time) {
   pRequest->body.requestMsg = (SDataBuf){ .pData = &req, .len = sizeof(SMqConsumeReq) };
   pRequest->type = TDMT_VND_CONSUME;
 
-  SMsgSendInfo* body = buildMsgInfoImpl(pRequest);
+  SMsgSendInfo* sendInfo = buildMsgInfoImpl(pRequest);
+  sendInfo->requestObjRefId = 0;
+  sendInfo->param = &tmq_message;
+  sendInfo->fp = tmq_poll_cb_inner;
 
   int64_t transporterId = 0;
-  asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &pVg->epSet, &transporterId, body);
+  asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &pVg->epSet, &transporterId, sendInfo);
 
   tsem_wait(&pRequest->body.rspSem);
 
-  return (tmq_message_t*)pRequest->body.resInfo.pData;
+  return tmq_message;
 
   /*tsem_wait(&pRequest->body.rspSem);*/
 

source/dnode/mgmt/impl/inc/dndEnv.h

@@ -31,8 +31,8 @@ typedef struct {
   SDnode     *pDnode;
   STaosQueue *queue;
   union {
-    SWorkerPool  pool;
-    SMWorkerPool mpool;
+    SQWorkerPool  pool;
+    SWWorkerPool mpool;
   };
 } SDnodeWorker;
 
@@ -109,10 +109,10 @@ typedef struct {
   int32_t      openVnodes;
   int32_t      totalVnodes;
   SRWLatch     latch;
-  SWorkerPool  queryPool;
-  SWorkerPool  fetchPool;
-  SMWorkerPool syncPool;
-  SMWorkerPool writePool;
+  SQWorkerPool queryPool;
+  SFWorkerPool fetchPool;
+  SWWorkerPool syncPool;
+  SWWorkerPool writePool;
 } SVnodesMgmt;
 
 typedef struct {

source/dnode/mgmt/impl/src/dndMgmt.c

@@ -487,6 +487,8 @@ static void *dnodeThreadRoutine(void *param) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   int32_t     ms = pDnode->cfg.statusInterval * 1000;
 
+  setThreadName("dnode-hb");
+
   while (true) {
     pthread_testcancel();
     taosMsleep(ms);

source/dnode/mgmt/impl/src/dndTransport.c

@@ -25,9 +25,9 @@
 #include "dndMnode.h"
 #include "dndVnodes.h"
 
-#define INTERNAL_USER "_internal"
+#define INTERNAL_USER "_dnd"
 #define INTERNAL_CKEY "_key"
-#define INTERNAL_SECRET "_secret"
+#define INTERNAL_SECRET "_pwd"
 
 static void dndInitMsgFp(STransMgmt *pMgmt) {
   // Requests handled by DNODE
@@ -90,9 +90,9 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_ALTER_DB)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_SYNC_DB)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_COMPACT_DB)] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_FUNCTION)] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_RETRIEVE_FUNCTION)] = dndProcessMnodeWriteMsg;
-  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_FUNCTION)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_FUNC)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_RETRIEVE_FUNC)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_FUNC)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_STB)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_ALTER_STB)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_STB)] = dndProcessMnodeWriteMsg;
@@ -112,11 +112,15 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_CREATE_TOPIC)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_ALTER_TOPIC)] = dndProcessMnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_MND_DROP_TOPIC)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_SUBSCRIBE)] = dndProcessMnodeWriteMsg;
+  /*pMgmt->msgFp[TMSG_INDEX(TDMT_VND_SUBSCRIBE_RSP)] = dndProcessMnodeWriteMsg;*/
+  pMgmt->msgFp[TMSG_INDEX(TDMT_VND_MQ_SET_CONN_RSP)] = dndProcessMnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_MND_GET_SUB_EP)] = dndProcessMnodeReadMsg;
 
   // Requests handled by VNODE
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_SUBMIT)] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_QUERY)] = dndProcessVnodeQueryMsg;
-  pMgmt->msgFp[TMSG_INDEX(TDMT_VND_QUERY_CONTINUE)] = dndProcessVnodeQueryMsg;  
+  pMgmt->msgFp[TMSG_INDEX(TDMT_VND_QUERY_CONTINUE)] = dndProcessVnodeQueryMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_FETCH)] = dndProcessVnodeFetchMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_ALTER_TABLE)] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_UPDATE_TAG_VAL)] = dndProcessVnodeWriteMsg;
@@ -142,6 +146,8 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_DROP_TABLE)] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_SHOW_TABLES)] = dndProcessVnodeFetchMsg;
   pMgmt->msgFp[TMSG_INDEX(TDMT_VND_SHOW_TABLES_FETCH)] = dndProcessVnodeFetchMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_VND_MQ_SET_CONN)] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TMSG_INDEX(TDMT_VND_MQ_SET_CUR)] = dndProcessVnodeFetchMsg;
 }
 
 static void dndProcessResponse(void *parent, SRpcMsg *pRsp, SEpSet *pEpSet) {
@@ -152,17 +158,18 @@ static void dndProcessResponse(void *parent, SRpcMsg *pRsp, SEpSet *pEpSet) {
 
   if (dndGetStat(pDnode) == DND_STAT_STOPPED) {
     if (pRsp == NULL || pRsp->pCont == NULL) return;
-    dTrace("RPC %p, rsp:%s is ignored since dnode is stopping", pRsp->handle, TMSG_INFO(msgType));
+    dTrace("RPC %p, rsp:%s ignored since dnode exiting, app:%p", pRsp->handle, TMSG_INFO(msgType), pRsp->ahandle);
     rpcFreeCont(pRsp->pCont);
     return;
   }
 
   DndMsgFp fp = pMgmt->msgFp[TMSG_INDEX(msgType)];
   if (fp != NULL) {
-    dTrace("RPC %p, rsp:%s will be processed, code:0x%x", pRsp->handle, TMSG_INFO(msgType), pRsp->code & 0XFFFF);
+    dTrace("RPC %p, rsp:%s will be processed, code:0x%x app:%p", pRsp->handle, TMSG_INFO(msgType), pRsp->code & 0XFFFF,
+           pRsp->ahandle);
     (*fp)(pDnode, pRsp, pEpSet);
   } else {
-    dError("RPC %p, rsp:%s not processed", pRsp->handle, TMSG_INFO(msgType));
+    dError("RPC %p, rsp:%s not processed, app:%p", pRsp->handle, TMSG_INFO(msgType), pRsp->ahandle);
     rpcFreeCont(pRsp->pCont);
   }
 }
@@ -189,7 +196,7 @@ static int32_t dndInitClient(SDnode *pDnode) {
 
   pMgmt->clientRpc = rpcOpen(&rpcInit);
   if (pMgmt->clientRpc == NULL) {
-    dError("failed to init rpc client");
+    dError("failed to init dnode rpc client");
     return -1;
   }
 
@@ -212,40 +219,39 @@ static void dndProcessRequest(void *param, SRpcMsg *pReq, SEpSet *pEpSet) {
 
   tmsg_t msgType = pReq->msgType;
   if (msgType == TDMT_DND_NETWORK_TEST) {
-    dTrace("RPC %p, network test req, app:%p will be processed, code:0x%x", pReq->handle, pReq->ahandle, pReq->code);
+    dTrace("RPC %p, network test req will be processed, app:%p", pReq->handle, pReq->ahandle);
     dndProcessStartupReq(pDnode, pReq);
     return;
   }
 
   if (dndGetStat(pDnode) == DND_STAT_STOPPED) {
-    dError("RPC %p, req:%s app:%p is ignored since dnode exiting", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
-    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_DND_OFFLINE};
+    dError("RPC %p, req:%s ignored since dnode exiting, app:%p", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
+    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_DND_OFFLINE, .ahandle = pReq->ahandle};
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pReq->pCont);
     return;
   } else if (dndGetStat(pDnode) != DND_STAT_RUNNING) {
-    dError("RPC %p, req:%s app:%p is ignored since dnode not running", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
-    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_APP_NOT_READY};
+    dError("RPC %p, req:%s ignored since dnode not running, app:%p", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
+    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_APP_NOT_READY, .ahandle = pReq->ahandle};
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pReq->pCont);
     return;
   }
 
   if (pReq->pCont == NULL) {
-    dTrace("RPC %p, req:%s app:%p not processed since content is null", pReq->handle, TMSG_INFO(msgType),
-           pReq->ahandle);
-    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_DND_INVALID_MSG_LEN};
+    dTrace("RPC %p, req:%s not processed since its empty, app:%p", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
+    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_DND_INVALID_MSG_LEN, .ahandle = pReq->ahandle};
     rpcSendResponse(&rspMsg);
     return;
   }
 
   DndMsgFp fp = pMgmt->msgFp[TMSG_INDEX(msgType)];
   if (fp != NULL) {
-    dTrace("RPC %p, req:%s app:%p will be processed", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
+    dTrace("RPC %p, req:%s will be processed, app:%p", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
     (*fp)(pDnode, pReq, pEpSet);
   } else {
-    dError("RPC %p, req:%s app:%p is not processed since no handle", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
-    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_MSG_NOT_PROCESSED};
+    dError("RPC %p, req:%s not processed since no handle, app:%p", pReq->handle, TMSG_INFO(msgType), pReq->ahandle);
+    SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_MSG_NOT_PROCESSED, .ahandle = pReq->ahandle};
     rpcSendResponse(&rspMsg);
     rpcFreeCont(pReq->pCont);
   }
@@ -285,24 +291,24 @@ static int32_t dndRetrieveUserAuthInfo(void *parent, char *user, char *spi, char
   SDnode *pDnode = parent;
 
   if (dndAuthInternalReq(parent, user, spi, encrypt, secret, ckey) == 0) {
-    dTrace("user:%s, get auth from internal mnode, spi:%d encrypt:%d", user, *spi, *encrypt);
+    dTrace("user:%s, get auth from mnode, spi:%d encrypt:%d", user, *spi, *encrypt);
     return 0;
   }
 
   if (dndGetUserAuthFromMnode(pDnode, user, spi, encrypt, secret, ckey) == 0) {
-    dTrace("user:%s, get auth from internal mnode, spi:%d encrypt:%d", user, *spi, *encrypt);
+    dTrace("user:%s, get auth from mnode, spi:%d encrypt:%d", user, *spi, *encrypt);
     return 0;
   }
 
   if (terrno != TSDB_CODE_APP_NOT_READY) {
-    dTrace("failed to get user auth from internal mnode since %s", terrstr());
+    dTrace("failed to get user auth from mnode since %s", terrstr());
     return -1;
   }
 
   SAuthReq *pReq = rpcMallocCont(sizeof(SAuthReq));
   tstrncpy(pReq->user, user, TSDB_USER_LEN);
 
-  SRpcMsg rpcMsg = {.pCont = pReq, .contLen = sizeof(SAuthReq), .msgType = TDMT_MND_AUTH};
+  SRpcMsg rpcMsg = {.pCont = pReq, .contLen = sizeof(SAuthReq), .msgType = TDMT_MND_AUTH, .ahandle = (void *)9528};
   SRpcMsg rpcRsp = {0};
   dTrace("user:%s, send user auth req to other mnodes, spi:%d encrypt:%d", user, pReq->spi, pReq->encrypt);
   dndSendMsgToMnodeRecv(pDnode, &rpcMsg, &rpcRsp);
@@ -346,7 +352,7 @@ static int32_t dndInitServer(SDnode *pDnode) {
 
   pMgmt->serverRpc = rpcOpen(&rpcInit);
   if (pMgmt->serverRpc == NULL) {
-    dError("failed to init rpc server");
+    dError("failed to init dnode rpc server");
     return -1;
   }
 

source/dnode/mgmt/impl/src/dndVnodes.c

@@ -253,7 +253,7 @@ static int32_t dndGetVnodesFromFile(SDnode *pDnode, SWrapperCfg **ppCfgs, int32_
     }
 
     for (int32_t i = 0; i < vnodesNum; ++i) {
-      cJSON       *vnode = cJSON_GetArrayItem(vnodes, i);
+      cJSON *      vnode = cJSON_GetArrayItem(vnodes, i);
       SWrapperCfg *pCfg = &pCfgs[i];
 
       cJSON *vgId = cJSON_GetObjectItem(vnode, "vgId");
@@ -382,7 +382,7 @@ static void *dnodeOpenVnodeFunc(void *param) {
     dndReportStartup(pDnode, "open-vnodes", stepDesc);
 
     SVnodeCfg cfg = {.pDnode = pDnode, .pTfs = pDnode->pTfs, .vgId = pCfg->vgId};
-    SVnode   *pImpl = vnodeOpen(pCfg->path, &cfg);
+    SVnode *  pImpl = vnodeOpen(pCfg->path, &cfg);
     if (pImpl == NULL) {
       dError("vgId:%d, failed to open vnode by thread:%d", pCfg->vgId, pThread->threadIndex);
       pThread->failed++;
@@ -737,15 +737,9 @@ int32_t dndProcessCompactVnodeReq(SDnode *pDnode, SRpcMsg *pReq) {
   return 0;
 }
 
-static void dndProcessVnodeQueryQueue(SVnodeObj *pVnode, SRpcMsg *pMsg) {
-  SRpcMsg *pRsp = NULL;
-  vnodeProcessQueryReq(pVnode->pImpl, pMsg, &pRsp);
-}
+static void dndProcessVnodeQueryQueue(SVnodeObj *pVnode, SRpcMsg *pMsg) { vnodeProcessQueryMsg(pVnode->pImpl, pMsg); }
 
-static void dndProcessVnodeFetchQueue(SVnodeObj *pVnode, SRpcMsg *pMsg) {
-  SRpcMsg *pRsp = NULL;
-  vnodeProcessFetchReq(pVnode->pImpl, pMsg, &pRsp);
-}
+static void dndProcessVnodeFetchQueue(SVnodeObj *pVnode, SRpcMsg *pMsg) { vnodeProcessFetchMsg(pVnode->pImpl, pMsg); }
 
 static void dndProcessVnodeWriteQueue(SVnodeObj *pVnode, STaosQall *qall, int32_t numOfMsgs) {
   SArray *pArray = taosArrayInit(numOfMsgs, sizeof(SRpcMsg *));
@@ -916,27 +910,27 @@ static int32_t dndInitVnodeWorkers(SDnode *pDnode) {
   int32_t maxWriteThreads = TMAX(pDnode->env.numOfCores, 1);
   int32_t maxSyncThreads = TMAX(pDnode->env.numOfCores / 2, 1);
 
-  SWorkerPool *pPool = &pMgmt->queryPool;
-  pPool->name = "vnode-query";
-  pPool->min = minQueryThreads;
-  pPool->max = maxQueryThreads;
-  if (tWorkerInit(pPool) != 0) return -1;
+  SQWorkerPool *pQPool = &pMgmt->queryPool;
+  pQPool->name = "vnode-query";
+  pQPool->min = minQueryThreads;
+  pQPool->max = maxQueryThreads;
+  if (tQWorkerInit(pQPool) != 0) return -1;
 
-  pPool = &pMgmt->fetchPool;
-  pPool->name = "vnode-fetch";
-  pPool->min = minFetchThreads;
-  pPool->max = maxFetchThreads;
-  if (tWorkerInit(pPool) != 0) return -1;
+  SFWorkerPool *pFPool = &pMgmt->fetchPool;
+  pFPool->name = "vnode-fetch";
+  pFPool->min = minFetchThreads;
+  pFPool->max = maxFetchThreads;
+  if (tFWorkerInit(pFPool) != 0) return -1;
 
-  SMWorkerPool *pMPool = &pMgmt->writePool;
-  pMPool->name = "vnode-write";
-  pMPool->max = maxWriteThreads;
-  if (tMWorkerInit(pMPool) != 0) return -1;
+  SWWorkerPool *pWPool = &pMgmt->writePool;
+  pWPool->name = "vnode-write";
+  pWPool->max = maxWriteThreads;
+  if (tWWorkerInit(pWPool) != 0) return -1;
 
-  pMPool = &pMgmt->syncPool;
-  pMPool->name = "vnode-sync";
-  pMPool->max = maxSyncThreads;
-  if (tMWorkerInit(pMPool) != 0) return -1;
+  pWPool = &pMgmt->syncPool;
+  pWPool->name = "vnode-sync";
+  pWPool->max = maxSyncThreads;
+  if (tWWorkerInit(pWPool) != 0) return -1;
 
   dDebug("vnode workers is initialized");
   return 0;
@@ -944,21 +938,21 @@ static int32_t dndInitVnodeWorkers(SDnode *pDnode) {
 
 static void dndCleanupVnodeWorkers(SDnode *pDnode) {
   SVnodesMgmt *pMgmt = &pDnode->vmgmt;
-  tWorkerCleanup(&pMgmt->fetchPool);
-  tWorkerCleanup(&pMgmt->queryPool);
-  tMWorkerCleanup(&pMgmt->writePool);
-  tMWorkerCleanup(&pMgmt->syncPool);
+  tFWorkerCleanup(&pMgmt->fetchPool);
+  tQWorkerCleanup(&pMgmt->queryPool);
+  tWWorkerCleanup(&pMgmt->writePool);
+  tWWorkerCleanup(&pMgmt->syncPool);
   dDebug("vnode workers is closed");
 }
 
 static int32_t dndAllocVnodeQueue(SDnode *pDnode, SVnodeObj *pVnode) {
   SVnodesMgmt *pMgmt = &pDnode->vmgmt;
 
-  pVnode->pWriteQ = tMWorkerAllocQueue(&pMgmt->writePool, pVnode, (FProcessItems)dndProcessVnodeWriteQueue);
-  pVnode->pApplyQ = tMWorkerAllocQueue(&pMgmt->writePool, pVnode, (FProcessItems)dndProcessVnodeApplyQueue);
-  pVnode->pSyncQ = tMWorkerAllocQueue(&pMgmt->syncPool, pVnode, (FProcessItems)dndProcessVnodeSyncQueue);
-  pVnode->pFetchQ = tWorkerAllocQueue(&pMgmt->fetchPool, pVnode, (FProcessItem)dndProcessVnodeFetchQueue);
-  pVnode->pQueryQ = tWorkerAllocQueue(&pMgmt->queryPool, pVnode, (FProcessItem)dndProcessVnodeQueryQueue);
+  pVnode->pWriteQ = tWWorkerAllocQueue(&pMgmt->writePool, pVnode, (FItems)dndProcessVnodeWriteQueue);
+  pVnode->pApplyQ = tWWorkerAllocQueue(&pMgmt->writePool, pVnode, (FItems)dndProcessVnodeApplyQueue);
+  pVnode->pSyncQ = tWWorkerAllocQueue(&pMgmt->syncPool, pVnode, (FItems)dndProcessVnodeSyncQueue);
+  pVnode->pFetchQ = tFWorkerAllocQueue(&pMgmt->fetchPool, pVnode, (FItem)dndProcessVnodeFetchQueue);
+  pVnode->pQueryQ = tQWorkerAllocQueue(&pMgmt->queryPool, pVnode, (FItem)dndProcessVnodeQueryQueue);
 
   if (pVnode->pApplyQ == NULL || pVnode->pWriteQ == NULL || pVnode->pSyncQ == NULL || pVnode->pFetchQ == NULL ||
       pVnode->pQueryQ == NULL) {
@@ -971,11 +965,11 @@ static int32_t dndAllocVnodeQueue(SDnode *pDnode, SVnodeObj *pVnode) {
 
 static void dndFreeVnodeQueue(SDnode *pDnode, SVnodeObj *pVnode) {
   SVnodesMgmt *pMgmt = &pDnode->vmgmt;
-  tWorkerFreeQueue(&pMgmt->queryPool, pVnode->pQueryQ);
-  tWorkerFreeQueue(&pMgmt->fetchPool, pVnode->pFetchQ);
-  tMWorkerFreeQueue(&pMgmt->writePool, pVnode->pWriteQ);
-  tMWorkerFreeQueue(&pMgmt->writePool, pVnode->pApplyQ);
-  tMWorkerFreeQueue(&pMgmt->syncPool, pVnode->pSyncQ);
+  tQWorkerFreeQueue(&pMgmt->queryPool, pVnode->pQueryQ);
+  tFWorkerFreeQueue(&pMgmt->fetchPool, pVnode->pFetchQ);
+  tWWorkerFreeQueue(&pMgmt->writePool, pVnode->pWriteQ);
+  tWWorkerFreeQueue(&pMgmt->writePool, pVnode->pApplyQ);
+  tWWorkerFreeQueue(&pMgmt->syncPool, pVnode->pSyncQ);
   pVnode->pWriteQ = NULL;
   pVnode->pApplyQ = NULL;
   pVnode->pSyncQ = NULL;

source/dnode/mgmt/impl/src/dndWorker.c

@@ -31,28 +31,28 @@ int32_t dndInitWorker(SDnode *pDnode, SDnodeWorker *pWorker, EWorkerType type, c
   pWorker->pDnode = pDnode;
 
   if (pWorker->type == DND_WORKER_SINGLE) {
-    SWorkerPool *pPool = &pWorker->pool;
+    SQWorkerPool *pPool = &pWorker->pool;
     pPool->name = name;
     pPool->min = minNum;
     pPool->max = maxNum;
-    if (tWorkerInit(pPool) != 0) {
+    if (tQWorkerInit(pPool) != 0) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
     }
-    pWorker->queue = tWorkerAllocQueue(pPool, pDnode, (FProcessItem)queueFp);
+    pWorker->queue = tQWorkerAllocQueue(pPool, pDnode, (FItem)queueFp);
     if (pWorker->queue == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
     }
   } else if (pWorker->type == DND_WORKER_MULTI) {
-    SMWorkerPool *pPool = &pWorker->mpool;
+    SWWorkerPool *pPool = &pWorker->mpool;
     pPool->name = name;
     pPool->max = maxNum;
-    if (tMWorkerInit(pPool) != 0) {
+    if (tWWorkerInit(pPool) != 0) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
     }
-    pWorker->queue = tMWorkerAllocQueue(pPool, pDnode, (FProcessItems)queueFp);
+    pWorker->queue = tWWorkerAllocQueue(pPool, pDnode, (FItems)queueFp);
     if (pWorker->queue == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
@@ -70,11 +70,11 @@ void dndCleanupWorker(SDnodeWorker *pWorker) {
   }
 
   if (pWorker->type == DND_WORKER_SINGLE) {
-    tWorkerCleanup(&pWorker->pool);
-    tWorkerFreeQueue(&pWorker->pool, pWorker->queue);
+    tQWorkerCleanup(&pWorker->pool);
+    tQWorkerFreeQueue(&pWorker->pool, pWorker->queue);
   } else if (pWorker->type == DND_WORKER_MULTI) {
-    tMWorkerCleanup(&pWorker->mpool);
-    tMWorkerFreeQueue(&pWorker->mpool, pWorker->queue);
+    tWWorkerCleanup(&pWorker->mpool);
+    tWWorkerFreeQueue(&pWorker->mpool, pWorker->queue);
   } else {
   }
 }

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/inc/mndConsumer.h

@@ -25,7 +25,7 @@ extern "C" {
 int32_t mndInitConsumer(SMnode *pMnode);
 void    mndCleanupConsumer(SMnode *pMnode);
 
-SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int32_t consumerId);
+SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int64_t consumerId);
 void            mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer);
 
 SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer);

source/dnode/mnode/impl/inc/mndDef.h

@@ -314,7 +314,7 @@ typedef struct {
   int8_t  outputType;
   int32_t outputLen;
   int32_t bufSize;
-  int64_t sigature;
+  int64_t signature;
   int32_t commentSize;
   int32_t codeSize;
   char*   pComment;
@@ -363,8 +363,9 @@ typedef struct SMqConsumerEp {
   int64_t      consumerId;  // -1 for unassigned
   int64_t      lastConsumerHbTs;
   int64_t      lastVgHbTs;
-  int32_t      execLen;
-  SSubQueryMsg qExec;
+  uint32_t     qmsgLen;
+  char*        qmsg;
+  //SSubQueryMsg qExec;
 } SMqConsumerEp;
 
 static FORCE_INLINE int32_t tEncodeSMqConsumerEp(void** buf, SMqConsumerEp* pConsumerEp) {
@@ -373,7 +374,9 @@ static FORCE_INLINE int32_t tEncodeSMqConsumerEp(void** buf, SMqConsumerEp* pCon
   tlen += taosEncodeFixedI32(buf, pConsumerEp->status);
   tlen += taosEncodeSEpSet(buf, &pConsumerEp->epSet);
   tlen += taosEncodeFixedI64(buf, pConsumerEp->consumerId);
-  tlen += tEncodeSSubQueryMsg(buf, &pConsumerEp->qExec);
+  //tlen += tEncodeSSubQueryMsg(buf, &pConsumerEp->qExec);
+  tlen += taosEncodeFixedU32(buf, pConsumerEp->qmsgLen);
+  tlen += taosEncodeBinary(buf, pConsumerEp->qmsg, pConsumerEp->qmsgLen);
   return tlen;
 }
 
@@ -382,8 +385,9 @@ static FORCE_INLINE void* tDecodeSMqConsumerEp(void** buf, SMqConsumerEp* pConsu
   buf = taosDecodeFixedI32(buf, &pConsumerEp->status);
   buf = taosDecodeSEpSet(buf, &pConsumerEp->epSet);
   buf = taosDecodeFixedI64(buf, &pConsumerEp->consumerId);
-  buf = tDecodeSSubQueryMsg(buf, &pConsumerEp->qExec);
-  pConsumerEp->execLen = sizeof(SSubQueryMsg) + pConsumerEp->qExec.contentLen;
+  //buf = tDecodeSSubQueryMsg(buf, &pConsumerEp->qExec);
+  buf = taosDecodeFixedU32(buf, &pConsumerEp->qmsgLen);
+  buf = taosDecodeBinary(buf, (void**)&pConsumerEp->qmsg, pConsumerEp->qmsgLen);
   return buf;
 }
 
@@ -402,11 +406,12 @@ typedef struct SMqSubscribeObj {
 
 static FORCE_INLINE SMqSubscribeObj* tNewSubscribeObj() {
   SMqSubscribeObj* pSub = malloc(sizeof(SMqSubscribeObj));
-  pSub->key[0] = 0;
-  pSub->epoch = 0;
   if (pSub == NULL) {
     return NULL;
   }
+  pSub->key[0] = 0;
+  pSub->epoch = 0;
+
   pSub->availConsumer = taosArrayInit(0, sizeof(int64_t));
   if (pSub->availConsumer == NULL) {
     free(pSub);
@@ -433,7 +438,7 @@ static FORCE_INLINE SMqSubscribeObj* tNewSubscribeObj() {
     free(pSub);
     return NULL;
   }
-  return NULL;
+  return pSub;
 }
 
 static FORCE_INLINE int32_t tEncodeSubscribeObj(void** buf, const SMqSubscribeObj* pSub) {

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

@@ -30,24 +30,23 @@
 #define MND_CONSUMER_VER_NUMBER 1
 #define MND_CONSUMER_RESERVE_SIZE 64
 
-static int32_t  mndConsumerActionInsert(SSdb *pSdb, SMqConsumerObj *pConsumer);
-static int32_t  mndConsumerActionDelete(SSdb *pSdb, SMqConsumerObj *pConsumer);
-static int32_t  mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pConsumer, SMqConsumerObj *pNewConsumer);
-static int32_t  mndProcessConsumerMetaMsg(SMnodeMsg *pMsg);
-static int32_t  mndGetConsumerMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
-static int32_t  mndRetrieveConsumer(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
-static void     mndCancelGetNextConsumer(SMnode *pMnode, void *pIter);
+static int32_t mndConsumerActionInsert(SSdb *pSdb, SMqConsumerObj *pConsumer);
+static int32_t mndConsumerActionDelete(SSdb *pSdb, SMqConsumerObj *pConsumer);
+static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pConsumer, SMqConsumerObj *pNewConsumer);
+static int32_t mndProcessConsumerMetaMsg(SMnodeMsg *pMsg);
+static int32_t mndGetConsumerMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
+static int32_t mndRetrieveConsumer(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
+static void    mndCancelGetNextConsumer(SMnode *pMnode, void *pIter);
 
 int32_t mndInitConsumer(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_CONSUMER,
-                     .keyType = SDB_KEY_BINARY,
+                     .keyType = SDB_KEY_INT64,
                      .encodeFp = (SdbEncodeFp)mndConsumerActionEncode,
                      .decodeFp = (SdbDecodeFp)mndConsumerActionDecode,
                      .insertFp = (SdbInsertFp)mndConsumerActionInsert,
                      .updateFp = (SdbUpdateFp)mndConsumerActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndConsumerActionDelete};
 
-
   return sdbSetTable(pMnode->pSdb, table);
 }
 
@@ -56,46 +55,20 @@ void mndCleanupConsumer(SMnode *pMnode) {}
 SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   int32_t tlen = tEncodeSMqConsumerObj(NULL, pConsumer);
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_CONSUMER, MND_CONSUMER_VER_NUMBER, tlen);
+  int32_t size = sizeof(int32_t) + tlen + MND_CONSUMER_RESERVE_SIZE;
+
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_CONSUMER, MND_CONSUMER_VER_NUMBER, size);
   if (pRaw == NULL) goto CM_ENCODE_OVER;
 
-  void* buf = malloc(tlen);
+  void *buf = malloc(tlen);
   if (buf == NULL) goto CM_ENCODE_OVER;
 
-  void* abuf = buf;
+  void *abuf = buf;
   tEncodeSMqConsumerObj(&abuf, pConsumer);
 
   int32_t dataPos = 0;
   SDB_SET_INT32(pRaw, dataPos, tlen, CM_ENCODE_OVER);
   SDB_SET_BINARY(pRaw, dataPos, buf, tlen, CM_ENCODE_OVER);
-
-#if 0
-  int32_t topicNum = taosArrayGetSize(pConsumer->topics);
-  SDB_SET_INT64(pRaw, dataPos, pConsumer->consumerId, CM_ENCODE_OVER);
-  int32_t len = strlen(pConsumer->cgroup);
-  SDB_SET_INT32(pRaw, dataPos, len, CM_ENCODE_OVER);
-  SDB_SET_BINARY(pRaw, dataPos, pConsumer->cgroup, len, CM_ENCODE_OVER);
-  SDB_SET_INT32(pRaw, dataPos, topicNum, CM_ENCODE_OVER);
-  for (int i = 0; i < topicNum; i++) {
-    int32_t           len;
-    SMqConsumerTopic *pConsumerTopic = taosArrayGet(pConsumer->topics, i);
-    len = strlen(pConsumerTopic->name);
-    SDB_SET_INT32(pRaw, dataPos, len, CM_ENCODE_OVER);
-    SDB_SET_BINARY(pRaw, dataPos, pConsumerTopic->name, len, CM_ENCODE_OVER);
-    int vgSize;
-    if (pConsumerTopic->vgroups == NULL) {
-      vgSize = 0;
-    } else {
-      vgSize = listNEles(pConsumerTopic->vgroups);
-    }
-    SDB_SET_INT32(pRaw, dataPos, vgSize, CM_ENCODE_OVER);
-    for (int j = 0; j < vgSize; j++) {
-      // SList* head;
-      /*SDB_SET_INT64(pRaw, dataPos, 0[> change to list item <]);*/
-    }
-  }
-#endif
-
   SDB_SET_RESERVE(pRaw, dataPos, MND_CONSUMER_RESERVE_SIZE, CM_ENCODE_OVER);
   SDB_SET_DATALEN(pRaw, dataPos, CM_ENCODE_OVER);
 
@@ -116,53 +89,35 @@ SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int8_t sver = 0;
-  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto CONSUME_DECODE_OVER;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto CM_DECODE_OVER;
 
   if (sver != MND_CONSUMER_VER_NUMBER) {
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
-    goto CONSUME_DECODE_OVER;
+    goto CM_DECODE_OVER;
   }
 
   SSdbRow *pRow = sdbAllocRow(sizeof(SMqConsumerObj));
-  if (pRow == NULL) goto CONSUME_DECODE_OVER;
+  if (pRow == NULL) goto CM_DECODE_OVER;
 
   SMqConsumerObj *pConsumer = sdbGetRowObj(pRow);
-  if (pConsumer == NULL) goto CONSUME_DECODE_OVER;
+  if (pConsumer == NULL) goto CM_DECODE_OVER;
 
   int32_t dataPos = 0;
   int32_t len;
-  SDB_GET_INT32(pRaw, dataPos, &len, CONSUME_DECODE_OVER);
-  void* buf = malloc(len);
-  if (buf == NULL) goto CONSUME_DECODE_OVER;
-  
-  SDB_GET_BINARY(pRaw, dataPos, buf, len, CONSUME_DECODE_OVER);
-
-  tDecodeSMqConsumerObj(buf, pConsumer);
-
-  SDB_GET_RESERVE(pRaw, dataPos, MND_CONSUMER_RESERVE_SIZE, CONSUME_DECODE_OVER);
+  SDB_GET_INT32(pRaw, dataPos, &len, CM_DECODE_OVER);
+  void *buf = malloc(len);
+  if (buf == NULL) goto CM_DECODE_OVER;
+  SDB_GET_BINARY(pRaw, dataPos, buf, len, CM_DECODE_OVER);
+  SDB_GET_RESERVE(pRaw, dataPos, MND_CONSUMER_RESERVE_SIZE, CM_DECODE_OVER);
+
+  if (tDecodeSMqConsumerObj(buf, pConsumer) == NULL) {
+    goto CM_DECODE_OVER;
+  }
 
   terrno = TSDB_CODE_SUCCESS;
 
-#if 0
-  SDB_GET_INT32(pRaw, dataPos, &topicNum, CONSUME_DECODE_OVER);
-  for (int i = 0; i < topicNum; i++) {
-    int32_t           topicLen;
-    SMqConsumerTopic *pConsumerTopic = malloc(sizeof(SMqConsumerTopic));
-    if (pConsumerTopic == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      // TODO
-      return NULL;
-    }
-    /*pConsumerTopic->vgroups = taosArrayInit(topicNum, sizeof(SMqConsumerTopic));*/
-    SDB_GET_INT32(pRaw, dataPos, &topicLen, CONSUME_DECODE_OVER);
-    SDB_GET_BINARY(pRaw, dataPos, pConsumerTopic->name, topicLen, CONSUME_DECODE_OVER);
-    int32_t vgSize;
-    SDB_GET_INT32(pRaw, dataPos, &vgSize, CONSUME_DECODE_OVER);
-  }
-#endif
-
-CONSUME_DECODE_OVER:
-  if (terrno != 0) {
+CM_DECODE_OVER:
+  if (terrno != TSDB_CODE_SUCCESS) {
     mError("consumer:%ld, failed to decode from raw:%p since %s", pConsumer->consumerId, pRaw, terrstr());
     tfree(pRow);
     return NULL;
@@ -191,7 +146,7 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
   return 0;
 }
 
-SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int32_t consumerId) {
+SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int64_t consumerId) {
   SSdb           *pSdb = pMnode->pSdb;
   SMqConsumerObj *pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &consumerId);
   if (pConsumer == NULL) {

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

@@ -25,14 +25,14 @@ static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc);
 static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw);
 static int32_t  mndFuncActionInsert(SSdb *pSdb, SFuncObj *pFunc);
 static int32_t  mndFuncActionDelete(SSdb *pSdb, SFuncObj *pFunc);
-static int32_t  mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOldFunc, SFuncObj *pNewFunc);
-static int32_t  mndCreateFunc(SMnode *pMnode, SMnodeMsg *pMsg, SCreateFuncReq *pCreate);
-static int32_t  mndDropFunc(SMnode *pMnode, SMnodeMsg *pMsg, SFuncObj *pFunc);
-static int32_t  mndProcessCreateFuncMsg(SMnodeMsg *pMsg);
-static int32_t  mndProcessDropFuncMsg(SMnodeMsg *pMsg);
-static int32_t  mndProcessRetrieveFuncMsg(SMnodeMsg *pMsg);
-static int32_t  mndGetFuncMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta);
-static int32_t  mndRetrieveFuncs(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows);
+static int32_t  mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew);
+static int32_t  mndCreateFunc(SMnode *pMnode, SMnodeMsg *pReq, SCreateFuncReq *pCreate);
+static int32_t  mndDropFunc(SMnode *pMnode, SMnodeMsg *pReq, SFuncObj *pFunc);
+static int32_t  mndProcessCreateFuncReq(SMnodeMsg *pReq);
+static int32_t  mndProcessDropFuncReq(SMnodeMsg *pReq);
+static int32_t  mndProcessRetrieveFuncReq(SMnodeMsg *pReq);
+static int32_t  mndGetFuncMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta);
+static int32_t  mndRetrieveFuncs(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows);
 static void     mndCancelGetNextFunc(SMnode *pMnode, void *pIter);
 
 int32_t mndInitFunc(SMnode *pMnode) {
@@ -44,13 +44,13 @@ int32_t mndInitFunc(SMnode *pMnode) {
                      .updateFp = (SdbUpdateFp)mndFuncActionUpdate,
                      .deleteFp = (SdbDeleteFp)mndFuncActionDelete};
 
-  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_FUNCTION, mndProcessCreateFuncMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_DROP_FUNCTION, mndProcessDropFuncMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_RETRIEVE_FUNCTION, mndProcessRetrieveFuncMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_FUNC, mndProcessCreateFuncReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_DROP_FUNC, mndProcessDropFuncReq);
+  mndSetMsgHandle(pMnode, TDMT_MND_RETRIEVE_FUNC, mndProcessRetrieveFuncReq);
 
-  mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_FUNCTION, mndGetFuncMeta);
-  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_FUNCTION, mndRetrieveFuncs);
-  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_FUNCTION, mndCancelGetNextFunc);
+  mndAddShowMetaHandle(pMnode, TSDB_MGMT_TABLE_FUNC, mndGetFuncMeta);
+  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_FUNC, mndRetrieveFuncs);
+  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_FUNC, mndCancelGetNextFunc);
 
   return sdbSetTable(pMnode->pSdb, table);
 }
@@ -73,7 +73,7 @@ static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) {
   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->sigature, 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)
@@ -104,13 +104,11 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
     goto FUNC_DECODE_OVER;
   }
 
-  int32_t  size = sizeof(SFuncObj) + TSDB_FUNC_COMMENT_LEN + TSDB_FUNC_CODE_LEN;
-  SSdbRow *pRow = sdbAllocRow(size);
+  SSdbRow *pRow = sdbAllocRow(sizeof(SFuncObj));
   if (pRow == NULL) goto FUNC_DECODE_OVER;
 
   SFuncObj *pFunc = sdbGetRowObj(pRow);
   if (pFunc == NULL) goto FUNC_DECODE_OVER;
-  char *tmp = (char *)pFunc + sizeof(SFuncObj);
 
   int32_t dataPos = 0;
   SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_DECODE_OVER)
@@ -121,12 +119,18 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
   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->sigature, 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->pData, pFunc->commentSize + pFunc->codeSize, FUNC_DECODE_OVER)
-  pFunc->pComment = pFunc->pData;
-  pFunc->pCode = (pFunc->pData + pFunc->commentSize);
+
+  pFunc->pComment = calloc(1, pFunc->commentSize);
+  pFunc->pCode = calloc(1, pFunc->codeSize);
+  if (pFunc->pComment == NULL || pFunc->pCode == NULL) {
+    goto FUNC_DECODE_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)
 
   terrno = 0;
 
@@ -148,136 +152,136 @@ 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;
 }
 
-static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOldFunc, SFuncObj *pNewFunc) {
-  mTrace("func:%s, perform update action, old row:%p new row:%p", pOldFunc->name, pOldFunc, pNewFunc);
+static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew) {
+  mTrace("func:%s, perform update action, old row:%p new row:%p", pOld->name, pOld, pNew);
   return 0;
 }
 
-static int32_t mndCreateFunc(SMnode *pMnode, SMnodeMsg *pMsg, SCreateFuncReq *pCreate) {
-  SFuncObj *pFunc = calloc(1, sizeof(SFuncObj) + pCreate->commentSize + pCreate->codeSize);
-  pFunc->createdTime = taosGetTimestampMs();
-  pFunc->funcType = pCreate->funcType;
-  pFunc->scriptType = pCreate->scriptType;
-  pFunc->outputType = pCreate->outputType;
-  pFunc->outputLen = pCreate->outputLen;
-  pFunc->bufSize = pCreate->bufSize;
-  pFunc->sigature = pCreate->sigature;
-  pFunc->commentSize = pCreate->commentSize;
-  pFunc->codeSize = pCreate->codeSize;
-  pFunc->pComment = pFunc->pData;
-  memcpy(pFunc->pComment, pCreate->pCont, pCreate->commentSize);
-  pFunc->pCode = pFunc->pData + pCreate->commentSize;
-  memcpy(pFunc->pCode, pCreate->pCont + pCreate->commentSize, pFunc->codeSize);
-
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pMsg->rpcMsg);
-  if (pTrans == NULL) {
-    free(pFunc);
-    mError("func:%s, failed to create since %s", pCreate->name, terrstr());
-    return -1;
+static SFuncObj *mndAcquireFunc(SMnode *pMnode, char *funcName) {
+  SSdb     *pSdb = pMnode->pSdb;
+  SFuncObj *pFunc = sdbAcquire(pSdb, SDB_FUNC, funcName);
+  if (pFunc == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
+    terrno = TSDB_CODE_MND_FUNC_NOT_EXIST;
   }
+  return pFunc;
+}
 
-  mDebug("trans:%d, used to create func:%s", pTrans->id, pCreate->name);
+static void mndReleaseFunc(SMnode *pMnode, SFuncObj *pFunc) {
+  SSdb *pSdb = pMnode->pSdb;
+  sdbRelease(pSdb, pFunc);
+}
 
-  SSdbRaw *pRedoRaw = mndFuncActionEncode(pFunc);
-  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
-    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
-    free(pFunc);
-    mndTransDrop(pTrans);
-    return -1;
+static int32_t mndCreateFunc(SMnode *pMnode, SMnodeMsg *pReq, SCreateFuncReq *pCreate) {
+  int32_t code = -1;
+  STrans *pTrans = NULL;
+
+  SFuncObj func = {0};
+  memcpy(func.name, pCreate->name, TSDB_FUNC_NAME_LEN);
+  func.createdTime = taosGetTimestampMs();
+  func.funcType = pCreate->funcType;
+  func.scriptType = pCreate->scriptType;
+  func.outputType = pCreate->outputType;
+  func.outputLen = pCreate->outputLen;
+  func.bufSize = pCreate->bufSize;
+  func.signature = pCreate->signature;
+  func.commentSize = pCreate->commentSize;
+  func.codeSize = pCreate->codeSize;
+  func.pComment = malloc(func.commentSize);
+  func.pCode = malloc(func.codeSize);
+  if (func.pCode == NULL || func.pCode == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto CREATE_FUNC_OVER;
   }
-  sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING);
 
-  SSdbRaw *pUndoRaw = mndFuncActionEncode(pFunc);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
-    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
-    free(pFunc);
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED);
+  memcpy(func.pComment, pCreate->pCont, pCreate->commentSize);
+  memcpy(func.pCode, pCreate->pCont + pCreate->commentSize, func.codeSize);
 
-  SSdbRaw *pCommitRaw = mndFuncActionEncode(pFunc);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
-    free(pFunc);
-    mndTransDrop(pTrans);
-    return -1;
-  }
-  sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
+  pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pReq->rpcMsg);
+  if (pTrans == NULL) goto CREATE_FUNC_OVER;
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) {
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
+  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;
 
-  free(pFunc);
+  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;
+
+  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 (mndTransPrepare(pMnode, pTrans) != 0) goto CREATE_FUNC_OVER;
+
+  code = 0;
+
+CREATE_FUNC_OVER:
+  free(func.pCode);
+  free(func.pComment);
   mndTransDrop(pTrans);
-  return 0;
+  return code;
 }
 
-static int32_t mndDropFunc(SMnode *pMnode, SMnodeMsg *pMsg, SFuncObj *pFunc) {
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pMsg->rpcMsg);
-  if (pTrans == NULL) {
-    mError("func:%s, failed to drop since %s", pFunc->name, terrstr());
-    return -1;
-  }
+static int32_t mndDropFunc(SMnode *pMnode, SMnodeMsg *pReq, SFuncObj *pFunc) {
+  int32_t code = -1;
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pReq->rpcMsg);
+  if (pTrans == NULL) goto DROP_FUNC_OVER;
+
   mDebug("trans:%d, used to drop user:%s", pTrans->id, pFunc->name);
 
   SSdbRaw *pRedoRaw = mndFuncActionEncode(pFunc);
-  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
-    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto DROP_FUNC_OVER;
   sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING);
 
   SSdbRaw *pUndoRaw = mndFuncActionEncode(pFunc);
-  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
-    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
+  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto DROP_FUNC_OVER;
   sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
 
   SSdbRaw *pCommitRaw = mndFuncActionEncode(pFunc);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
+  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto DROP_FUNC_OVER;
   sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) {
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    mndTransDrop(pTrans);
-    return -1;
-  }
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_FUNC_OVER;
+
+  code = 0;
 
+DROP_FUNC_OVER:
   mndTransDrop(pTrans);
-  return 0;
+  return code;
 }
 
-static int32_t mndProcessCreateFuncMsg(SMnodeMsg *pMsg) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndProcessCreateFuncReq(SMnodeMsg *pReq) {
+  SMnode *pMnode = pReq->pMnode;
 
-  SCreateFuncReq *pCreate = pMsg->rpcMsg.pCont;
+  SCreateFuncReq *pCreate = pReq->rpcMsg.pCont;
   pCreate->outputLen = htonl(pCreate->outputLen);
   pCreate->bufSize = htonl(pCreate->bufSize);
-  pCreate->sigature = htobe64(pCreate->sigature);
+  pCreate->signature = htobe64(pCreate->signature);
   pCreate->commentSize = htonl(pCreate->commentSize);
   pCreate->codeSize = htonl(pCreate->codeSize);
 
   mDebug("func:%s, start to create", pCreate->name);
 
-  SFuncObj *pFunc = sdbAcquire(pMnode->pSdb, SDB_FUNC, pCreate->name);
+  SFuncObj *pFunc = mndAcquireFunc(pMnode, pCreate->name);
   if (pFunc != NULL) {
-    sdbRelease(pMnode->pSdb, pFunc);
-    terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST;
-    mError("func:%s, failed to create since %s", pCreate->name, terrstr());
+    mndReleaseFunc(pMnode, pFunc);
+    if (pCreate->igExists) {
+      mDebug("stb:%s, already exist, ignore exist is set", pCreate->name);
+      return 0;
+    } else {
+      terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST;
+      mError("func:%s, failed to create since %s", pCreate->name, terrstr());
+      return -1;
+    }
+  } else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) {
+    mError("stb:%s, failed to create since %s", pCreate->name, terrstr());
     return -1;
   }
 
@@ -305,14 +309,13 @@ static int32_t mndProcessCreateFuncMsg(SMnodeMsg *pMsg) {
     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;
   }
 
-  int32_t code = mndCreateFunc(pMnode, pMsg, pCreate);
-
+  int32_t code = mndCreateFunc(pMnode, pReq, pCreate);
   if (code != 0) {
     mError("func:%s, failed to create since %s", pCreate->name, terrstr());
     return -1;
@@ -321,9 +324,9 @@ static int32_t mndProcessCreateFuncMsg(SMnodeMsg *pMsg) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
-static int32_t mndProcessDropFuncMsg(SMnodeMsg *pMsg) {
-  SMnode       *pMnode = pMsg->pMnode;
-  SDropFuncReq *pDrop = pMsg->rpcMsg.pCont;
+static int32_t mndProcessDropFuncReq(SMnodeMsg *pReq) {
+  SMnode       *pMnode = pReq->pMnode;
+  SDropFuncReq *pDrop = pReq->rpcMsg.pCont;
 
   mDebug("func:%s, start to drop", pDrop->name);
 
@@ -333,14 +336,20 @@ static int32_t mndProcessDropFuncMsg(SMnodeMsg *pMsg) {
     return -1;
   }
 
-  SFuncObj *pFunc = sdbAcquire(pMnode->pSdb, SDB_FUNC, pDrop->name);
+  SFuncObj *pFunc = mndAcquireFunc(pMnode, pDrop->name);
   if (pFunc == NULL) {
-    terrno = TSDB_CODE_MND_FUNC_NOT_EXIST;
-    mError("func:%s, failed to drop since %s", pDrop->name, terrstr());
-    return -1;
+    if (pDrop->igNotExists) {
+      mDebug("func:%s, not exist, ignore not exist is set", pDrop->name);
+      return 0;
+    } else {
+      terrno = TSDB_CODE_MND_FUNC_NOT_EXIST;
+      mError("func:%s, failed to drop since %s", pDrop->name, terrstr());
+      return -1;
+    }
   }
 
-  int32_t code = mndDropFunc(pMnode, pMsg, pFunc);
+  int32_t code = mndDropFunc(pMnode, pReq, pFunc);
+  mndReleaseFunc(pMnode, pFunc);
 
   if (code != 0) {
     mError("func:%s, failed to drop since %s", pDrop->name, terrstr());
@@ -350,15 +359,26 @@ static int32_t mndProcessDropFuncMsg(SMnodeMsg *pMsg) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
-static int32_t mndProcessRetrieveFuncMsg(SMnodeMsg *pMsg) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndProcessRetrieveFuncReq(SMnodeMsg *pReq) {
+  int32_t code = -1;
+  SMnode *pMnode = pReq->pMnode;
 
-  SRetrieveFuncReq *pRetrieve = pMsg->rpcMsg.pCont;
+  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 size = sizeof(SRetrieveFuncRsp) + (sizeof(SFuncInfo) + TSDB_FUNC_CODE_LEN) * pRetrieve->numOfFuncs + 16384;
+  int32_t fsize = sizeof(SFuncInfo) + TSDB_FUNC_CODE_LEN + TSDB_FUNC_COMMENT_LEN;
+  int32_t size = sizeof(SRetrieveFuncRsp) + fsize * pRetrieve->numOfFuncs;
 
   SRetrieveFuncRsp *pRetrieveRsp = rpcMallocCont(size);
+  if (pRetrieveRsp == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto FUNC_RETRIEVE_OVER;
+  }
+
   pRetrieveRsp->numOfFuncs = htonl(pRetrieve->numOfFuncs);
   char *pOutput = pRetrieveRsp->pFuncInfos;
 
@@ -366,37 +386,42 @@ static int32_t mndProcessRetrieveFuncMsg(SMnodeMsg *pMsg) {
     char funcName[TSDB_FUNC_NAME_LEN] = {0};
     memcpy(funcName, pRetrieve->pFuncNames + i * TSDB_FUNC_NAME_LEN, TSDB_FUNC_NAME_LEN);
 
-    SFuncObj *pFunc = sdbAcquire(pMnode->pSdb, SDB_FUNC, funcName);
+    SFuncObj *pFunc = mndAcquireFunc(pMnode, funcName);
     if (pFunc == NULL) {
       terrno = TSDB_CODE_MND_INVALID_FUNC;
       mError("func:%s, failed to retrieve since %s", funcName, terrstr());
-      return -1;
+      goto FUNC_RETRIEVE_OVER;
     }
 
     SFuncInfo *pFuncInfo = (SFuncInfo *)pOutput;
-
-    strncpy(pFuncInfo->name, pFunc->name, TSDB_FUNC_NAME_LEN);
+    memcpy(pFuncInfo->name, pFunc->name, TSDB_FUNC_NAME_LEN);
     pFuncInfo->funcType = pFunc->funcType;
     pFuncInfo->scriptType = pFunc->scriptType;
     pFuncInfo->outputType = pFunc->outputType;
     pFuncInfo->outputLen = htonl(pFunc->outputLen);
     pFuncInfo->bufSize = htonl(pFunc->bufSize);
-    pFuncInfo->sigature = htobe64(pFunc->sigature);
+    pFuncInfo->signature = htobe64(pFunc->signature);
     pFuncInfo->commentSize = htonl(pFunc->commentSize);
     pFuncInfo->codeSize = htonl(pFunc->codeSize);
-    memcpy(pFuncInfo->pCont, pFunc->pCode, pFunc->commentSize + pFunc->codeSize);
-
-    pOutput += sizeof(SFuncInfo) + pFunc->commentSize + pFunc->codeSize;
+    memcpy(pFuncInfo->pCont, pFunc->pComment, pFunc->commentSize);
+    memcpy(pFuncInfo->pCont + pFunc->commentSize, pFunc->pCode, pFunc->codeSize);
+    pOutput += (sizeof(SFuncInfo) + pFunc->commentSize + pFunc->codeSize);
+    mndReleaseFunc(pMnode, pFunc);
   }
 
-  pMsg->pCont = pRetrieveRsp;
-  pMsg->contLen = (int32_t)(pOutput - (char *)pRetrieveRsp);
+  pReq->pCont = pRetrieveRsp;
+  pReq->contLen = (int32_t)(pOutput - (char *)pRetrieveRsp);
 
-  return 0;
+  code = 0;
+
+FUNC_RETRIEVE_OVER:
+  if (code != 0) rpcFreeCont(pRetrieveRsp);
+
+  return code;
 }
 
-static int32_t mndGetFuncMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *pMeta) {
-  SMnode *pMnode = pMsg->pMnode;
+static int32_t mndGetFuncMeta(SMnodeMsg *pReq, SShowObj *pShow, STableMetaRsp *pMeta) {
+  SMnode *pMnode = pReq->pMnode;
   SSdb   *pSdb = pMnode->pSdb;
 
   int32_t  cols = 0;
@@ -454,7 +479,7 @@ static int32_t mndGetFuncMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaRsp *p
 
   pShow->numOfRows = sdbGetSize(pSdb, SDB_FUNC);
   pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1];
-  strcpy(pMeta->tbFname, "show funcs");
+  strcpy(pMeta->tbFname, mndShowStr(pShow->type));
 
   return 0;
 }
@@ -477,8 +502,8 @@ static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int16_t le
   return tDataTypes[type].name;
 }
 
-static int32_t mndRetrieveFuncs(SMnodeMsg *pMsg, SShowObj *pShow, char *data, int32_t rows) {
-  SMnode   *pMnode = pMsg->pMnode;
+static int32_t mndRetrieveFuncs(SMnodeMsg *pReq, SShowObj *pShow, char *data, int32_t rows) {
+  SMnode   *pMnode = pReq->pMnode;
   SSdb     *pSdb = pMnode->pSdb;
   int32_t   numOfRows = 0;
   SFuncObj *pFunc = NULL;

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

@@ -296,7 +296,7 @@ char *mndShowStr(int32_t showType) {
       return "show streamtables";
     case TSDB_MGMT_TABLE_TP:
       return "show topics";
-    case TSDB_MGMT_TABLE_FUNCTION:
+    case TSDB_MGMT_TABLE_FUNC:
       return "show functions";
     default:
       return "undefined";

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

@@ -123,8 +123,7 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
     goto STB_DECODE_OVER;
   }
 
-  int32_t  size = sizeof(SStbObj) + TSDB_MAX_COLUMNS * sizeof(SSchema);
-  SSdbRow *pRow = sdbAllocRow(size);
+  SSdbRow *pRow = sdbAllocRow(sizeof(SStbObj));
   if (pRow == NULL) goto STB_DECODE_OVER;
 
   SStbObj *pStb = sdbGetRowObj(pRow);
@@ -143,6 +142,9 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
 
   int32_t totalCols = pStb->numOfColumns + pStb->numOfTags;
   pStb->pSchema = calloc(totalCols, sizeof(SSchema));
+  if (pStb->pSchema == NULL) {
+    goto STB_DECODE_OVER;
+  }
 
   for (int32_t i = 0; i < totalCols; ++i) {
     SSchema *pSchema = &pStb->pSchema[i];
@@ -448,7 +450,7 @@ static int32_t mndCreateStb(SMnode *pMnode, SMnodeMsg *pReq, SMCreateStbReq *pCr
     stbObj.pSchema[i].colId = i + 1;
   }
 
-  int32_t code = 0;
+  int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pReq->rpcMsg);
   if (pTrans == NULL) goto CREATE_STB_OVER;
 
@@ -481,7 +483,7 @@ static int32_t mndProcessMCreateStbReq(SMnodeMsg *pReq) {
 
   SStbObj *pStb = mndAcquireStb(pMnode, pCreate->name);
   if (pStb != NULL) {
-    sdbRelease(pMnode->pSdb, pStb);
+    mndReleaseStb(pMnode, pStb);
     if (pCreate->igExists) {
       mDebug("stb:%s, already exist, ignore exist is set", pCreate->name);
       return 0;
@@ -492,6 +494,7 @@ static int32_t mndProcessMCreateStbReq(SMnodeMsg *pReq) {
     }
   } else if (terrno != TSDB_CODE_MND_STB_NOT_EXIST) {
     mError("stb:%s, failed to create since %s", pCreate->name, terrstr());
+    return -1;
   }
 
   // topic should have different name with stb
@@ -640,7 +643,7 @@ static int32_t mndDropStb(SMnode *pMnode, SMnodeMsg *pReq, SStbObj *pStb) {
 
 DROP_STB_OVER:
   mndTransDrop(pTrans);
-  return 0;
+  return code;
 }
 
 static int32_t mndProcessMDropStbReq(SMnodeMsg *pReq) {
@@ -665,7 +668,6 @@ static int32_t mndProcessMDropStbReq(SMnodeMsg *pReq) {
   mndReleaseStb(pMnode, pStb);
 
   if (code != 0) {
-    terrno = code;
     mError("stb:%s, failed to drop since %s", pDrop->name, terrstr());
     return -1;
   }

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

@@ -30,6 +30,8 @@
 #define MND_SUBSCRIBE_VER_NUMBER 1
 #define MND_SUBSCRIBE_RESERVE_SIZE 64
 
+static char *mndMakeSubscribeKey(char *cgroup, char *topicName);
+
 static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *);
 static SSdbRow *mndSubActionDecode(SSdbRaw *pRaw);
 static int32_t  mndSubActionInsert(SSdb *pSdb, SMqSubscribeObj *);
@@ -41,9 +43,10 @@ static int32_t mndProcessSubscribeRsp(SMnodeMsg *pMsg);
 static int32_t mndProcessSubscribeInternalReq(SMnodeMsg *pMsg);
 static int32_t mndProcessSubscribeInternalRsp(SMnodeMsg *pMsg);
 static int32_t mndProcessMqTimerMsg(SMnodeMsg *pMsg);
+static int32_t mndProcessGetSubEpReq(SMnodeMsg *pMsg);
 
 static int mndBuildMqSetConsumerVgReq(SMnode *pMnode, STrans *pTrans, SMqConsumerObj *pConsumer,
-                                      SMqConsumerTopic *pConsumerTopic, SMqTopicObj *pTopic);
+                                      SMqConsumerTopic *pConsumerTopic, SMqTopicObj *pTopic, SMqConsumerEp *pSub);
 
 int32_t mndInitSubscribe(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_SUBSCRIBE,
@@ -55,11 +58,62 @@ int32_t mndInitSubscribe(SMnode *pMnode) {
                      .deleteFp = (SdbDeleteFp)mndSubActionDelete};
 
   mndSetMsgHandle(pMnode, TDMT_MND_SUBSCRIBE, mndProcessSubscribeReq);
-  mndSetMsgHandle(pMnode, TDMT_VND_SUBSCRIBE_RSP, mndProcessSubscribeInternalRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_MQ_SET_CONN_RSP, mndProcessSubscribeInternalRsp);
   mndSetMsgHandle(pMnode, TDMT_MND_MQ_TIMER, mndProcessMqTimerMsg);
+  mndSetMsgHandle(pMnode, TDMT_MND_GET_SUB_EP, mndProcessGetSubEpReq);
   return sdbSetTable(pMnode->pSdb, table);
 }
 
+static int32_t mndProcessGetSubEpReq(SMnodeMsg *pMsg) {
+  SMnode           *pMnode = pMsg->pMnode;
+  SMqCMGetSubEpReq *pReq = (SMqCMGetSubEpReq *)pMsg->pCont;
+  SMqCMGetSubEpRsp  rsp;
+  int64_t           consumerId = be64toh(pReq->consumerId);
+
+  SMqConsumerObj *pConsumer = mndAcquireConsumer(pMsg->pMnode, consumerId);
+  if (pConsumer == NULL) {
+    /*terrno = */
+    return -1;
+  }
+  ASSERT(strcmp(pReq->cgroup, pConsumer->cgroup) == 0);
+
+  strcpy(rsp.cgroup, pReq->cgroup);
+  rsp.consumerId = consumerId;
+  SArray *pTopics = pConsumer->topics;
+  int32_t sz = taosArrayGetSize(pTopics);
+  rsp.topics = taosArrayInit(sz, sizeof(SMqSubTopicEp));
+  for (int32_t i = 0; i < sz; i++) {
+    SMqSubTopicEp     topicEp;
+    SMqConsumerTopic *pConsumerTopic = taosArrayGet(pTopics, i);
+    strcpy(topicEp.topic, pConsumerTopic->name);
+
+    SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, pConsumerTopic->name);
+    int32_t          assignedSz = taosArrayGetSize(pSub->assigned);
+    topicEp.vgs = taosArrayInit(assignedSz, sizeof(SMqSubVgEp));
+    for (int32_t j = 0; j < assignedSz; j++) {
+      SMqConsumerEp *pCEp = taosArrayGet(pSub->assigned, i);
+      if (pCEp->consumerId == consumerId) {
+        taosArrayPush(pSub->assigned, pCEp);
+      }
+    }
+    if (taosArrayGetSize(topicEp.vgs) != 0) {
+      taosArrayPush(rsp.topics, &topicEp);
+    }
+  }
+  int32_t tlen = tEncodeSMqCMGetSubEpRsp(NULL, &rsp);
+  void   *buf = malloc(tlen);
+  if (buf == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+  void *abuf = buf;
+  tEncodeSMqCMGetSubEpRsp(&abuf, &rsp);
+  //TODO: free rsp
+  pMsg->pCont = buf;
+  pMsg->contLen = tlen;
+  return 0;
+}
+
 static int32_t mndSplitSubscribeKey(char *key, char **topic, char **cgroup) {
   int i = 0;
   while (key[i] != ':') {
@@ -96,25 +150,28 @@ static int32_t mndProcessMqTimerMsg(SMnodeMsg *pMsg) {
         pSub->nextConsumerIdx = (pSub->nextConsumerIdx + 1) % taosArrayGetSize(pSub->availConsumer);
 
         // build msg
-        SMqSetCVgReq req = {
-            .vgId = pCEp->vgId,
-            .oldConsumerId = -1,
-            .newConsumerId = consumerId,
-        };
-        strcpy(req.cgroup, cgroup);
-        strcpy(req.topicName, topic);
-        strcpy(req.sql, pTopic->sql);
-        strcpy(req.logicalPlan, pTopic->logicalPlan);
-        strcpy(req.physicalPlan, pTopic->physicalPlan);
-        memcpy(&req.msg, &pCEp->qExec, pCEp->execLen);
-        int32_t tlen = tEncodeSMqSetCVgReq(NULL, &req);
+
+        SMqSetCVgReq *pReq = malloc(sizeof(SMqSetCVgReq));
+        if (pReq == NULL) {
+          terrno = TSDB_CODE_OUT_OF_MEMORY;
+          return -1;
+        }
+        strcpy(pReq->cgroup, cgroup);
+        strcpy(pReq->topicName, topic);
+        pReq->sql = strdup(pTopic->sql);
+        pReq->logicalPlan = strdup(pTopic->logicalPlan);
+        pReq->physicalPlan = strdup(pTopic->physicalPlan);
+        pReq->qmsgLen = pCEp->qmsgLen;
+        /*memcpy(pReq->qmsg, pCEp->qmsg, pCEp->qmsgLen);*/
+        pReq->qmsg = strdup(pCEp->qmsg);
+        int32_t tlen = tEncodeSMqSetCVgReq(NULL, pReq);
         void   *reqStr = malloc(tlen);
         if (reqStr == NULL) {
           terrno = TSDB_CODE_OUT_OF_MEMORY;
           return -1;
         }
         void *abuf = reqStr;
-        tEncodeSMqSetCVgReq(abuf, &req);
+        tEncodeSMqSetCVgReq(&abuf, pReq);
 
         // persist msg
         STransAction action = {0};
@@ -128,6 +185,7 @@ static int32_t mndProcessMqTimerMsg(SMnodeMsg *pMsg) {
         SSdbRaw *pRaw = mndSubActionEncode(pSub);
         mndTransAppendRedolog(pTrans, pRaw);
 
+        free(pReq);
         tfree(topic);
         tfree(cgroup);
       }
@@ -143,30 +201,48 @@ static int32_t mndProcessMqTimerMsg(SMnodeMsg *pMsg) {
 }
 
 static int mndInitUnassignedVg(SMnode *pMnode, SMqTopicObj *pTopic, SArray *unassignedVg) {
-  //convert phyplan to dag
+  // convert phyplan to dag
   SQueryDag *pDag = qStringToDag(pTopic->physicalPlan);
-  SArray *pArray;
+  SArray    *pArray;
+  SArray    *inner = taosArrayGet(pDag->pSubplans, 0);
+  SSubplan  *plan = taosArrayGetP(inner, 0);
+  plan->execNode.inUse = 0;
+  strcpy(plan->execNode.epAddr[0].fqdn, "localhost");
+  plan->execNode.epAddr[0].port = 6030;
+  plan->execNode.nodeId = 2;
+  plan->execNode.numOfEps = 1;
+
   if (schedulerConvertDagToTaskList(pDag, &pArray) < 0) {
     return -1;
   }
   int32_t sz = taosArrayGetSize(pArray);
-  //convert dag to msg
+  // convert dag to msg
   for (int32_t i = 0; i < sz; i++) {
     SMqConsumerEp CEp;
     CEp.status = 0;
     CEp.lastConsumerHbTs = CEp.lastVgHbTs = -1;
-    STaskInfo* pTaskInfo = taosArrayGet(pArray, i);
+    STaskInfo *pTaskInfo = taosArrayGet(pArray, i);
     tConvertQueryAddrToEpSet(&CEp.epSet, &pTaskInfo->addr);
+    /*mDebug("subscribe convert ep %d %s %s %s %s %s\n", CEp.epSet.numOfEps, CEp.epSet.fqdn[0], CEp.epSet.fqdn[1],
+     * CEp.epSet.fqdn[2], CEp.epSet.fqdn[3], CEp.epSet.fqdn[4]);*/
     CEp.vgId = pTaskInfo->addr.nodeId;
+    CEp.qmsg = strdup(pTaskInfo->msg->msg);
+    CEp.qmsgLen = strlen(CEp.qmsg) + 1;
+    printf("abc:\n%s\n", CEp.qmsg);
+    /*CEp.qmsg = malloc(CEp.qmsgLen);*/
+    /*if (CEp.qmsg == NULL) {*/
+    /*return -1;*/
+    /*}*/
+    /*memcpy(CEp.qmsg, pTaskInfo->msg->msg, pTaskInfo->msg->contentLen);*/
     taosArrayPush(unassignedVg, &CEp);
   }
 
-  qDestroyQueryDag(pDag);
+  /*qDestroyQueryDag(pDag);*/
   return 0;
 }
 
 static int mndBuildMqSetConsumerVgReq(SMnode *pMnode, STrans *pTrans, SMqConsumerObj *pConsumer,
-                                      SMqConsumerTopic *pConsumerTopic, SMqTopicObj *pTopic) {
+                                      SMqConsumerTopic *pConsumerTopic, SMqTopicObj *pTopic, SMqConsumerEp *pCEp) {
   int32_t sz = taosArrayGetSize(pConsumerTopic->pVgInfo);
   for (int32_t i = 0; i < sz; i++) {
     int32_t      vgId = *(int32_t *)taosArrayGet(pConsumerTopic->pVgInfo, i);
@@ -178,27 +254,35 @@ static int mndBuildMqSetConsumerVgReq(SMnode *pMnode, STrans *pTrans, SMqConsume
     };
     strcpy(req.cgroup, pConsumer->cgroup);
     strcpy(req.topicName, pTopic->name);
-    strcpy(req.sql, pTopic->sql);
-    strcpy(req.logicalPlan, pTopic->logicalPlan);
-    strcpy(req.physicalPlan, pTopic->physicalPlan);
+    req.sql = pTopic->sql;
+    req.logicalPlan = pTopic->logicalPlan;
+    req.physicalPlan = pTopic->physicalPlan;
+    req.qmsg = strdup(pCEp->qmsg);
+    req.qmsgLen = strlen(req.qmsg);
     int32_t tlen = tEncodeSMqSetCVgReq(NULL, &req);
-    void   *reqStr = malloc(tlen);
-    if (reqStr == NULL) {
+    void   *buf = malloc(sizeof(SMsgHead) + tlen);
+    if (buf == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
     }
-    void *abuf = reqStr;
+
+    SMsgHead *pMsgHead = (SMsgHead *)buf;
+
+    pMsgHead->contLen = htonl(sizeof(SMsgHead) + tlen);
+    pMsgHead->vgId = htonl(vgId);
+
+    void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
     tEncodeSMqSetCVgReq(&abuf, &req);
 
     STransAction action = {0};
     action.epSet = mndGetVgroupEpset(pMnode, pVgObj);
-    action.pCont = reqStr;
-    action.contLen = tlen;
+    action.pCont = buf;
+    action.contLen = sizeof(SMsgHead) + tlen;
     action.msgType = TDMT_VND_MQ_SET_CONN;
 
     mndReleaseVgroup(pMnode, pVgObj);
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(reqStr);
+      free(buf);
       return -1;
     }
   }
@@ -208,19 +292,18 @@ static int mndBuildMqSetConsumerVgReq(SMnode *pMnode, STrans *pTrans, SMqConsume
 void mndCleanupSubscribe(SMnode *pMnode) {}
 
 static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *pSub) {
+  terrno = TSDB_CODE_OUT_OF_MEMORY;
   int32_t tlen = tEncodeSubscribeObj(NULL, pSub);
-  int32_t size = tlen + MND_SUBSCRIBE_RESERVE_SIZE;
+  int32_t size = sizeof(int32_t) + tlen + MND_SUBSCRIBE_RESERVE_SIZE;
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_SUBSCRIBE, MND_SUBSCRIBE_VER_NUMBER, size);
   if (pRaw == NULL) goto SUB_ENCODE_OVER;
 
   void *buf = malloc(tlen);
-  if (buf == NULL) {
-    goto SUB_ENCODE_OVER;
-  }
-  void *abuf = buf;
+  if (buf == NULL) goto SUB_ENCODE_OVER;
 
-  tEncodeSubscribeObj(&buf, pSub);
+  void *abuf = buf;
+  tEncodeSubscribeObj(&abuf, pSub);
 
   int32_t dataPos = 0;
   SDB_SET_INT32(pRaw, dataPos, tlen, SUB_ENCODE_OVER);
@@ -228,6 +311,8 @@ static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *pSub) {
   SDB_SET_RESERVE(pRaw, dataPos, MND_SUBSCRIBE_RESERVE_SIZE, SUB_ENCODE_OVER);
   SDB_SET_DATALEN(pRaw, dataPos, SUB_ENCODE_OVER);
 
+  terrno = TSDB_CODE_SUCCESS;
+
 SUB_ENCODE_OVER:
   if (terrno != 0) {
     mError("subscribe:%s, failed to encode to raw:%p since %s", pSub->key, pRaw, terrstr());
@@ -259,9 +344,9 @@ static SSdbRow *mndSubActionDecode(SSdbRaw *pRaw) {
 
   int32_t dataPos = 0;
   int32_t tlen;
-  void   *buf = malloc(tlen + 1);
-  if (buf == NULL) goto SUB_DECODE_OVER;
   SDB_GET_INT32(pRaw, dataPos, &tlen, SUB_DECODE_OVER);
+  void *buf = malloc(tlen + 1);
+  if (buf == NULL) goto SUB_DECODE_OVER;
   SDB_GET_BINARY(pRaw, dataPos, buf, tlen, SUB_DECODE_OVER);
   SDB_GET_RESERVE(pRaw, dataPos, MND_SUBSCRIBE_RESERVE_SIZE, SUB_DECODE_OVER);
 
@@ -269,8 +354,10 @@ static SSdbRow *mndSubActionDecode(SSdbRaw *pRaw) {
     goto SUB_DECODE_OVER;
   }
 
+  terrno = TSDB_CODE_SUCCESS;
+
 SUB_DECODE_OVER:
-  if (terrno != 0) {
+  if (terrno != TSDB_CODE_SUCCESS) {
     mError("subscribe:%s, failed to decode from raw:%p since %s", pSub->key, pRaw, terrstr());
     // TODO free subscribeobj
     tfree(pRow);
@@ -379,10 +466,10 @@ static int32_t mndProcessSubscribeReq(SMnodeMsg *pMsg) {
       oldTopicName = ((SMqConsumerTopic *)taosArrayGet(oldSub, j))->name;
       j++;
     } else if (j >= oldTopicNum) {
-      newTopicName = taosArrayGet(newSub, i);
+      newTopicName = taosArrayGetP(newSub, i);
       i++;
     } else {
-      newTopicName = taosArrayGet(newSub, i);
+      newTopicName = taosArrayGetP(newSub, i);
       oldTopicName = ((SMqConsumerTopic *)taosArrayGet(oldSub, j))->name;
 
       int comp = compareLenPrefixedStr(newTopicName, oldTopicName);
@@ -466,9 +553,11 @@ static int32_t mndProcessSubscribeReq(SMnodeMsg *pMsg) {
           terrno = TSDB_CODE_OUT_OF_MEMORY;
           return -1;
         }
+        char *key = mndMakeSubscribeKey(consumerGroup, newTopicName);
+        strcpy(pSub->key, key);
         // set unassigned vg
         mndInitUnassignedVg(pMnode, pTopic, pSub->unassignedVg);
-        //TODO: disable alter
+        // TODO: disable alter
       }
       taosArrayPush(pSub->availConsumer, &consumerId);
 
@@ -477,16 +566,19 @@ static int32_t mndProcessSubscribeReq(SMnodeMsg *pMsg) {
 
       if (taosArrayGetSize(pConsumerTopic->pVgInfo) > 0) {
         ASSERT(taosArrayGetSize(pConsumerTopic->pVgInfo) == 1);
-        int32_t vgId = *(int32_t *)taosArrayGetLast(pConsumerTopic->pVgInfo);
-        // send setmsg to vnode
-        if (mndBuildMqSetConsumerVgReq(pMnode, pTrans, pConsumer, pConsumerTopic, pTopic) < 0) {
-          // TODO
-          return -1;
+        int32_t        vgId = *(int32_t *)taosArrayGetLast(pConsumerTopic->pVgInfo);
+        SMqConsumerEp *pCEp = taosArrayGetLast(pSub->assigned);
+        if (pCEp->vgId == vgId) {
+          if (mndBuildMqSetConsumerVgReq(pMnode, pTrans, pConsumer, pConsumerTopic, pTopic, pCEp) < 0) {
+            // TODO
+            return -1;
+          }
         }
+        // send setmsg to vnode
       }
 
       SSdbRaw *pRaw = mndSubActionEncode(pSub);
-      /*sdbSetRawStatus(pRaw, SDB_STATUS_READY);*/
+      sdbSetRawStatus(pRaw, SDB_STATUS_READY);
       mndTransAppendRedolog(pTrans, pRaw);
 #if 0
       SMqCGroup *pGroup = taosHashGet(pTopic->cgroups, consumerGroup, cgroupLen);
@@ -519,8 +611,8 @@ static int32_t mndProcessSubscribeReq(SMnodeMsg *pMsg) {
       mndTransAppendRedolog(pTrans, pTopicRaw);
 
 #endif
-      mndReleaseTopic(pMnode, pTopic);
-      mndReleaseSubscribe(pMnode, pSub);
+      /*mndReleaseTopic(pMnode, pTopic);*/
+      /*mndReleaseSubscribe(pMnode, pSub);*/
     }
   }
   // part3. persist consumerObj

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

@@ -60,7 +60,9 @@ void mndCleanupTopic(SMnode *pMnode) {}
 SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
-  int32_t  size = sizeof(SMqTopicObj) + MND_TOPIC_RESERVE_SIZE;
+  int32_t logicalPlanLen = strlen(pTopic->logicalPlan) + 1;
+  int32_t physicalPlanLen = strlen(pTopic->physicalPlan) + 1;
+  int32_t  size = sizeof(SMqTopicObj) + logicalPlanLen + physicalPlanLen + pTopic->sqlLen + MND_TOPIC_RESERVE_SIZE;
   SSdbRaw *pRaw = sdbAllocRaw(SDB_TOPIC, MND_TOPIC_VER_NUMBER, size);
   if (pRaw == NULL) goto TOPIC_ENCODE_OVER;
 
@@ -74,12 +76,10 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
   SDB_SET_INT32(pRaw, dataPos, pTopic->version, TOPIC_ENCODE_OVER);
   SDB_SET_INT32(pRaw, dataPos, pTopic->sqlLen, TOPIC_ENCODE_OVER);
   SDB_SET_BINARY(pRaw, dataPos, pTopic->sql, pTopic->sqlLen, TOPIC_ENCODE_OVER);
-  int32_t logicalPlanLen = strlen(pTopic->logicalPlan) + 1;
-  SDB_SET_INT32(pRaw, dataPos, strlen(pTopic->logicalPlan)+1, TOPIC_ENCODE_OVER);
+  SDB_SET_INT32(pRaw, dataPos, logicalPlanLen, TOPIC_ENCODE_OVER);
   SDB_SET_BINARY(pRaw, dataPos, pTopic->logicalPlan, logicalPlanLen, TOPIC_ENCODE_OVER);
 
-  int32_t physicalPlanLen = strlen(pTopic->physicalPlan) + 1;
-  SDB_SET_INT32(pRaw, dataPos, strlen(pTopic->physicalPlan)+1, TOPIC_ENCODE_OVER);
+  SDB_SET_INT32(pRaw, dataPos, physicalPlanLen, TOPIC_ENCODE_OVER);
   SDB_SET_BINARY(pRaw, dataPos, pTopic->physicalPlan, physicalPlanLen, TOPIC_ENCODE_OVER);
 
   SDB_SET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_ENCODE_OVER);
@@ -135,7 +135,7 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto TOPIC_DECODE_OVER;
   }
-  SDB_GET_BINARY(pRaw, dataPos, pTopic->logicalPlan, len+1, TOPIC_DECODE_OVER);
+  SDB_GET_BINARY(pRaw, dataPos, pTopic->logicalPlan, len, TOPIC_DECODE_OVER);
 
   SDB_GET_INT32(pRaw, dataPos, &len, TOPIC_DECODE_OVER);
   pTopic->physicalPlan = calloc(len + 1, sizeof(char));
@@ -144,7 +144,7 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto TOPIC_DECODE_OVER;
   }
-  SDB_GET_BINARY(pRaw, dataPos, pTopic->physicalPlan, len+1, TOPIC_DECODE_OVER);
+  SDB_GET_BINARY(pRaw, dataPos, pTopic->physicalPlan, len, TOPIC_DECODE_OVER);
 
   SDB_GET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_DECODE_OVER);
 
@@ -231,6 +231,7 @@ static int32_t mndCheckCreateTopicMsg(SCMCreateTopicReq *creattopReq) {
 }
 
 static int32_t mndCreateTopic(SMnode *pMnode, SMnodeMsg *pMsg, SCMCreateTopicReq *pCreate, SDbObj *pDb) {
+  mDebug("topic:%s to create", pCreate->name);
   SMqTopicObj topicObj = {0};
   tstrncpy(topicObj.name, pCreate->name, TSDB_TOPIC_FNAME_LEN);
   tstrncpy(topicObj.db, pDb->name, TSDB_DB_FNAME_LEN);
@@ -273,7 +274,7 @@ static int32_t mndProcessCreateTopicMsg(SMnodeMsg *pMsg) {
       return 0;
     } else {
       terrno = TSDB_CODE_MND_TOPIC_ALREADY_EXIST;
-      mError("db:%s, failed to create since %s", createTopicReq.name, terrstr());
+      mError("topic:%s, failed to create since already exists", createTopicReq.name);
       return -1;
     }
   }

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

@@ -390,9 +390,11 @@ static void mndTransDropActions(SArray *pArray) {
 }
 
 void mndTransDrop(STrans *pTrans) {
-  mndTransDropData(pTrans);
-  mDebug("trans:%d, is dropped, data:%p", pTrans->id, pTrans);
-  tfree(pTrans);
+  if (pTrans != NULL) {
+    mndTransDropData(pTrans);
+    mDebug("trans:%d, is dropped, data:%p", pTrans->id, pTrans);
+    tfree(pTrans);
+  }
 }
 
 static int32_t mndTransAppendLog(SArray *pArray, SSdbRaw *pRaw) {

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

+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

+/**
+ * @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(numOfFuncs);
+    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);
+    }
+  }
+
+    {
+    int32_t contLen = sizeof(SRetrieveFuncReq);
+    int32_t numOfFuncs = 2;
+    contLen = (contLen + numOfFuncs * TSDB_FUNC_NAME_LEN);
+
+    SRetrieveFuncReq* pReq = (SRetrieveFuncReq*)rpcMallocCont(contLen);
+    pReq->numOfFuncs = htonl(numOfFuncs);
+    strcpy(pReq->pFuncNames, "f2");
+    strcpy((char*)pReq->pFuncNames + TSDB_FUNC_NAME_LEN, "f3");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_RETRIEVE_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC);
+    }
+}
+
+TEST_F(MndTestFunc, 04_Drop_Func) {
+  {
+    int32_t contLen = sizeof(SDropFuncReq);
+
+    SDropFuncReq* pReq = (SDropFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "");
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_NAME);
+  }
+
+  {
+    int32_t contLen = sizeof(SDropFuncReq);
+
+    SDropFuncReq* pReq = (SDropFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f3");
+
+    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->name, "f3");
+    pReq->igNotExists = 1;
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_FUNC, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, 0);
+  }
+
+  {
+    int32_t contLen = sizeof(SDropFuncReq);
+
+    SDropFuncReq* pReq = (SDropFuncReq*)rpcMallocCont(contLen);
+    strcpy(pReq->name, "f1");
+
+    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", 7);
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 1);
+
+  // restart
+  test.Restart();
+
+  test.SendShowMetaReq(TSDB_MGMT_TABLE_FUNC, "");
+  CHECK_META("show functions", 7);
+
+  test.SendShowRetrieveReq();
+  EXPECT_EQ(test.GetShowRows(), 1);
+
+   CheckBinary("f2", TSDB_FUNC_NAME_LEN);
+}

source/dnode/vnode/inc/tq.h

@@ -318,7 +318,7 @@ int       tqRegisterContext(STqGroup*, void* ahandle);
 int       tqSendLaunchQuery(STqMsgItem*, int64_t offset);
 #endif
 
-int32_t tqProcessConsumeReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg** ppRsp);
+int32_t tqProcessConsumeReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessSetConnReq(STQ* pTq, char* msg);
 
 #ifdef __cplusplus

source/dnode/vnode/inc/tsdb.h

@@ -75,7 +75,6 @@ typedef struct STsdbQueryCond {
 } STsdbQueryCond;
 
 typedef struct {
-  void    *pTable;
   TSKEY    lastKey;
   uint64_t uid;
 } STableKeyInfo;
@@ -104,8 +103,7 @@ typedef void* tsdbReadHandleT;
  * @param qinfo      query info handle from query processor
  * @return
  */
-tsdbReadHandleT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId,
-                                  void *pRef);
+tsdbReadHandleT *tsdbQueryTables(STsdb *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfoGroup, uint64_t qId, uint64_t taskId);
 
 /**
  * Get the last row of the given query time window for all the tables in STableGroupInfo object.
@@ -142,7 +140,7 @@ bool isTsdbCacheLastRow(tsdbReadHandleT* pTsdbReadHandle);
  */
 int32_t tsdbQuerySTableByTagCond(STsdb* tsdb, uint64_t uid, TSKEY skey, const char* pTagCond, size_t len,
                                  int16_t tagNameRelType, const char* tbnameCond, STableGroupInfo* pGroupInfo,
-                                 SColIndex* pColIndex, int32_t numOfCols, uint64_t reqId);
+                                 SColIndex* pColIndex, int32_t numOfCols, uint64_t reqId, uint64_t taskId);
 /**
  * get num of rows in mem table
  *

source/dnode/vnode/inc/vnode.h

@@ -159,20 +159,18 @@ int vnodeProcessSyncReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
  *
  * @param pVnode The vnode object.
  * @param pMsg The request message
- * @param pRsp The response message
  * @return int 0 for success, -1 for failure
  */
-int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+int vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg);
 
 /**
  * @brief Process a fetch message.
  *
  * @param pVnode The vnode object.
  * @param pMsg The request message
- * @param pRsp The response message
  * @return int 0 for success, -1 for failure
  */
-int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg);
 
 /* ------------------------ SVnodeCfg ------------------------ */
 /**

source/dnode/vnode/src/meta/metaBDBImpl.c

@@ -587,7 +587,11 @@ char *metaTbCursorNext(SMTbCursor *pTbCur) {
       pBuf = value.data;
       metaDecodeTbInfo(pBuf, &tbCfg);
       if (tbCfg.type == META_SUPER_TABLE) {
+        free(tbCfg.name);
+        free(tbCfg.stbCfg.pTagSchema);
         continue;
+      } else if (tbCfg.type == META_CHILD_TABLE) {
+        kvRowFree(tbCfg.ctbCfg.pTag);
       }
       return tbCfg.name;
     } else {

source/dnode/vnode/src/tq/tq.c

@@ -81,6 +81,10 @@ STQ* tqOpen(const char* path, SWal* pWal, SMeta* pMeta, STqCfg* tqConfig, SMemAl
 }
 
 void tqClose(STQ* pTq) {
+  if (pTq) {
+    tfree(pTq->path);
+    free(pTq);
+  }
   // TODO
 }
 
@@ -663,8 +667,8 @@ int tqItemSSize() {
 }
 #endif
 
-int32_t tqProcessConsumeReq(STQ* pTq, SRpcMsg* pMsg, SRpcMsg** ppRsp) {
-  SMqConsumeReq* pReq = pMsg->pCont;
+int32_t tqProcessConsumeReq(STQ* pTq, SRpcMsg* pMsg) {
+  SMqConsumeReq*   pReq = pMsg->pCont;
   SRpcMsg          rpcMsg;
   int64_t          reqId = pReq->reqId;
   int64_t          consumerId = pReq->consumerId;
@@ -795,9 +799,9 @@ int32_t tqProcessSetConnReq(STQ* pTq, char* msg) {
     return -1;
   }
   strcpy(pTopic->topicName, req.topicName);
-  strcpy(pTopic->sql, req.sql);
-  strcpy(pTopic->logicalPlan, req.logicalPlan);
-  strcpy(pTopic->physicalPlan, req.physicalPlan);
+  pTopic->sql = strdup(req.sql);
+  pTopic->logicalPlan = strdup(req.logicalPlan);
+  pTopic->physicalPlan = strdup(req.physicalPlan);
 
   pTopic->buffer.firstOffset = -1;
   pTopic->buffer.lastOffset = -1;
@@ -807,9 +811,10 @@ int32_t tqProcessSetConnReq(STQ* pTq, char* msg) {
   for (int i = 0; i < TQ_BUFFER_SIZE; i++) {
     pTopic->buffer.output[i].status = 0;
     STqReadHandle* pReadHandle = tqInitSubmitMsgScanner(pTq->pMeta);
-    pTopic->buffer.output[i].task = qCreateStreamExecTaskInfo(&req.msg, pReadHandle);
+    pTopic->buffer.output[i].task = qCreateStreamExecTaskInfo(req.qmsg, pReadHandle);
   }
   taosArrayPush(pConsumer->topics, pTopic);
+  terrno = TSDB_CODE_SUCCESS;
   return 0;
 }
 
@@ -822,7 +827,7 @@ STqReadHandle* tqInitSubmitMsgScanner(SMeta* pMeta) {
   pReadHandle->pMsg = NULL;
   pReadHandle->ver = -1;
   pReadHandle->pColIdList = NULL;
-  return NULL;
+  return pReadHandle;
 }
 
 void tqReadHandleSetMsg(STqReadHandle* pReadHandle, SSubmitMsg* pMsg, int64_t ver) {

source/dnode/vnode/src/tsdb/tsdbFS.c

@@ -359,7 +359,7 @@ void tsdbStartFSTxn(STsdb *pRepo, int64_t pointsAdd, int64_t storageAdd) {
   tsdbResetFSStatus(pfs->nstatus);
   pfs->nstatus->meta = pfs->cstatus->meta;
   // if (pfs->cstatus->pmf == NULL) {
-  pfs->nstatus->meta.version = 0;
+  pfs->nstatus->meta.version += 1;
   // } else {
   //   pfs->nstatus->meta.version = pfs->cstatus->meta.version + 1;
   // }

source/dnode/vnode/src/vnd/vnodeArenaMAImpl.c

@@ -114,4 +114,4 @@ static void vArenaNodeFree(SVArenaNode *pNode) {
   if (pNode) {
     free(pNode);
   }
-}
\ No newline at end of file
+}

source/dnode/vnode/src/vnd/vnodeBufferPool.c

@@ -71,6 +71,7 @@ int vnodeOpenBufPool(SVnode *pVnode) {
 
 void vnodeCloseBufPool(SVnode *pVnode) {
   if (pVnode->pBufPool) {
+    tfree(pVnode->pBufPool->pMAF);
     vmaDestroy(pVnode->pBufPool->inuse);
 
     while (true) {

source/dnode/vnode/src/vnd/vnodeMgr.c

@@ -98,6 +98,8 @@ int32_t vnodePutReqToVQueryQ(SVnode* pVnode, struct SRpcMsg* pReq) {
 
 /* ------------------------ STATIC METHODS ------------------------ */
 static void* loop(void* arg) {
+  setThreadName("vnode-commit");
+
   SVnodeTask* pTask;
   for (;;) {
     pthread_mutex_lock(&(vnodeMgr.mutex));
@@ -119,6 +121,7 @@ static void* loop(void* arg) {
     pthread_mutex_unlock(&(vnodeMgr.mutex));
 
     (*(pTask->execute))(pTask->arg);
+    free(pTask);
   }
 
   return NULL;

source/dnode/vnode/src/vnd/vnodeQuery.c

@@ -17,14 +17,14 @@
 #include "vnd.h"
 
 static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg);
-static int     vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+static int     vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg);
 
 int vnodeQueryOpen(SVnode *pVnode) {
   return qWorkerInit(NODE_TYPE_VNODE, pVnode->vgId, NULL, (void **)&pVnode->pQuery, pVnode,
                      (putReqToQueryQFp)vnodePutReqToVQueryQ);
 }
 
-int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+int vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) {
   vTrace("message in query queue is processing");
 
   switch (pMsg->msgType) {
@@ -38,7 +38,7 @@ int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   }
 }
 
-int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg) {
   vTrace("message in fetch queue is processing");
   switch (pMsg->msgType) {
     case TDMT_VND_FETCH:
@@ -57,24 +57,24 @@ int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       return vnodeGetTableList(pVnode, pMsg);
       //      return qWorkerProcessShowFetchMsg(pVnode->pMeta, pVnode->pQuery, pMsg);
     case TDMT_VND_TABLE_META:
-      return vnodeGetTableMeta(pVnode, pMsg, pRsp);
+      return vnodeGetTableMeta(pVnode, pMsg);
     case TDMT_VND_CONSUME:
-      return tqProcessConsumeReq(pVnode->pTq, pMsg, pRsp);
+      return tqProcessConsumeReq(pVnode->pTq, pMsg);
     default:
       vError("unknown msg type:%d in fetch queue", pMsg->msgType);
       return TSDB_CODE_VND_APP_ERROR;
   }
 }
 
-static int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+static int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg) {
   STableInfoReq * pReq = (STableInfoReq *)(pMsg->pCont);
   STbCfg *        pTbCfg = NULL;
   STbCfg *        pStbCfg = NULL;
   tb_uid_t        uid;
   int32_t         nCols;
   int32_t         nTagCols;
-  SSchemaWrapper *pSW;
-  STableMetaRsp * pTbMetaMsg = NULL;
+  SSchemaWrapper *pSW = NULL;
+  STableMetaRsp  *pTbMetaMsg = NULL;
   SSchema *       pTagSchema;
   SRpcMsg         rpcMsg;
   int             msgLen = 0;
@@ -145,6 +145,22 @@ static int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
 
 _exit:
 
+  if (pSW != NULL) {
+    tfree(pSW->pSchema);
+    tfree(pSW);
+  }
+
+  if (pTbCfg) {
+    tfree(pTbCfg->name);
+    if (pTbCfg->type == META_SUPER_TABLE) {
+      free(pTbCfg->stbCfg.pTagSchema);
+    } else if (pTbCfg->type == META_SUPER_TABLE) {
+      kvRowFree(pTbCfg->ctbCfg.pTag);
+    }
+
+    tfree(pTbCfg);
+  }
+
   rpcMsg.handle = pMsg->handle;
   rpcMsg.ahandle = pMsg->ahandle;
   rpcMsg.pCont = pTbMetaMsg;
@@ -156,8 +172,8 @@ _exit:
   return 0;
 }
 
-static void freeItemHelper(void* pItem) {
-  char* p = *(char**)pItem;
+static void freeItemHelper(void *pItem) {
+  char *p = *(char **)pItem;
   free(p);
 }
 
@@ -187,14 +203,14 @@ static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg) {
   // TODO: temp debug, and should del when show tables command ok
   vInfo("====vgId:%d, numOfTables: %d", pVnode->vgId, numOfTables);
   if (numOfTables > 10000) {
-     numOfTables = 10000;
+    numOfTables = 10000;
   }
 
   metaCloseTbCursor(pCur);
 
   int32_t rowLen =
       (TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE) + 8 + 2 + (TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE) + 8 + 4;
-  //int32_t numOfTables = (int32_t)taosArrayGetSize(pArray);
+  // int32_t numOfTables = (int32_t)taosArrayGetSize(pArray);
 
   int32_t payloadLen = rowLen * numOfTables;
   //  SVShowTablesFetchReq *pFetchReq = pMsg->pCont;
@@ -208,6 +224,7 @@ static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg) {
     STR_TO_VARSTR(p, n);
 
     p += (TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE);
+    // free(n);
   }
 
   pFetchRsp->numOfRows = htonl(numOfTables);
@@ -222,6 +239,7 @@ static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg) {
   };
 
   rpcSendResponse(&rpcMsg);
+
   taosArrayDestroyEx(pArray, freeItemHelper);
   return 0;
 }

source/dnode/vnode/src/vnd/vnodeWrite.c

@@ -34,7 +34,7 @@ int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
     pMsg = *(SRpcMsg **)taosArrayGet(pMsgs, i);
 
     // ser request version
-    void   *pBuf = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
+    void *  pBuf = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
     int64_t ver = pVnode->state.processed++;
     taosEncodeFixedU64(&pBuf, ver);
 
@@ -53,7 +53,7 @@ int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
 int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   SVCreateTbReq      vCreateTbReq;
   SVCreateTbBatchReq vCreateTbBatchReq;
-  void              *ptr = vnodeMalloc(pVnode, pMsg->contLen);
+  void *             ptr = vnodeMalloc(pVnode, pMsg->contLen);
   if (ptr == NULL) {
     // TODO: handle error
   }
@@ -76,6 +76,9 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       }
 
       // TODO: maybe need to clear the requst struct
+      free(vCreateTbReq.stbCfg.pSchema);
+      free(vCreateTbReq.stbCfg.pTagSchema);
+      free(vCreateTbReq.name);
       break;
     case TDMT_VND_CREATE_TABLE:
       tSVCreateTbBatchReqDeserialize(POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)), &vCreateTbBatchReq);
@@ -112,7 +115,8 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       }
       break;
     case TDMT_VND_MQ_SET_CONN: {
-      if (tqProcessSetConnReq(pVnode->pTq, ptr) < 0) {
+      if (tqProcessSetConnReq(pVnode->pTq, POINTER_SHIFT(ptr, sizeof(SMsgHead))) < 0) {
+        // TODO: handle error
       }
     } break;
     default:
@@ -129,7 +133,7 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       // TODO: handle error
     }
   }
-  
+
   return 0;
 }
 

source/libs/executor/inc/executil.h

@@ -38,7 +38,7 @@
 #define GET_RES_WINDOW_KEY_LEN(_l) ((_l) + sizeof(uint64_t))
 #define GET_RES_EXT_WINDOW_KEY_LEN(_l) ((_l) + sizeof(uint64_t) + POINTER_BYTES)
 
-#define GET_TASKID(_t)  (((SExecTaskInfo*)(_t))->id.queryId)
+#define GET_TASKID(_t)  (((SExecTaskInfo*)(_t))->id.str)
 
 #define curTimeWindowIndex(_winres)        ((_winres)->curIndex)
 

source/libs/executor/inc/executorimpl.h

@@ -239,7 +239,7 @@ typedef struct STaskIdInfo {
   uint64_t       queryId;    // this is also a request id
   uint64_t       subplanId;
   uint64_t       templateId;
-  uint64_t       taskId;     // this is a subplan id
+  char          *str;
 } STaskIdInfo;
 
 typedef struct SExecTaskInfo {
@@ -250,9 +250,8 @@ typedef struct SExecTaskInfo {
   STaskCostInfo   cost;
   int64_t         owner;       // if it is in execution
   int32_t         code;
-
+  uint64_t        totalRows;   // total number of rows
   STableGroupInfo tableqinfoGroupInfo;  // this is a group array list, including SArray<STableQueryInfo*> structure
-  pthread_mutex_t lock;        // used to synchronize the rsp/query threads
   char           *sql;         // query sql string
   jmp_buf         env;         //
   struct SOperatorInfo  *pRoot;
@@ -378,8 +377,10 @@ typedef struct SExchangeInfo {
   SSDataBlock       *pResult;
   int32_t            current;
   uint64_t           rowsOfCurrentSource;
-  uint64_t           bytes;   // total load bytes from remote
-  uint64_t           totalRows;
+
+  uint64_t           totalSize;   // total load bytes from remote
+  uint64_t           totalRows;   // total number of rows
+  uint64_t           totalElapsed;// total elapsed time
 } SExchangeInfo;
 
 typedef struct STableScanInfo {
@@ -622,8 +623,6 @@ int32_t createIndirectQueryFuncExprFromMsg(SQueryTableReq *pQueryMsg, int32_t nu
 int32_t createQueryFilter(char *data, uint16_t len, SFilterInfo** pFilters);
 
 SGroupbyExpr *createGroupbyExprFromMsg(SQueryTableReq *pQueryMsg, SColIndex *pColIndex, int32_t *code);
-SQInfo *createQInfoImpl(SQueryTableReq *pQueryMsg, SGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
-                        SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, SFilterInfo* pFilters, int32_t vgId, char* sql, uint64_t qId, struct SUdfInfo* pUdfInfo);
 
 int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, STaskParam* param, char* start,
                   int32_t prevResultLen, void* merger);
@@ -639,32 +638,29 @@ int32_t buildArithmeticExprFromMsg(SExprInfo *pArithExprInfo, void *pQueryMsg);
 bool isTaskKilled(SExecTaskInfo *pTaskInfo);
 int32_t checkForQueryBuf(size_t numOfTables);
 bool checkNeedToCompressQueryCol(SQInfo *pQInfo);
-bool doBuildResCheck(SQInfo* pQInfo);
 void setQueryStatus(STaskRuntimeEnv *pRuntimeEnv, int8_t status);
 
 bool onlyQueryTags(STaskAttr* pQueryAttr);
 //void destroyUdfInfo(struct SUdfInfo* pUdfInfo);
 
-bool isValidQInfo(void *param);
-
 int32_t doDumpQueryResult(SQInfo *pQInfo, char *data, int8_t compressed, int32_t *compLen);
 
 size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows);
-void setQueryKilled(SQInfo *pQInfo);
+void setTaskKilled(SExecTaskInfo *pTaskInfo);
 
 void publishOperatorProfEvent(SOperatorInfo* operatorInfo, EQueryProfEventType eventType);
 void publishQueryAbortEvent(SExecTaskInfo * pTaskInfo, int32_t code);
 
 void calculateOperatorProfResults(SQInfo* pQInfo);
-void queryCostStatis(SQInfo *pQInfo);
+void queryCostStatis(SExecTaskInfo *pTaskInfo);
 
-void doDestroyTask(SQInfo *pQInfo);
+void doDestroyTask(SExecTaskInfo *pTaskInfo);
 void freeQueryAttr(STaskAttr *pQuery);
 
 int32_t getMaximumIdleDurationSec();
 
 void doInvokeUdf(struct SUdfInfo* pUdfInfo, SQLFunctionCtx *pCtx, int32_t idx, int32_t type);
 void setTaskStatus(SExecTaskInfo *pTaskInfo, int8_t status);
-int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, void* readerHandle);
+int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, void* readerHandle, uint64_t taskId);
 
 #endif  // TDENGINE_EXECUTORIMPL_H

source/libs/executor/src/dataDispatcher.c

@@ -121,11 +121,19 @@ static void toDataCacheEntry(const SDataDispatchHandle* pHandle, const SInputDat
 }
 
 static bool allocBuf(SDataDispatchHandle* pDispatcher, const SInputData* pInput, SDataDispatchBuf* pBuf) {
-  if (taosQueueSize(pDispatcher->pDataBlocks) >= pDispatcher->pManager->cfg.maxDataBlockNumPerQuery) {
+  uint32_t capacity = pDispatcher->pManager->cfg.maxDataBlockNumPerQuery;
+  if (taosQueueSize(pDispatcher->pDataBlocks) > capacity) {
+    qError("SinkNode queue is full, no capacity, max:%d, current:%d, no capacity", capacity,
+           taosQueueSize(pDispatcher->pDataBlocks));
     return false;
   }
+
   pBuf->allocSize = DATA_META_LENGTH(pInput->pTableRetrieveTsMap) + pDispatcher->schema.resultRowSize * pInput->pData->info.rows;
   pBuf->pData = malloc(pBuf->allocSize);
+  if (pBuf->pData == NULL) {
+    qError("SinkNode failed to malloc memory, size:%d, code:%d", pBuf->allocSize, TAOS_SYSTEM_ERROR(errno));
+  }
+
   return NULL != pBuf->pData;
 }
 

source/libs/executor/test/executorTests.cpp

@@ -219,7 +219,7 @@ TEST(testCase, build_executor_tree_Test) {
 
   SExecTaskInfo* pTaskInfo = nullptr;
   DataSinkHandle sinkHandle = nullptr;
-  int32_t code = qCreateExecTask((void*) 1, 2, NULL, (void**) &pTaskInfo, &sinkHandle);
+  int32_t code = qCreateExecTask((void*) 1, 2, 1, NULL, (void**) &pTaskInfo, &sinkHandle);
 }
 
 #pragma GCC diagnostic pop
\ No newline at end of file