merge 3.0

example/src/tstream.c

@@ -25,7 +25,7 @@ int32_t init_env() {
     return -1;
   }
 
-  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 1");
+  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 2");
   if (taos_errno(pRes) != 0) {
     printf("error in create db, reason:%s\n", taos_errstr(pRes));
     return -1;

include/common/tcommon.h

@@ -54,13 +54,16 @@ typedef struct SColumnDataAgg {
 } SColumnDataAgg;
 
 typedef struct SDataBlockInfo {
-  STimeWindow    window;
-  int32_t        rows;
-  int32_t        rowSize;
-  int16_t        numOfCols;
-  int16_t        hasVarCol;
-  union {int64_t uid; int64_t blockId;};
-  int64_t        groupId;     // no need to serialize
+  STimeWindow window;
+  int32_t     rows;
+  int32_t     rowSize;
+  int16_t     numOfCols;
+  int16_t     hasVarCol;
+  union {
+    int64_t uid;
+    int64_t blockId;
+  };
+  int64_t groupId;  // no need to serialize
 } SDataBlockInfo;
 
 typedef struct SSDataBlock {
@@ -92,7 +95,7 @@ int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock);
 void*   tDecodeDataBlock(const void* buf, SSDataBlock* pBlock);
 
 int32_t tEncodeDataBlocks(void** buf, const SArray* blocks);
-void*   tDecodeDataBlocks(const void* buf, SArray* blocks);
+void*   tDecodeDataBlocks(const void* buf, SArray** blocks);
 
 static FORCE_INLINE void blockDestroyInner(SSDataBlock* pBlock) {
   // WARNING: do not use info.numOfCols,
@@ -101,16 +104,16 @@ static FORCE_INLINE void blockDestroyInner(SSDataBlock* pBlock) {
   for (int32_t i = 0; i < numOfOutput; ++i) {
     SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
     if (IS_VAR_DATA_TYPE(pColInfoData->info.type)) {
-      tfree(pColInfoData->varmeta.offset);
+      taosMemoryFreeClear(pColInfoData->varmeta.offset);
     } else {
-      tfree(pColInfoData->nullbitmap);
+      taosMemoryFreeClear(pColInfoData->nullbitmap);
     }
 
-    tfree(pColInfoData->pData);
+    taosMemoryFreeClear(pColInfoData->pData);
   }
 
   taosArrayDestroy(pBlock->pDataBlock);
-  tfree(pBlock->pBlockAgg);
+  taosMemoryFreeClear(pBlock->pBlockAgg);
 }
 
 static FORCE_INLINE void tDeleteSSDataBlock(SSDataBlock* pBlock) { blockDestroyInner(pBlock); }
@@ -144,7 +147,7 @@ static FORCE_INLINE void* tDecodeSMqPollRsp(void* buf, SMqPollRsp* pRsp) {
   buf = taosDecodeFixedI32(buf, &pRsp->skipLogNum);
   buf = taosDecodeFixedI32(buf, &pRsp->numOfTopics);
   if (pRsp->numOfTopics == 0) return buf;
-  pRsp->schema = (SSchemaWrapper*)calloc(1, sizeof(SSchemaWrapper));
+  pRsp->schema = (SSchemaWrapper*)taosMemoryCalloc(1, sizeof(SSchemaWrapper));
   if (pRsp->schema == NULL) return NULL;
   buf = tDecodeSSchemaWrapper(buf, pRsp->schema);
   buf = taosDecodeFixedI32(buf, &sz);
@@ -160,9 +163,9 @@ static FORCE_INLINE void* tDecodeSMqPollRsp(void* buf, SMqPollRsp* pRsp) {
 static FORCE_INLINE void tDeleteSMqConsumeRsp(SMqPollRsp* pRsp) {
   if (pRsp->schema) {
     if (pRsp->schema->nCols) {
-      tfree(pRsp->schema->pSchema);
+      taosMemoryFreeClear(pRsp->schema->pSchema);
     }
-    free(pRsp->schema);
+    taosMemoryFree(pRsp->schema);
   }
   taosArrayDestroyEx(pRsp->pBlockData, (void (*)(void*))blockDestroyInner);
   pRsp->pBlockData = NULL;

include/common/tdatablock.h

@@ -102,7 +102,8 @@ static FORCE_INLINE bool colDataIsNull(const SColumnInfoData* pColumnInfoData, u
                                         : ((p1_)->pData + ((r_) * (p1_)->info.bytes)))
 
 int32_t colDataAppend(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, bool isNull);
-int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, const SColumnInfoData* pSource, uint32_t numOfRow2);
+int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, const SColumnInfoData* pSource,
+                        uint32_t numOfRow2);
 int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows);
 int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock);
 
@@ -113,7 +114,8 @@ size_t blockDataGetNumOfCols(const SSDataBlock* pBlock);
 size_t blockDataGetNumOfRows(const SSDataBlock* pBlock);
 
 int32_t blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc);
-int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex, int32_t pageSize);
+int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex,
+                           int32_t pageSize);
 int32_t blockDataToBuf(char* buf, const SSDataBlock* pBlock);
 int32_t blockDataFromBuf(SSDataBlock* pBlock, const char* buf);
 
@@ -136,6 +138,8 @@ SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock);
 size_t       blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize);
 void*        blockDataDestroy(SSDataBlock* pBlock);
 
+void blockDebugShowData(const SArray* dataBlocks);
+
 #ifdef __cplusplus
 }
 #endif

include/common/tdataformat.h

@@ -93,7 +93,7 @@ typedef struct {
 #define schemaFLen(s)     ((s)->flen)
 #define schemaVLen(s)     ((s)->vlen)
 #define schemaColAt(s, i) ((s)->columns + i)
-#define tdFreeSchema(s)   tfree((s))
+#define tdFreeSchema(s)   taosMemoryFreeClear((s))
 
 STSchema *tdDupSchema(const STSchema *pSchema);
 int32_t   tdEncodeSchema(void **buf, STSchema *pSchema);
@@ -493,7 +493,7 @@ typedef struct {
 #define kvRowCpy(dst, r)       memcpy((dst), (r), kvRowLen(r))
 #define kvRowColVal(r, colIdx) POINTER_SHIFT(kvRowValues(r), (colIdx)->offset)
 #define kvRowColIdxAt(r, i)    (kvRowColIdx(r) + (i))
-#define kvRowFree(r)           tfree(r)
+#define kvRowFree(r)           taosMemoryFreeClear(r)
 #define kvRowEnd(r)            POINTER_SHIFT(r, kvRowLen(r))
 #define kvRowValLen(r)         (kvRowLen(r) - TD_KV_ROW_HEAD_SIZE - sizeof(SColIdx) * kvRowNCols(r))
 #define kvRowTKey(r)           (*(TKEY *)(kvRowValues(r)))
@@ -593,7 +593,7 @@ SKVRow  tdGetKVRowFromBuilder(SKVRowBuilder *pBuilder);
 static FORCE_INLINE int32_t tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId, int8_t type, const void *value) {
   if (pBuilder->nCols >= pBuilder->tCols) {
     pBuilder->tCols *= 2;
-    SColIdx *pColIdx = (SColIdx *)realloc((void *)(pBuilder->pColIdx), sizeof(SColIdx) * pBuilder->tCols);
+    SColIdx *pColIdx = (SColIdx *)taosMemoryRealloc((void *)(pBuilder->pColIdx), sizeof(SColIdx) * pBuilder->tCols);
     if (pColIdx == NULL) return -1;
     pBuilder->pColIdx = pColIdx;
   }
@@ -608,7 +608,7 @@ static FORCE_INLINE int32_t tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t col
     while (tlen > pBuilder->alloc - pBuilder->size) {
       pBuilder->alloc *= 2;
     }
-    void *buf = realloc(pBuilder->buf, pBuilder->alloc);
+    void *buf = taosMemoryRealloc(pBuilder->buf, pBuilder->alloc);
     if (buf == NULL) return -1;
     pBuilder->buf = buf;
   }

include/common/tmsg.h

@@ -201,21 +201,13 @@ typedef struct SEp {
 
 typedef struct {
   int32_t contLen;
-  union {
-    int32_t vgId;
-    int32_t streamTaskId;
-  };
+  int32_t vgId;
 } SMsgHead;
 
-typedef struct {
-  int32_t workerType;
-  int32_t streamTaskId;
-} SStreamExecMsgHead;
-
 // Submit message for one table
 typedef struct SSubmitBlk {
   int64_t uid;        // table unique id
-  int64_t suid;        // stable id
+  int64_t suid;       // stable id
   int32_t padding;    // TODO just for padding here
   int32_t sversion;   // data schema version
   int32_t dataLen;    // data part length, not including the SSubmitBlk head
@@ -477,7 +469,8 @@ typedef struct {
   int32_t tz;  // query client timezone
   char    intervalUnit;
   char    slidingUnit;
-  char    offsetUnit;   // TODO Remove it, the offset is the number of precision tickle, and it must be a immutable duration.
+  char
+      offsetUnit;  // TODO Remove it, the offset is the number of precision tickle, and it must be a immutable duration.
   int8_t  precision;
   int64_t interval;
   int64_t sliding;
@@ -1132,7 +1125,6 @@ int32_t tDeserializeSSchedulerHbReq(void* buf, int32_t bufLen, SSchedulerHbReq*
 void    tFreeSSchedulerHbReq(SSchedulerHbReq* pReq);
 
 typedef struct {
-  uint64_t       seqId;
   SQueryNodeEpId epId;
   SArray*        taskStatus;  // SArray<STaskStatus>
 } SSchedulerHbRsp;
@@ -1316,7 +1308,7 @@ typedef struct {
 } SMqRebSubscribe;
 
 static FORCE_INLINE SMqRebSubscribe* tNewSMqRebSubscribe(const char* key) {
-  SMqRebSubscribe* pRebSub = (SMqRebSubscribe*)calloc(1, sizeof(SMqRebSubscribe));
+  SMqRebSubscribe* pRebSub = (SMqRebSubscribe*)taosMemoryCalloc(1, sizeof(SMqRebSubscribe));
   if (pRebSub == NULL) {
     goto _err;
   }
@@ -1338,7 +1330,7 @@ _err:
   taosArrayDestroy(pRebSub->lostConsumers);
   taosArrayDestroy(pRebSub->removedConsumers);
   taosArrayDestroy(pRebSub->newConsumers);
-  tfree(pRebSub);
+  taosMemoryFreeClear(pRebSub);
   return NULL;
 }
 
@@ -1639,7 +1631,7 @@ static FORCE_INLINE void tFreeReqKvHash(SHashObj* info) {
   void* pIter = taosHashIterate(info, NULL);
   while (pIter != NULL) {
     SKv* kv = (SKv*)pIter;
-    tfree(kv->value);
+    taosMemoryFreeClear(kv->value);
     pIter = taosHashIterate(info, pIter);
   }
 }
@@ -1662,13 +1654,13 @@ static FORCE_INLINE void tFreeClientHbBatchReq(void* pReq, bool deep) {
   } else {
     taosArrayDestroy(req->reqs);
   }
-  free(pReq);
+  taosMemoryFree(pReq);
 }
 
 static FORCE_INLINE void tFreeClientKv(void* pKv) {
   SKv* kv = (SKv*)pKv;
   if (kv) {
-    tfree(kv->value);
+    taosMemoryFreeClear(kv->value);
   }
 }
 
@@ -1695,7 +1687,7 @@ static FORCE_INLINE int32_t tEncodeSKv(SCoder* pEncoder, const SKv* pKv) {
 static FORCE_INLINE int32_t tDecodeSKv(SCoder* pDecoder, SKv* pKv) {
   if (tDecodeI32(pDecoder, &pKv->key) < 0) return -1;
   if (tDecodeI32(pDecoder, &pKv->valueLen) < 0) return -1;
-  pKv->value = malloc(pKv->valueLen + 1);
+  pKv->value = taosMemoryMalloc(pKv->valueLen + 1);
   if (pKv->value == NULL) return -1;
   if (tDecodeCStrTo(pDecoder, (char*)pKv->value) < 0) return -1;
   return 0;
@@ -1949,7 +1941,7 @@ static FORCE_INLINE int32_t tEncodeSSchemaWrapper(void** buf, const SSchemaWrapp
 
 static FORCE_INLINE void* tDecodeSSchemaWrapper(void* buf, SSchemaWrapper* pSW) {
   buf = taosDecodeFixedU32(buf, &pSW->nCols);
-  pSW->pSchema = (SSchema*)calloc(pSW->nCols, sizeof(SSchema));
+  pSW->pSchema = (SSchema*)taosMemoryCalloc(pSW->nCols, sizeof(SSchema));
   if (pSW->pSchema == NULL) {
     return NULL;
   }
@@ -2084,8 +2076,8 @@ typedef struct {
 
 static FORCE_INLINE void tdDestroyTSma(STSma* pSma) {
   if (pSma) {
-    tfree(pSma->expr);
-    tfree(pSma->tagsFilter);
+    taosMemoryFreeClear(pSma->expr);
+    taosMemoryFreeClear(pSma->tagsFilter);
   }
 }
 
@@ -2095,14 +2087,14 @@ static FORCE_INLINE void tdDestroyTSmaWrapper(STSmaWrapper* pSW) {
       for (uint32_t i = 0; i < pSW->number; ++i) {
         tdDestroyTSma(pSW->tSma + i);
       }
-      tfree(pSW->tSma);
+      taosMemoryFreeClear(pSW->tSma);
     }
   }
 }
 
 static FORCE_INLINE void tdFreeTSmaWrapper(STSmaWrapper* pSW) {
   tdDestroyTSmaWrapper(pSW);
-  tfree(pSW);
+  taosMemoryFreeClear(pSW);
 }
 
 static FORCE_INLINE int32_t tEncodeTSma(void** buf, const STSma* pSma) {
@@ -2180,7 +2172,7 @@ static FORCE_INLINE void* tDecodeTSma(void* buf, STSma* pSma) {
 static FORCE_INLINE void* tDecodeTSmaWrapper(void* buf, STSmaWrapper* pSW) {
   buf = taosDecodeFixedU32(buf, &pSW->number);
 
-  pSW->tSma = (STSma*)calloc(pSW->number, sizeof(STSma));
+  pSW->tSma = (STSma*)taosMemoryCalloc(pSW->number, sizeof(STSma));
   if (pSW->tSma == NULL) {
     return NULL;
   }
@@ -2190,7 +2182,7 @@ static FORCE_INLINE void* tDecodeTSmaWrapper(void* buf, STSmaWrapper* pSW) {
       for (uint32_t j = i; j >= 0; --i) {
         tdDestroyTSma(pSW->tSma + j);
       }
-      free(pSW->tSma);
+      taosMemoryFree(pSW->tSma);
       return NULL;
     }
   }
@@ -2365,108 +2357,6 @@ static FORCE_INLINE void* tDecodeSMqCMGetSubEpRsp(void* buf, SMqCMGetSubEpRsp* p
   }
   return buf;
 }
-
-enum {
-  STREAM_TASK_STATUS__RUNNING = 1,
-  STREAM_TASK_STATUS__STOP,
-};
-
-enum {
-  STREAM_NEXT_OP_DST__VND = 1,
-  STREAM_NEXT_OP_DST__SND,
-};
-
-enum {
-  STREAM_SOURCE_TYPE__NONE = 1,
-  STREAM_SOURCE_TYPE__SUPER,
-  STREAM_SOURCE_TYPE__CHILD,
-  STREAM_SOURCE_TYPE__NORMAL,
-};
-
-enum {
-  STREAM_SINK_TYPE__NONE = 1,
-  STREAM_SINK_TYPE__INPLACE,
-  STREAM_SINK_TYPE__ASSIGNED,
-  STREAM_SINK_TYPE__MULTIPLE,
-  STREAM_SINK_TYPE__TEMPORARY,
-};
-
-enum {
-  STREAM_TYPE__NORMAL = 1,
-  STREAM_TYPE__SMA,
-};
-
-typedef struct {
-  void* inputHandle;
-  void* executor;
-} SStreamRunner;
-
-typedef struct {
-  int64_t streamId;
-  int32_t taskId;
-  int32_t level;
-  int8_t  status;
-  int8_t  parallelizable;
-
-  // vnode or snode
-  int8_t nextOpDst;
-
-  int8_t sourceType;
-  int8_t sinkType;
-
-  // for sink type assigned
-  int32_t sinkVgId;
-  SEpSet  NextOpEp;
-
-  // executor meta info
-  char* qmsg;
-
-  // followings are not applied to encoder and decoder
-  int8_t        numOfRunners;
-  SStreamRunner runner[8];
-} SStreamTask;
-
-static FORCE_INLINE SStreamTask* streamTaskNew(int64_t streamId) {
-  SStreamTask* pTask = (SStreamTask*)calloc(1, sizeof(SStreamTask));
-  if (pTask == NULL) {
-    return NULL;
-  }
-  pTask->taskId = tGenIdPI32();
-  pTask->streamId = streamId;
-  pTask->status = STREAM_TASK_STATUS__RUNNING;
-  pTask->qmsg = NULL;
-  return pTask;
-}
-
-int32_t tEncodeSStreamTask(SCoder* pEncoder, const SStreamTask* pTask);
-int32_t tDecodeSStreamTask(SCoder* pDecoder, SStreamTask* pTask);
-void    tFreeSStreamTask(SStreamTask* pTask);
-
-typedef struct {
-  SMsgHead     head;
-  SStreamTask* task;
-} SStreamTaskDeployReq;
-
-typedef struct {
-  int32_t reserved;
-} SStreamTaskDeployRsp;
-
-typedef struct {
-  SStreamExecMsgHead head;
-  SArray*            data;  // SArray<SSDataBlock>
-} SStreamTaskExecReq;
-
-typedef struct {
-  int32_t reserved;
-} SStreamTaskExecRsp;
-
-typedef struct {
-  SMsgHead head;
-  int64_t  streamId;
-  int64_t  version;
-  SArray*  res;  // SArray<SSDataBlock>
-} SStreamSinkReq;
-
 #pragma pack(pop)
 
 #ifdef __cplusplus

include/common/tmsgcb.h

@@ -25,7 +25,16 @@ extern "C" {
 typedef struct SRpcMsg      SRpcMsg;
 typedef struct SEpSet       SEpSet;
 typedef struct SMgmtWrapper SMgmtWrapper;
-typedef enum { QUERY_QUEUE, FETCH_QUEUE, WRITE_QUEUE, APPLY_QUEUE, SYNC_QUEUE, QUEUE_MAX } EQueueType;
+typedef enum {
+  QUERY_QUEUE,
+  FETCH_QUEUE,
+  READ_QUEUE,
+  WRITE_QUEUE,
+  APPLY_QUEUE,
+  SYNC_QUEUE,
+  MERGE_QUEUE,
+  QUEUE_MAX,
+} EQueueType;
 
 typedef int32_t (*PutToQueueFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq);
 typedef int32_t (*GetQueueSizeFp)(SMgmtWrapper* pWrapper, int32_t vgId, EQueueType qtype);

include/common/tmsgdef.h

@@ -193,6 +193,9 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_CONSUME, "vnode-consume", SMqCVConsumeReq, SMqCVConsumeRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_TASK_DEPLOY, "vnode-task-deploy", SStreamTaskDeployReq, SStreamTaskDeployRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_TASK_EXEC, "vnode-task-exec", SStreamTaskExecReq, SStreamTaskExecRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_TASK_PIPE_EXEC, "vnode-task-pipe-exec", SStreamTaskExecReq, SStreamTaskExecRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_TASK_MERGE_EXEC, "vnode-task-merge-exec", SStreamTaskExecReq, SStreamTaskExecRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_TASK_WRITE_EXEC, "vnode-task-write-exec", SStreamTaskExecReq, SStreamTaskExecRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_STREAM_TRIGGER, "vnode-stream-trigger", NULL, NULL)
 
   TD_DEF_MSG_TYPE(TDMT_VND_CREATE_SMA, "vnode-create-sma", NULL, NULL)
@@ -206,7 +209,13 @@ enum {
   TD_NEW_MSG_SEG(TDMT_SND_MSG)
   TD_DEF_MSG_TYPE(TDMT_SND_TASK_DEPLOY, "snode-task-deploy", SStreamTaskDeployReq, SStreamTaskDeployRsp)
   TD_DEF_MSG_TYPE(TDMT_SND_TASK_EXEC, "snode-task-exec", SStreamTaskExecReq, SStreamTaskExecRsp)
+  TD_DEF_MSG_TYPE(TDMT_SND_TASK_PIPE_EXEC, "snode-task-pipe-exec", SStreamTaskExecReq, SStreamTaskExecRsp)
+  TD_DEF_MSG_TYPE(TDMT_SND_TASK_MERGE_EXEC, "snode-task-merge-exec", SStreamTaskExecReq, SStreamTaskExecRsp)
 
+  // Requests handled by SCHEDULER
+  TD_NEW_MSG_SEG(TDMT_SCH_MSG)
+  TD_DEF_MSG_TYPE(TDMT_SCH_LINK_BROKEN, "scheduler-link-broken", NULL, NULL)
+  
 #if defined(TD_MSG_NUMBER_)
   TDMT_MAX
 #endif

include/libs/catalog/catalog.h

@@ -112,7 +112,7 @@ int32_t catalogUpdateDBVgInfo(SCatalog* pCatalog, const char* dbName, uint64_t d
 
 int32_t catalogRemoveDB(SCatalog* pCatalog, const char* dbName, uint64_t dbId);
 
-int32_t catalogRemoveTableMeta(SCatalog* pCtg, SName* pTableName);
+int32_t catalogRemoveTableMeta(SCatalog* pCtg, const SName* pTableName);
 
 int32_t catalogRemoveStbMeta(SCatalog* pCtg, const char* dbFName, uint64_t dbId, const char* stbName, uint64_t suid);
 

include/libs/function/functionMgt.h

@@ -57,18 +57,19 @@ typedef enum EFunctionType {
 
   // math function
   FUNCTION_TYPE_ABS = 1000,
-  FUNCTION_TYPE_ACOS,
-  FUNCTION_TYPE_ASION,
-  FUNCTION_TYPE_ATAN,
-  FUNCTION_TYPE_CEIL,
-  FUNCTION_TYPE_COS,
-  FUNCTION_TYPE_FLOOR,
   FUNCTION_TYPE_LOG,
   FUNCTION_TYPE_POW,
+  FUNCTION_TYPE_SQRT,
+  FUNCTION_TYPE_CEIL,
+  FUNCTION_TYPE_FLOOR,
   FUNCTION_TYPE_ROUND,
+
   FUNCTION_TYPE_SIN,
-  FUNCTION_TYPE_SQRT,
+  FUNCTION_TYPE_COS,
   FUNCTION_TYPE_TAN,
+  FUNCTION_TYPE_ASIN,
+  FUNCTION_TYPE_ACOS,
+  FUNCTION_TYPE_ATAN,
 
   // string function
   FUNCTION_TYPE_CHAR_LENGTH = 1500,

include/libs/nodes/plannodes.h

@@ -48,6 +48,7 @@ typedef struct SScanLogicNode {
   uint8_t scanFlag;         // denotes reversed scan of data or not
   STimeWindow scanRange;
   SName tableName;
+  bool showRewrite;
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
@@ -178,6 +179,8 @@ typedef SScanPhysiNode SStreamScanPhysiNode;
 typedef struct SSystemTableScanPhysiNode {
   SScanPhysiNode scan;
   SEpSet mgmtEpSet;
+  bool showRewrite;
+  int32_t accountId;
 } SSystemTableScanPhysiNode;
 
 typedef struct STableScanPhysiNode {

include/libs/parser/parser.h

@@ -54,6 +54,7 @@ typedef struct SQuery {
   int32_t msgType;
   SArray* pDbList;
   SArray* pTableList;
+  bool showRewrite;
 } SQuery;
 
 int32_t qParseQuerySql(SParseContext* pCxt, SQuery** pQuery);

include/libs/planner/planner.h

@@ -29,6 +29,7 @@ typedef struct SPlanContext {
   SNode* pAstRoot;
   bool topicQuery;
   bool streamQuery;
+  bool showRewrite;
 } SPlanContext;
 
 // Create the physical plan for the query, according to the AST.

include/libs/qcom/query.h

@@ -150,6 +150,8 @@ int32_t cleanupTaskQueue();
  */
 int32_t taosAsyncExec(__async_exec_fn_t execFn, void* execParam, int32_t* code);
 
+int32_t asyncSendMsgToServerExt(void* pTransporter, SEpSet* epSet, int64_t* pTransporterId, const SMsgSendInfo* pInfo, bool persistHandle, void *ctx);
+
 /**
  * Asynchronously send message to server, after the response received, the callback will be incured.
  *

include/libs/qworker/qworker.h

@@ -28,6 +28,7 @@ enum {
   NODE_TYPE_VNODE = 1,
   NODE_TYPE_QNODE,
   NODE_TYPE_SNODE,
+  NODE_TYPE_MNODE,
 };
 
 

include/libs/scalar/scalar.h

@@ -42,6 +42,21 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type);
 int32_t vectorGetConvertType(int32_t type1, int32_t type2);
 int32_t vectorConvertImpl(SScalarParam* pIn, SScalarParam* pOut);
 
+int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t sqrtFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
+int32_t sinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t cosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t tanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t asinFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t acosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t atanFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
+int32_t ceilFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t floorFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t roundFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 #ifdef __cplusplus
 }

include/libs/stream/tstream.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tdatablock.h"
+#include "tmsg.h"
+#include "tmsgcb.h"
+#include "trpc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _TSTREAM_H_
+#define _TSTREAM_H_
+
+enum {
+  STREAM_TASK_STATUS__RUNNING = 1,
+  STREAM_TASK_STATUS__STOP,
+};
+
+#if 0
+// pipe  -> fetch/pipe queue
+// merge -> merge      queue
+// write -> write      queue
+enum {
+  TASK_DISPATCH_MSG__SND_PIPE = 1,
+  TASK_DISPATCH_MSG__SND_MERGE,
+  TASK_DISPATCH_MSG__VND_PIPE,
+  TASK_DISPATCH_MSG__VND_MERGE,
+  TASK_DISPATCH_MSG__VND_WRITE,
+};
+#endif
+
+typedef struct {
+  int32_t nodeId;  // 0 for snode
+  SEpSet  epSet;
+} SStreamTaskEp;
+
+typedef struct {
+  void* inputHandle;
+  void* executor;
+} SStreamRunner;
+
+typedef struct {
+  int8_t parallelizable;
+  char*  qmsg;
+  // followings are not applicable to encoder and decoder
+  int8_t         numOfRunners;
+  SStreamRunner* runners;
+} STaskExec;
+
+typedef struct {
+  int8_t reserved;
+} STaskDispatcherInplace;
+
+typedef struct {
+  int32_t nodeId;
+  SEpSet  epSet;
+} STaskDispatcherFixedEp;
+
+typedef struct {
+  int8_t  hashMethod;
+  SArray* info;
+} STaskDispatcherShuffle;
+
+typedef struct {
+  int8_t reserved;
+  // not applicable to encoder and decoder
+  SHashObj* pHash;  // groupId to tbuid
+} STaskSinkTb;
+
+typedef struct {
+  int8_t reserved;
+} STaskSinkSma;
+
+typedef struct {
+  int8_t reserved;
+} STaskSinkFetch;
+
+typedef struct {
+  int8_t reserved;
+} STaskSinkShow;
+
+enum {
+  TASK_SOURCE__SCAN = 1,
+  TASK_SOURCE__PIPE,
+  TASK_SOURCE__MERGE,
+};
+
+enum {
+  TASK_EXEC__NONE = 1,
+  TASK_EXEC__PIPE,
+  TASK_EXEC__MERGE,
+};
+
+enum {
+  TASK_DISPATCH__NONE = 1,
+  TASK_DISPATCH__INPLACE,
+  TASK_DISPATCH__FIXED,
+  TASK_DISPATCH__SHUFFLE,
+};
+
+enum {
+  TASK_SINK__NONE = 1,
+  TASK_SINK__TABLE,
+  TASK_SINK__SMA,
+  TASK_SINK__FETCH,
+  TASK_SINK__SHOW,
+};
+
+typedef struct {
+  int64_t streamId;
+  int32_t taskId;
+  int8_t  status;
+
+  int8_t  sourceType;
+  int8_t  execType;
+  int8_t  sinkType;
+  int8_t  dispatchType;
+  int16_t dispatchMsgType;
+  int32_t downstreamTaskId;
+
+  int32_t nodeId;
+  SEpSet  epSet;
+
+  // source preprocess
+
+  // exec
+  STaskExec exec;
+
+  // local sink
+  union {
+    STaskSinkTb    tbSink;
+    STaskSinkSma   smaSink;
+    STaskSinkFetch fetchSink;
+    STaskSinkShow  showSink;
+  };
+
+  // dispatch
+  union {
+    STaskDispatcherInplace inplaceDispatcher;
+    STaskDispatcherFixedEp fixedEpDispatcher;
+    STaskDispatcherShuffle shuffleDispatcher;
+  };
+
+  // state storage
+
+} SStreamTask;
+
+SStreamTask* tNewSStreamTask(int64_t streamId);
+int32_t      tEncodeSStreamTask(SCoder* pEncoder, const SStreamTask* pTask);
+int32_t      tDecodeSStreamTask(SCoder* pDecoder, SStreamTask* pTask);
+void         tFreeSStreamTask(SStreamTask* pTask);
+
+typedef struct {
+  // SMsgHead     head;
+  SStreamTask* task;
+} SStreamTaskDeployReq;
+
+typedef struct {
+  int32_t reserved;
+} SStreamTaskDeployRsp;
+
+typedef struct {
+  // SMsgHead head;
+  int64_t streamId;
+  int32_t taskId;
+  SArray* data;  // SArray<SSDataBlock>
+} SStreamTaskExecReq;
+
+int32_t tEncodeSStreamTaskExecReq(void** buf, const SStreamTaskExecReq* pReq);
+void*   tDecodeSStreamTaskExecReq(const void* buf, SStreamTaskExecReq* pReq);
+void    tFreeSStreamTaskExecReq(SStreamTaskExecReq* pReq);
+
+typedef struct {
+  int32_t reserved;
+} SStreamTaskExecRsp;
+
+typedef struct {
+  // SMsgHead head;
+  int64_t streamId;
+  int64_t version;
+  SArray* res;  // SArray<SSDataBlock>
+} SStreamSinkReq;
+
+int32_t streamExecTask(SStreamTask* pTask, SMsgCb* pMsgCb, const void* input, int32_t inputType, int32_t workId);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _TSTREAM_H_ */

include/libs/transport/trpc.h

@@ -52,8 +52,8 @@ typedef struct {
   char    user[TSDB_USER_LEN];
   SRpcMsg rpcMsg;
   int32_t rspLen;
-  void   *pRsp;
-  void   *pNode;
+  void *  pRsp;
+  void *  pNode;
 } SNodeMsg;
 
 typedef struct SRpcInit {
@@ -81,13 +81,21 @@ typedef struct SRpcInit {
 } SRpcInit;
 
 typedef struct {
-  void *  val;
-  int32_t len;
-  void (*free)(void *arg);
+  void     *val;
+  int32_t (*clone)(void *src, void **dst);
+  void    (*freeFunc)(const void *arg);
 } SRpcCtxVal;
 
 typedef struct {
-  SHashObj *args;
+  int32_t   msgType;
+  void     *val;
+  int32_t (*clone)(void *src, void **dst);
+  void    (*freeFunc)(const void *arg);
+} SRpcBrokenlinkVal;
+
+typedef struct {
+  SHashObj *        args;
+  SRpcBrokenlinkVal brokenVal;
 } SRpcCtx;
 
 int32_t rpcInit();

include/libs/wal/wal.h

@@ -61,30 +61,45 @@ extern "C" {
     }                                                             \
   }
 
-#define WAL_HEAD_VER 0
+#define WAL_HEAD_VER     0
 #define WAL_NOSUFFIX_LEN 20
-#define WAL_SUFFIX_AT (WAL_NOSUFFIX_LEN + 1)
-#define WAL_LOG_SUFFIX "log"
+#define WAL_SUFFIX_AT    (WAL_NOSUFFIX_LEN + 1)
+#define WAL_LOG_SUFFIX   "log"
 #define WAL_INDEX_SUFFIX "idx"
-#define WAL_REFRESH_MS 1000
-#define WAL_MAX_SIZE (TSDB_MAX_WAL_SIZE + sizeof(SWalHead))
-#define WAL_PATH_LEN (TSDB_FILENAME_LEN + 12)
-#define WAL_FILE_LEN (WAL_PATH_LEN + 32)
-#define WAL_MAGIC 0xFAFBFCFDULL
+#define WAL_REFRESH_MS   1000
+#define WAL_MAX_SIZE     (TSDB_MAX_WAL_SIZE + sizeof(SWalHead))
+#define WAL_PATH_LEN     (TSDB_FILENAME_LEN + 12)
+#define WAL_FILE_LEN     (WAL_PATH_LEN + 32)
+#define WAL_MAGIC        0xFAFBFCFDULL
 
 #define WAL_CUR_FAILED 1
 
 #pragma pack(push, 1)
-typedef enum { TAOS_WAL_NOLOG = 0, TAOS_WAL_WRITE = 1, TAOS_WAL_FSYNC = 2 } EWalType;
+typedef enum {
+  TAOS_WAL_NOLOG = 0,
+  TAOS_WAL_WRITE = 1,
+  TAOS_WAL_FSYNC = 2,
+} EWalType;
+
+// used by sync module
+typedef struct {
+  int8_t   isWeek;
+  uint64_t seqNum;
+  uint64_t term;
+} SSyncLogMeta;
 
 typedef struct SWalReadHead {
   int8_t  headVer;
-  int16_t msgType;
   int8_t  reserved;
+  int16_t msgType;
   int32_t len;
   int64_t ingestTs;  // not implemented
   int64_t version;
-  char    body[];
+
+  // sync meta
+  SSyncLogMeta syncMeta;
+
+  char body[];
 } SWalReadHead;
 
 typedef struct {
@@ -117,16 +132,16 @@ typedef struct SWal {
   SWalCfg cfg;
   int32_t fsyncSeq;
   // meta
-  SWalVer vers;
+  SWalVer   vers;
   TdFilePtr pWriteLogTFile;
   TdFilePtr pWriteIdxTFile;
-  int32_t writeCur;
-  SArray *fileInfoSet;
+  int32_t   writeCur;
+  SArray   *fileInfoSet;
   // status
   int64_t totSize;
   int64_t lastRollSeq;
   // ctl
-  int64_t         refId;
+  int64_t       refId;
   TdThreadMutex mutex;
   // path
   char path[WAL_PATH_LEN];
@@ -158,6 +173,8 @@ int32_t walAlter(SWal *, SWalCfg *pCfg);
 void    walClose(SWal *);
 
 // write
+int64_t walWriteWithSyncInfo(SWal *, int64_t index, tmsg_t msgType, SSyncLogMeta syncMeta, const void *body,
+                             int32_t bodyLen);
 int64_t walWrite(SWal *, int64_t index, tmsg_t msgType, const void *body, int32_t bodyLen);
 void    walFsync(SWal *, bool force);
 

include/os/osMemory.h

@@ -20,12 +20,25 @@
 extern "C" {
 #endif
 
-#define tfree(x)         \
-  do {                   \
-    if (x) {             \
-      free((void *)(x)); \
-      (x) = 0;           \
-    }                    \
+// If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following sectio
+#ifndef ALLOW_FORBID_FUNC
+    #define malloc MALLOC_FUNC_TAOS_FORBID
+    #define calloc CALLOC_FUNC_TAOS_FORBID
+    #define realloc REALLOC_FUNC_TAOS_FORBID
+    #define free FREE_FUNC_TAOS_FORBID
+#endif
+
+void *taosMemoryMalloc(int32_t size);
+void *taosMemoryCalloc(int32_t num, int32_t size);
+void *taosMemoryRealloc(void *ptr, int32_t size);
+void taosMemoryFree(const void *ptr);
+int32_t taosMemorySize(void *ptr);
+
+#define taosMemoryFreeClear(ptr) \
+  do {                           \
+    taosMemoryFree(ptr);         \
+    (ptr)=NULL;                  \
   } while (0)
 
 #ifdef __cplusplus

include/util/tcoding.h

@@ -351,7 +351,7 @@ static FORCE_INLINE void *taosDecodeString(const void *buf, char **value) {
   uint64_t size = 0;
 
   buf = taosDecodeVariantU64(buf, &size);
-  *value = (char *)malloc((size_t)size + 1);
+  *value = (char *)taosMemoryMalloc((size_t)size + 1);
 
   if (*value == NULL) return NULL;
   memcpy(*value, buf, (size_t)size);
@@ -386,7 +386,7 @@ static FORCE_INLINE int32_t taosEncodeBinary(void **buf, const void *value, int3
 }
 
 static FORCE_INLINE void *taosDecodeBinary(const void *buf, void **value, int32_t valueLen) {
-  *value = malloc((size_t)valueLen);
+  *value = taosMemoryMalloc((size_t)valueLen);
   if (*value == NULL) return NULL;
   memcpy(*value, buf, (size_t)valueLen);
 

include/util/tdef.h

@@ -109,6 +109,8 @@ extern const int32_t TYPE_BYTES[15];
 #define TSDB_INS_TABLE_USER_USERS             "user_users"
 #define TSDB_INS_TABLE_VGROUPS                "vgroups"
 
+#define TSDB_INS_USER_STABLES_DBNAME_COLID    2
+
 #define TSDB_TICK_PER_SECOND(precision)                      \
   ((int64_t)((precision) == TSDB_TIME_PRECISION_MILLI ? 1e3L \
                                                       : ((precision) == TSDB_TIME_PRECISION_MICRO ? 1e6L : 1e9L)))

include/util/tencode.h

@@ -406,7 +406,7 @@ static FORCE_INLINE int32_t tDecodeBinaryAlloc(SCoder* pDecoder, void** val, uin
   if (tDecodeU64v(pDecoder, len) < 0) return -1;
 
   if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, *len)) return -1;
-  *val = malloc(*len);
+  *val = taosMemoryMalloc(*len);
   if (*val == NULL) return -1;
   memcpy(*val, TD_CODER_CURRENT(pDecoder), *len);
 

include/util/tfreelist.h

@@ -31,7 +31,7 @@ typedef TD_SLIST(SFreeListNode) SFreeList;
 
 #define TFL_MALLOC(PTR, TYPE, SIZE, LIST)                      \
   do {                                                         \
-    void *ptr = malloc((SIZE) + sizeof(struct SFreeListNode)); \
+    void *ptr = taosMemoryMalloc((SIZE) + sizeof(struct SFreeListNode)); \
     if (ptr) {                                                 \
       TD_SLIST_PUSH((LIST), (struct SFreeListNode *)ptr);      \
       ptr = ((struct SFreeListNode *)ptr)->payload;            \
@@ -49,7 +49,7 @@ static FORCE_INLINE void tFreeListClear(SFreeList *pFL) {
     pNode = TD_SLIST_HEAD(pFL);
     if (pNode == NULL) break;
     TD_SLIST_POP(pFL);
-    free(pNode);
+    taosMemoryFree(pNode);
   }
 }
 

include/util/tlist.h

@@ -216,7 +216,7 @@ typedef struct {
 #define listNEles(l)    TD_DLIST_NELES(l)
 #define listEleSize(l)  ((l)->eleSize)
 #define isListEmpty(l)  (TD_DLIST_NELES(l) == 0)
-#define listNodeFree(n) free(n)
+#define listNodeFree(n) taosMemoryFree(n)
 
 void       tdListInit(SList *list, int32_t eleSize);
 void       tdListEmpty(SList *list);

source/client/src/clientEnv.c

@@ -115,11 +115,11 @@ void destroyTscObj(void *pObj) {
   atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
   tscDebug("connObj 0x%" PRIx64 " destroyed, totalConn:%" PRId64, pTscObj->id, pTscObj->pAppInfo->numOfConns);
   taosThreadMutexDestroy(&pTscObj->mutex);
-  tfree(pTscObj);
+  taosMemoryFreeClear(pTscObj);
 }
 
 void *createTscObj(const char *user, const char *auth, const char *db, SAppInstInfo *pAppInfo) {
-  STscObj *pObj = (STscObj *)calloc(1, sizeof(STscObj));
+  STscObj *pObj = (STscObj *)taosMemoryCalloc(1, sizeof(STscObj));
   if (NULL == pObj) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return NULL;
@@ -143,7 +143,7 @@ void *createTscObj(const char *user, const char *auth, const char *db, SAppInstI
 void *createRequest(STscObj *pObj, __taos_async_fn_t fp, void *param, int32_t type) {
   assert(pObj != NULL);
 
-  SRequestObj *pRequest = (SRequestObj *)calloc(1, sizeof(SRequestObj));
+  SRequestObj *pRequest = (SRequestObj *)taosMemoryCalloc(1, sizeof(SRequestObj));
   if (NULL == pRequest) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return NULL;
@@ -156,7 +156,7 @@ void *createRequest(STscObj *pObj, __taos_async_fn_t fp, void *param, int32_t ty
   pRequest->type = type;
   pRequest->pTscObj = pObj;
   pRequest->body.fp = fp;  // not used it yet
-  pRequest->msgBuf = calloc(1, ERROR_MSG_BUF_DEFAULT_SIZE);
+  pRequest->msgBuf = taosMemoryCalloc(1, ERROR_MSG_BUF_DEFAULT_SIZE);
   tsem_init(&pRequest->body.rspSem, 0, 0);
 
   registerRequest(pRequest);
@@ -164,17 +164,17 @@ void *createRequest(STscObj *pObj, __taos_async_fn_t fp, void *param, int32_t ty
 }
 
 static void doFreeReqResultInfo(SReqResultInfo *pResInfo) {
-  tfree(pResInfo->pRspMsg);
-  tfree(pResInfo->length);
-  tfree(pResInfo->row);
-  tfree(pResInfo->pCol);
-  tfree(pResInfo->fields);
+  taosMemoryFreeClear(pResInfo->pRspMsg);
+  taosMemoryFreeClear(pResInfo->length);
+  taosMemoryFreeClear(pResInfo->row);
+  taosMemoryFreeClear(pResInfo->pCol);
+  taosMemoryFreeClear(pResInfo->fields);
 
   if (pResInfo->convertBuf != NULL) {
     for (int32_t i = 0; i < pResInfo->numOfCols; ++i) {
-      tfree(pResInfo->convertBuf[i]);
+      taosMemoryFreeClear(pResInfo->convertBuf[i]);
     }
-    tfree(pResInfo->convertBuf);
+    taosMemoryFreeClear(pResInfo->convertBuf);
   }
 }
 
@@ -184,20 +184,24 @@ static void doDestroyRequest(void *p) {
 
   assert(RID_VALID(pRequest->self));
 
-  tfree(pRequest->msgBuf);
-  tfree(pRequest->sqlstr);
-  tfree(pRequest->pInfo);
-  tfree(pRequest->pDb);
+  taosMemoryFreeClear(pRequest->msgBuf);
+  taosMemoryFreeClear(pRequest->sqlstr);
+  taosMemoryFreeClear(pRequest->pInfo);
+  taosMemoryFreeClear(pRequest->pDb);
 
   doFreeReqResultInfo(&pRequest->body.resInfo);
   qDestroyQueryPlan(pRequest->body.pDag);
 
+  if (pRequest->body.queryJob != 0) {
+    schedulerFreeJob(pRequest->body.queryJob);
+  }
+
   if (pRequest->body.showInfo.pArray != NULL) {
     taosArrayDestroy(pRequest->body.showInfo.pArray);
   }
 
   deregisterRequest(pRequest);
-  tfree(pRequest);
+  taosMemoryFreeClear(pRequest);
 }
 
 void destroyRequest(SRequestObj *pRequest) {
@@ -356,7 +360,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
             tscInfo("charset:%s is not valid in locale, charset remains:%s", charset, tsCharset);
           }
 
-          free(charset);
+          taosMemoryFree(charset);
         } else {  // it may be windows system
           tscInfo("charset remains:%s", tsCharset);
         }

source/client/src/clientHb.c

@@ -166,7 +166,7 @@ static int32_t hbQueryHbRspHandle(SAppHbMgr *pAppHbMgr, SClientHbRsp *pRsp) {
 static int32_t hbAsyncCallBack(void *param, const SDataBuf *pMsg, int32_t code) {
   static int32_t emptyRspNum = 0;
   if (code != 0) {
-    tfree(param);
+    taosMemoryFreeClear(param);
     return -1;
   }
 
@@ -179,12 +179,12 @@ static int32_t hbAsyncCallBack(void *param, const SDataBuf *pMsg, int32_t code)
   SAppInstInfo **pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
   if (pInst == NULL || NULL == *pInst) {
     tscError("cluster not exist, key:%s", key);
-    tfree(param);
+    taosMemoryFreeClear(param);
     tFreeClientHbBatchRsp(&pRsp);
     return -1;
   }
 
-  tfree(param);
+  taosMemoryFreeClear(param);
 
   if (rspNum) {
     tscDebug("hb got %d rsp, %d empty rsp received before", rspNum,
@@ -317,7 +317,7 @@ void hbFreeReq(void *req) {
 }
 
 SClientHbBatchReq *hbGatherAllInfo(SAppHbMgr *pAppHbMgr) {
-  SClientHbBatchReq *pBatchReq = calloc(1, sizeof(SClientHbBatchReq));
+  SClientHbBatchReq *pBatchReq = taosMemoryCalloc(1, sizeof(SClientHbBatchReq));
   if (pBatchReq == NULL) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return NULL;
@@ -346,7 +346,7 @@ SClientHbBatchReq *hbGatherAllInfo(SAppHbMgr *pAppHbMgr) {
 
   if (code) {
     taosArrayDestroyEx(pBatchReq->reqs, hbFreeReq);
-    tfree(pBatchReq);
+    taosMemoryFreeClear(pBatchReq);
   }
 
   return pBatchReq;
@@ -387,7 +387,7 @@ static void *hbThreadFunc(void *param) {
         continue;
       }
       int   tlen = tSerializeSClientHbBatchReq(NULL, 0, pReq);
-      void *buf = malloc(tlen);
+      void *buf = taosMemoryMalloc(tlen);
       if (buf == NULL) {
         terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
         tFreeClientHbBatchReq(pReq, false);
@@ -396,13 +396,13 @@ static void *hbThreadFunc(void *param) {
       }
 
       tSerializeSClientHbBatchReq(buf, tlen, pReq);
-      SMsgSendInfo *pInfo = calloc(1, sizeof(SMsgSendInfo));
+      SMsgSendInfo *pInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
 
       if (pInfo == NULL) {
         terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
         tFreeClientHbBatchReq(pReq, false);
         hbClearReqInfo(pAppHbMgr);
-        free(buf);
+        taosMemoryFree(buf);
         break;
       }
       pInfo->fp = hbAsyncCallBack;
@@ -458,7 +458,7 @@ static void hbStopThread() {
 
 SAppHbMgr *appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key) {
   hbMgrInit();
-  SAppHbMgr *pAppHbMgr = malloc(sizeof(SAppHbMgr));
+  SAppHbMgr *pAppHbMgr = taosMemoryMalloc(sizeof(SAppHbMgr));
   if (pAppHbMgr == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -478,7 +478,7 @@ SAppHbMgr *appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key) {
 
   if (pAppHbMgr->activeInfo == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    free(pAppHbMgr);
+    taosMemoryFree(pAppHbMgr);
     return NULL;
   }
 
@@ -488,7 +488,7 @@ SAppHbMgr *appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key) {
 
   if (pAppHbMgr->connInfo == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    free(pAppHbMgr);
+    taosMemoryFree(pAppHbMgr);
     return NULL;
   }
 
@@ -580,7 +580,7 @@ int hbRegisterConn(SAppHbMgr *pAppHbMgr, int32_t connId, int64_t clusterId, int3
 
   switch (hbType) {
     case HEARTBEAT_TYPE_QUERY: {
-      int64_t *pClusterId = malloc(sizeof(int64_t));
+      int64_t *pClusterId = taosMemoryMalloc(sizeof(int64_t));
       *pClusterId = clusterId;
 
       info.param = pClusterId;

source/client/src/clientImpl.c

@@ -100,7 +100,7 @@ TAOS* taos_connect_internal(const char* ip, const char* user, const char* pass,
   pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
   SAppInstInfo* p = NULL;
   if (pInst == NULL) {
-    p = calloc(1, sizeof(struct SAppInstInfo));
+    p = taosMemoryCalloc(1, sizeof(struct SAppInstInfo));
     p->mgmtEp = epSet;
     p->pTransporter = openTransporter(user, secretEncrypt, tsNumOfCores);
     p->pAppHbMgr = appHbMgrInit(p, key);
@@ -111,7 +111,7 @@ TAOS* taos_connect_internal(const char* ip, const char* user, const char* pass,
 
   taosThreadMutexUnlock(&appInfo.mutex);
 
-  tfree(key);
+  taosMemoryFreeClear(key);
   return taosConnectImpl(user, &secretEncrypt[0], localDb, NULL, NULL, *pInst);
 }
 
@@ -122,7 +122,7 @@ int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj*
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  (*pRequest)->sqlstr = malloc(sqlLen + 1);
+  (*pRequest)->sqlstr = taosMemoryMalloc(sqlLen + 1);
   if ((*pRequest)->sqlstr == NULL) {
     tscError("0x%" PRIx64 " failed to prepare sql string buffer", (*pRequest)->self);
     (*pRequest)->msgBuf = strdup("failed to prepare sql string buffer");
@@ -199,7 +199,8 @@ int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArra
     .queryId = pRequest->requestId,
     .acctId = pRequest->pTscObj->acctId,
     .mgmtEpSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp),
-    .pAstRoot = pQuery->pRoot
+    .pAstRoot = pQuery->pRoot,
+    .showRewrite = pQuery->showRewrite
   };
   int32_t  code = qCreateQueryPlan(&cxt, pPlan, pNodeList);
   if (code != 0) {
@@ -212,7 +213,7 @@ void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t
   assert(pSchema != NULL && numOfCols > 0);
 
   pResInfo->numOfCols = numOfCols;
-  pResInfo->fields = calloc(numOfCols, sizeof(pSchema[0]));
+  pResInfo->fields = taosMemoryCalloc(numOfCols, sizeof(pSchema[0]));
 
   for (int32_t i = 0; i < pResInfo->numOfCols; ++i) {
     pResInfo->fields[i].bytes = pSchema[i].bytes;
@@ -330,6 +331,8 @@ SRequestObj* execQuery(STscObj* pTscObj, const char* sql, int sqlLen) {
       pRequest->code = code;
       break;
     }
+
+    destroyRequest(pRequest);
   }
   
   return pRequest;
@@ -421,7 +424,7 @@ STscObj* taosConnectImpl(const char* user, const char* auth, const char* db, __t
 }
 
 static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest) {
-  SMsgSendInfo* pMsgSendInfo = calloc(1, sizeof(SMsgSendInfo));
+  SMsgSendInfo* pMsgSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
   if (pMsgSendInfo == NULL) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return NULL;
@@ -441,14 +444,14 @@ static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest) {
   if (db != NULL) {
     tstrncpy(connectReq.db, db, sizeof(connectReq.db));
   }
-  tfree(db);
+  taosMemoryFreeClear(db);
 
   connectReq.pid = htonl(appInfo.pid);
   connectReq.startTime = htobe64(appInfo.startTime);
   tstrncpy(connectReq.app, appInfo.appName, sizeof(connectReq.app));
 
   int32_t contLen = tSerializeSConnectReq(NULL, 0, &connectReq);
-  void*   pReq = malloc(contLen);
+  void*   pReq = taosMemoryMalloc(contLen);
   tSerializeSConnectReq(pReq, contLen, &connectReq);
 
   pMsgSendInfo->msgInfo.len = contLen;
@@ -458,8 +461,8 @@ static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest) {
 
 static void destroySendMsgInfo(SMsgSendInfo* pMsgBody) {
   assert(pMsgBody != NULL);
-  tfree(pMsgBody->msgInfo.pData);
-  tfree(pMsgBody);
+  taosMemoryFreeClear(pMsgBody->msgInfo.pData);
+  taosMemoryFreeClear(pMsgBody);
 }
 bool persistConnForSpecificMsg(void* parenct, tmsg_t msgType) {
   return msgType == TDMT_VND_QUERY_RSP || msgType == TDMT_VND_FETCH_RSP || msgType == TDMT_VND_RES_READY_RSP || msgType == TDMT_VND_QUERY_HEARTBEAT_RSP;
@@ -500,7 +503,7 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
   SDataBuf buf = {.len = pMsg->contLen, .pData = NULL, .handle = pMsg->handle};
 
   if (pMsg->contLen > 0) {
-    buf.pData = calloc(1, pMsg->contLen);
+    buf.pData = taosMemoryCalloc(1, pMsg->contLen);
     if (buf.pData == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       pMsg->code = TSDB_CODE_OUT_OF_MEMORY;
@@ -592,7 +595,7 @@ void* doFetchRow(SRequestObj* pRequest) {
       }
 
       SVgroupInfo*     pVgroupInfo = taosArrayGet(pShowReqInfo->pArray, pShowReqInfo->currentIndex);
-      SVShowTablesReq* pShowReq = calloc(1, sizeof(SVShowTablesReq));
+      SVShowTablesReq* pShowReq = taosMemoryCalloc(1, sizeof(SVShowTablesReq));
       pShowReq->head.vgId = htonl(pVgroupInfo->vgId);
 
       pRequest->body.requestMsg.len = sizeof(SVShowTablesReq);
@@ -670,10 +673,10 @@ _return:
 
 static int32_t doPrepareResPtr(SReqResultInfo* pResInfo) {
   if (pResInfo->row == NULL) {
-    pResInfo->row    = calloc(pResInfo->numOfCols, POINTER_BYTES);
-    pResInfo->pCol   = calloc(pResInfo->numOfCols, sizeof(SResultColumn));
-    pResInfo->length = calloc(pResInfo->numOfCols, sizeof(int32_t));
-    pResInfo->convertBuf = calloc(pResInfo->numOfCols, POINTER_BYTES);
+    pResInfo->row    = taosMemoryCalloc(pResInfo->numOfCols, POINTER_BYTES);
+    pResInfo->pCol   = taosMemoryCalloc(pResInfo->numOfCols, sizeof(SResultColumn));
+    pResInfo->length = taosMemoryCalloc(pResInfo->numOfCols, sizeof(int32_t));
+    pResInfo->convertBuf = taosMemoryCalloc(pResInfo->numOfCols, POINTER_BYTES);
 
     if (pResInfo->row == NULL || pResInfo->pCol == NULL || pResInfo->length == NULL || pResInfo->convertBuf == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
@@ -681,7 +684,7 @@ static int32_t doPrepareResPtr(SReqResultInfo* pResInfo) {
 
     for(int32_t i = 0; i < pResInfo->numOfCols; ++i) {
       if(pResInfo->fields[i].type == TSDB_DATA_TYPE_NCHAR) {
-        pResInfo->convertBuf[i] = calloc(1, NCHAR_WIDTH_TO_BYTES(pResInfo->fields[i].bytes));
+        pResInfo->convertBuf[i] = taosMemoryCalloc(1, NCHAR_WIDTH_TO_BYTES(pResInfo->fields[i].bytes));
       }
     }
   }

source/client/src/clientMsgHandler.c

@@ -32,7 +32,7 @@ int32_t genericRspCallback(void* param, const SDataBuf* pMsg, int32_t code) {
   SRequestObj* pRequest = param;
   setErrno(pRequest, code);
 
-  free(pMsg->pData);
+  taosMemoryFree(pMsg->pData);
   tsem_post(&pRequest->body.rspSem);
   return code;
 }
@@ -40,7 +40,7 @@ int32_t genericRspCallback(void* param, const SDataBuf* pMsg, int32_t code) {
 int32_t processConnectRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   SRequestObj* pRequest = param;
   if (code != TSDB_CODE_SUCCESS) {
-    free(pMsg->pData);
+    taosMemoryFree(pMsg->pData);
     setErrno(pRequest, code);
     tsem_post(&pRequest->body.rspSem);
     return code;
@@ -77,13 +77,13 @@ int32_t processConnectRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   tscDebug("0x%" PRIx64 " clusterId:%" PRId64 ", totalConn:%" PRId64, pRequest->requestId, connectRsp.clusterId,
            pTscObj->pAppInfo->numOfConns);
 
-  free(pMsg->pData);
+  taosMemoryFree(pMsg->pData);
   tsem_post(&pRequest->body.rspSem);
   return 0;
 }
 
 SMsgSendInfo* buildMsgInfoImpl(SRequestObj *pRequest) {
-  SMsgSendInfo* pMsgSendInfo = calloc(1, sizeof(SMsgSendInfo));
+  SMsgSendInfo* pMsgSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
 
   pMsgSendInfo->requestObjRefId = pRequest->self;
   pMsgSendInfo->requestId       = pRequest->requestId;
@@ -96,13 +96,13 @@ SMsgSendInfo* buildMsgInfoImpl(SRequestObj *pRequest) {
       retrieveReq.showId = pRequest->body.showInfo.execId;
 
       int32_t contLen = tSerializeSRetrieveTableReq(NULL, 0, &retrieveReq);
-      void*   pReq = malloc(contLen);
+      void*   pReq = taosMemoryMalloc(contLen);
       tSerializeSRetrieveTableReq(pReq, contLen, &retrieveReq);
       pMsgSendInfo->msgInfo.pData = pReq;
       pMsgSendInfo->msgInfo.len = contLen;
       pMsgSendInfo->msgInfo.handle = NULL;
     } else {
-      SVShowTablesFetchReq* pFetchMsg = calloc(1, sizeof(SVShowTablesFetchReq));
+      SVShowTablesFetchReq* pFetchMsg = taosMemoryCalloc(1, sizeof(SVShowTablesFetchReq));
       if (pFetchMsg == NULL) {
         return NULL;
       }
@@ -135,12 +135,12 @@ int32_t processShowRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   tDeserializeSShowRsp(pMsg->pData, pMsg->len, &showRsp);
   STableMetaRsp *pMetaMsg = &showRsp.tableMeta;
 
-  tfree(pRequest->body.resInfo.pRspMsg);
+  taosMemoryFreeClear(pRequest->body.resInfo.pRspMsg);
   pRequest->body.resInfo.pRspMsg = pMsg->pData;
   SReqResultInfo* pResInfo = &pRequest->body.resInfo;
 
   if (pResInfo->fields == NULL) {
-    TAOS_FIELD* pFields = calloc(pMetaMsg->numOfColumns, sizeof(TAOS_FIELD));
+    TAOS_FIELD* pFields = taosMemoryCalloc(pMetaMsg->numOfColumns, sizeof(TAOS_FIELD));
     for (int32_t i = 0; i < pMetaMsg->numOfColumns; ++i) {
       SSchema* pSchema = &pMetaMsg->pSchemas[i];
       tstrncpy(pFields[i].name, pSchema->name, tListLen(pFields[i].name));
@@ -171,7 +171,7 @@ int32_t processShowRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 int32_t processRetrieveMnodeRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   SRequestObj    *pRequest = param;
   SReqResultInfo *pResInfo = &pRequest->body.resInfo;
-  tfree(pResInfo->pRspMsg);
+  taosMemoryFreeClear(pResInfo->pRspMsg);
 
   if (code != TSDB_CODE_SUCCESS) {
     setErrno(pRequest, code);
@@ -204,7 +204,7 @@ int32_t processRetrieveVndRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   SRequestObj* pRequest = param;
 
   SReqResultInfo* pResInfo = &pRequest->body.resInfo;
-  tfree(pResInfo->pRspMsg);
+  taosMemoryFreeClear(pResInfo->pRspMsg);
 
   if (code != TSDB_CODE_SUCCESS) {
     setErrno(pRequest, code);
@@ -237,7 +237,7 @@ int32_t processRetrieveVndRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 int32_t processCreateDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   // todo rsp with the vnode id list
   SRequestObj* pRequest = param;
-  free(pMsg->pData);
+  taosMemoryFree(pMsg->pData);
   if (code != TSDB_CODE_SUCCESS) {
     setErrno(pRequest, code);
   }
@@ -266,7 +266,7 @@ int32_t processUseDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   }
 
   if (code != TSDB_CODE_SUCCESS) {
-    free(pMsg->pData);
+    taosMemoryFree(pMsg->pData);
     setErrno(pRequest, code);
     tsem_post(&pRequest->body.rspSem);
     return code;
@@ -284,7 +284,7 @@ int32_t processUseDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   if (code != 0) {
     terrno = code;
     if (output.dbVgroup) taosHashCleanup(output.dbVgroup->vgHash);
-    tfree(output.dbVgroup);
+    taosMemoryFreeClear(output.dbVgroup);
 
     tscError("failed to build use db output since %s", terrstr());
   } else {
@@ -304,7 +304,7 @@ int32_t processUseDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   tNameGetDbName(&name, db);
 
   setConnectionDB(pRequest->pTscObj, db);
-  free(pMsg->pData);
+  taosMemoryFree(pMsg->pData);
   tsem_post(&pRequest->body.rspSem);
   return 0;
 }
@@ -313,7 +313,7 @@ int32_t processCreateTableRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   assert(pMsg != NULL && param != NULL);
   SRequestObj* pRequest = param;
 
-  free(pMsg->pData);
+  taosMemoryFree(pMsg->pData);
   if (code != TSDB_CODE_SUCCESS) {
     setErrno(pRequest, code);
     tsem_post(&pRequest->body.rspSem);

source/client/src/tmq.c

@@ -136,14 +136,14 @@ typedef struct {
 } SMqCommitCbParam;
 
 tmq_conf_t* tmq_conf_new() {
-  tmq_conf_t* conf = calloc(1, sizeof(tmq_conf_t));
+  tmq_conf_t* conf = taosMemoryCalloc(1, sizeof(tmq_conf_t));
   conf->auto_commit = false;
   conf->resetOffset = TMQ_CONF__RESET_OFFSET__EARLIEAST;
   return conf;
 }
 
 void tmq_conf_destroy(tmq_conf_t* conf) {
-  if (conf) free(conf);
+  if (conf) taosMemoryFree(conf);
 }
 
 tmq_conf_res_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value) {
@@ -184,7 +184,7 @@ tmq_conf_res_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value
 }
 
 tmq_list_t* tmq_list_new() {
-  tmq_list_t* ptr = malloc(sizeof(tmq_list_t) + 8 * sizeof(char*));
+  tmq_list_t* ptr = taosMemoryMalloc(sizeof(tmq_list_t) + 8 * sizeof(char*));
   if (ptr == NULL) {
     return ptr;
   }
@@ -254,7 +254,7 @@ tmq_resp_err_t tmq_unsubscribe(tmq_t* tmq) {
 }
 
 tmq_t* tmq_consumer_new(void* conn, tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
-  tmq_t* pTmq = calloc(sizeof(tmq_t), 1);
+  tmq_t* pTmq = taosMemoryCalloc(sizeof(tmq_t), 1);
   if (pTmq == NULL) {
     return NULL;
   }
@@ -317,7 +317,7 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* offsets, in
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, NULL, 0, TD_ENCODER);
   tEncodeSMqCMCommitOffsetReq(&encoder, &req);
   int32_t tlen = encoder.pos;
-  void*   buf = malloc(tlen);
+  void*   buf = taosMemoryMalloc(tlen);
   if (buf == NULL) {
     tCoderClear(&encoder);
     return -1;
@@ -333,7 +333,7 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* offsets, in
     tscError("failed to malloc request");
   }
 
-  SMqCommitCbParam* pParam = malloc(sizeof(SMqCommitCbParam));
+  SMqCommitCbParam* pParam = taosMemoryMalloc(sizeof(SMqCommitCbParam));
   if (pParam == NULL) {
     return -1;
   }
@@ -361,7 +361,7 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* offsets, in
   }
 
   tsem_destroy(&pParam->rspSem);
-  free(pParam);
+  taosMemoryFree(pParam);
 
   if (pArray) {
     taosArrayDestroy(pArray);
@@ -394,7 +394,7 @@ tmq_resp_err_t tmq_subscribe(tmq_t* tmq, tmq_list_t* topic_list) {
     tNameSetDbName(&name, tmq->pTscObj->acctId, dbName, strlen(dbName));
     tNameFromString(&name, topicName, T_NAME_TABLE);
 
-    char* topicFname = calloc(1, TSDB_TOPIC_FNAME_LEN);
+    char* topicFname = taosMemoryCalloc(1, TSDB_TOPIC_FNAME_LEN);
     if (topicFname == NULL) {
       goto _return;
     }
@@ -405,11 +405,11 @@ tmq_resp_err_t tmq_subscribe(tmq_t* tmq, tmq_list_t* topic_list) {
     topic.vgs = taosArrayInit(0, sizeof(SMqClientVg));
     taosArrayPush(tmq->clientTopics, &topic);
     taosArrayPush(req.topicNames, &topicFname);
-    free(dbName);
+    taosMemoryFree(dbName);
   }
 
   int   tlen = tSerializeSCMSubscribeReq(NULL, &req);
-  void* buf = malloc(tlen);
+  void* buf = taosMemoryMalloc(tlen);
   if (buf == NULL) {
     goto _return;
   }
@@ -508,7 +508,7 @@ TAOS_RES* tmq_create_stream(TAOS* taos, const char* streamName, const char* tbNa
   strcpy(req.outputSTbName, tbName);
 
   int   tlen = tSerializeSCMCreateStreamReq(NULL, 0, &req);
-  void* buf = malloc(tlen);
+  void* buf = taosMemoryMalloc(tlen);
   if (buf == NULL) {
     goto _return;
   }
@@ -532,7 +532,7 @@ TAOS_RES* tmq_create_stream(TAOS* taos, const char* streamName, const char* tbNa
   tsem_wait(&pRequest->body.rspSem);
 
 _return:
-  tfree(astStr);
+  taosMemoryFreeClear(astStr);
   qDestroyQuery(pQueryNode);
   /*if (sendInfo != NULL) {*/
   /*destroySendMsgInfo(sendInfo);*/
@@ -594,7 +594,7 @@ TAOS_RES* tmq_create_topic(TAOS* taos, const char* topicName, const char* sql, i
   tNameExtractFullName(&name, req.name);
 
   int   tlen = tSerializeSCMCreateTopicReq(NULL, 0, &req);
-  void* buf = malloc(tlen);
+  void* buf = taosMemoryMalloc(tlen);
   if (buf == NULL) {
     goto _return;
   }
@@ -618,7 +618,7 @@ TAOS_RES* tmq_create_topic(TAOS* taos, const char* topicName, const char* sql, i
   tsem_wait(&pRequest->body.rspSem);
 
 _return:
-  tfree(astStr);
+  taosMemoryFreeClear(astStr);
   qDestroyQuery(pQueryNode);
   /*if (sendInfo != NULL) {*/
   /*destroySendMsgInfo(sendInfo);*/
@@ -757,7 +757,7 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
 
 #if 0
   if (pParam->sync == 1) {
-    /**pParam->msg = malloc(sizeof(tmq_message_t));*/
+    /**pParam->msg = taosMemoryMalloc(sizeof(tmq_message_t));*/
     *pParam->msg = taosAllocateQitem(sizeof(tmq_message_t));
     if (*pParam->msg) {
       memcpy(*pParam->msg, pMsg->pData, sizeof(SMqRspHead));
@@ -774,7 +774,7 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
   }
 #endif
 
-  /*SMqConsumeRsp* pRsp = calloc(1, sizeof(SMqConsumeRsp));*/
+  /*SMqConsumeRsp* pRsp = taosMemoryCalloc(1, sizeof(SMqConsumeRsp));*/
   tmq_message_t* pRsp = taosAllocateQitem(sizeof(tmq_message_t));
   if (pRsp == NULL) {
     goto WRITE_QUEUE_FAIL;
@@ -884,7 +884,7 @@ END:
 
 int32_t tmqAskEp(tmq_t* tmq, bool sync) {
   int32_t           tlen = sizeof(SMqCMGetSubEpReq);
-  SMqCMGetSubEpReq* req = malloc(tlen);
+  SMqCMGetSubEpReq* req = taosMemoryMalloc(tlen);
   if (req == NULL) {
     tscError("failed to malloc get subscribe ep buf");
     return -1;
@@ -893,21 +893,21 @@ int32_t tmqAskEp(tmq_t* tmq, bool sync) {
   req->epoch = htonl(tmq->epoch);
   strcpy(req->cgroup, tmq->groupId);
 
-  SMqAskEpCbParam* pParam = malloc(sizeof(SMqAskEpCbParam));
+  SMqAskEpCbParam* pParam = taosMemoryMalloc(sizeof(SMqAskEpCbParam));
   if (pParam == NULL) {
     tscError("failed to malloc subscribe param");
-    free(req);
+    taosMemoryFree(req);
     return -1;
   }
   pParam->tmq = tmq;
   pParam->sync = sync;
   tsem_init(&pParam->rspSem, 0, 0);
 
-  SMsgSendInfo* sendInfo = malloc(sizeof(SMsgSendInfo));
+  SMsgSendInfo* sendInfo = taosMemoryMalloc(sizeof(SMsgSendInfo));
   if (sendInfo == NULL) {
     tsem_destroy(&pParam->rspSem);
-    free(pParam);
-    free(req);
+    taosMemoryFree(pParam);
+    taosMemoryFree(req);
     return -1;
   }
 
@@ -967,7 +967,7 @@ SMqPollReq* tmqBuildConsumeReqImpl(tmq_t* tmq, int64_t blockingTime, SMqClientTo
     reqOffset = tmq->resetOffsetCfg;
   }
 
-  SMqPollReq* pReq = malloc(sizeof(SMqPollReq));
+  SMqPollReq* pReq = taosMemoryMalloc(sizeof(SMqPollReq));
   if (pReq == NULL) {
     return NULL;
   }
@@ -1003,7 +1003,7 @@ tmq_message_t* tmqSyncPollImpl(tmq_t* tmq, int64_t blockingTime) {
         return NULL;
       }
 
-      SMqPollCbParam* pParam = malloc(sizeof(SMqPollCbParam));
+      SMqPollCbParam* pParam = taosMemoryMalloc(sizeof(SMqPollCbParam));
       if (pParam == NULL) {
         atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
         // TODO: out of mem
@@ -1016,7 +1016,7 @@ tmq_message_t* tmqSyncPollImpl(tmq_t* tmq, int64_t blockingTime) {
       pParam->msg = &msg;
       tsem_init(&pParam->rspSem, 0, 0);
 
-      SMsgSendInfo* sendInfo = malloc(sizeof(SMsgSendInfo));
+      SMsgSendInfo* sendInfo = taosMemoryMalloc(sizeof(SMsgSendInfo));
       if (sendInfo == NULL) {
         return NULL;
       }
@@ -1071,9 +1071,9 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t blockingTime) {
         tsem_post(&tmq->rspSem);
         return -1;
       }
-      SMqPollCbParam* pParam = malloc(sizeof(SMqPollCbParam));
+      SMqPollCbParam* pParam = taosMemoryMalloc(sizeof(SMqPollCbParam));
       if (pParam == NULL) {
-        free(pReq);
+        taosMemoryFree(pReq);
         atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
         tsem_post(&tmq->rspSem);
         return -1;
@@ -1083,10 +1083,10 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t blockingTime) {
       pParam->epoch = tmq->epoch;
       pParam->sync = 0;
 
-      SMsgSendInfo* sendInfo = malloc(sizeof(SMsgSendInfo));
+      SMsgSendInfo* sendInfo = taosMemoryMalloc(sizeof(SMsgSendInfo));
       if (sendInfo == NULL) {
-        free(pReq);
-        free(pParam);
+        taosMemoryFree(pReq);
+        taosMemoryFree(pParam);
         atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
         tsem_post(&tmq->rspSem);
         return -1;
@@ -1258,7 +1258,7 @@ tmq_message_t* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
       return NULL;
     }
 
-    SMqPollCbParam* param = malloc(sizeof(SMqPollCbParam));
+    SMqPollCbParam* param = taosMemoryMalloc(sizeof(SMqPollCbParam));
     if (param == NULL) {
       ASSERT(false);
       taosMsleep(blocking_time);
@@ -1289,7 +1289,7 @@ tmq_message_t* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
 
     tsem_wait(&param->rspSem);
     tsem_destroy(&param->rspSem);
-    free(param);
+    taosMemoryFree(param);
 
     if (tmq_message == NULL) {
       if (beginVgIdx == pTopic->nextVgIdx) {
@@ -1331,7 +1331,7 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* tmq_topic_v
 
       SRequestObj* pRequest = createRequest(tmq->pTscObj, NULL, NULL, TDMT_VND_CONSUME);
       pRequest->body.requestMsg = (SDataBuf){.pData = pReq, .len = sizeof(SMqConsumeReq)};
-      SMqCommitCbParam* pParam = malloc(sizeof(SMqCommitCbParam));
+      SMqCommitCbParam* pParam = taosMemoryMalloc(sizeof(SMqCommitCbParam));
       if (pParam == NULL) {
         continue;
       }
@@ -1360,7 +1360,7 @@ void tmq_message_destroy(tmq_message_t* tmq_message) {
   if (tmq_message == NULL) return;
   SMqPollRsp* pRsp = &tmq_message->msg;
   tDeleteSMqConsumeRsp(pRsp);
-  /*free(tmq_message);*/
+  /*taosMemoryFree(tmq_message);*/
   taosFreeQitem(tmq_message);
 }
 
@@ -1403,7 +1403,7 @@ char* tmq_get_topic_name(tmq_message_t* message) { return "not implemented yet";
 
 #if 0
 tmq_t* tmqCreateConsumerImpl(TAOS* conn, tmq_conf_t* conf) {
-  tmq_t* pTmq = malloc(sizeof(tmq_t));
+  tmq_t* pTmq = taosMemoryMalloc(sizeof(tmq_t));
   if (pTmq == NULL) {
     return NULL;
   }
@@ -1417,7 +1417,7 @@ tmq_t* tmqCreateConsumerImpl(TAOS* conn, tmq_conf_t* conf) {
 
 static void destroySendMsgInfo(SMsgSendInfo* pMsgBody) {
   assert(pMsgBody != NULL);
-  tfree(pMsgBody->msgInfo.pData);
-  tfree(pMsgBody);
+  taosMemoryFreeClear(pMsgBody->msgInfo.pData);
+  taosMemoryFreeClear(pMsgBody);
 }
 #endif

source/common/src/tdatablock.c

@@ -115,7 +115,7 @@ int32_t colDataAppend(SColumnInfoData* pColumnInfoData, uint32_t currentRow, con
         newSize = newSize * 1.5;
       }
 
-      char* buf = realloc(pColumnInfoData->pData, newSize);
+      char* buf = taosMemoryRealloc(pColumnInfoData->pData, newSize);
       if (buf == NULL) {
         return TSDB_CODE_OUT_OF_MEMORY;
       }
@@ -178,7 +178,7 @@ static void doBitmapMerge(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, c
   uint32_t total = numOfRow1 + numOfRow2;
 
   if (BitmapLen(numOfRow1) < BitmapLen(total)) {
-    char*    tmp = realloc(pColumnInfoData->nullbitmap, BitmapLen(total));
+    char*    tmp = taosMemoryRealloc(pColumnInfoData->nullbitmap, BitmapLen(total));
     uint32_t extend = BitmapLen(total) - BitmapLen(numOfRow1);
     memset(tmp + BitmapLen(numOfRow1), 0, extend);
     pColumnInfoData->nullbitmap = tmp;
@@ -218,7 +218,7 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, co
 
   if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
     // Handle the bitmap
-    char* p = realloc(pColumnInfoData->varmeta.offset, sizeof(int32_t) * (numOfRow1 + numOfRow2));
+    char* p = taosMemoryRealloc(pColumnInfoData->varmeta.offset, sizeof(int32_t) * (numOfRow1 + numOfRow2));
     if (p == NULL) {
       // TODO
     }
@@ -232,7 +232,7 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, co
     uint32_t len = pSource->varmeta.length;
     uint32_t oldLen = pColumnInfoData->varmeta.length;
     if (pColumnInfoData->varmeta.allocLen < len + oldLen) {
-      char* tmp = realloc(pColumnInfoData->pData, len + oldLen);
+      char* tmp = taosMemoryRealloc(pColumnInfoData->pData, len + oldLen);
       if (tmp == NULL) {
         return TSDB_CODE_VND_OUT_OF_MEMORY;
       }
@@ -247,7 +247,7 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, co
     doBitmapMerge(pColumnInfoData, numOfRow1, pSource, numOfRow2);
 
     int32_t newSize = (numOfRow1 + numOfRow2) * pColumnInfoData->info.bytes;
-    char*   tmp = realloc(pColumnInfoData->pData, newSize);
+    char*   tmp = taosMemoryRealloc(pColumnInfoData->pData, newSize);
     if (tmp == NULL) {
       return TSDB_CODE_VND_OUT_OF_MEMORY;
     }
@@ -268,16 +268,16 @@ int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* p
 
   if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
     // Handle the bitmap
-    char* p = realloc(pColumnInfoData->varmeta.offset, sizeof(int32_t) * numOfRows);
+    char* p = taosMemoryRealloc(pColumnInfoData->varmeta.offset, sizeof(int32_t) * numOfRows);
     if (p == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
 
-    pColumnInfoData->varmeta.offset = (int32_t*) p;
+    pColumnInfoData->varmeta.offset = (int32_t*)p;
     memcpy(pColumnInfoData->varmeta.offset, pSource->varmeta.offset, sizeof(int32_t) * numOfRows);
 
     if (pColumnInfoData->varmeta.allocLen < pSource->varmeta.length) {
-      char* tmp = realloc(pColumnInfoData->pData, pSource->varmeta.length);
+      char* tmp = taosMemoryRealloc(pColumnInfoData->pData, pSource->varmeta.length);
       if (tmp == NULL) {
         return TSDB_CODE_OUT_OF_MEMORY;
       }
@@ -289,7 +289,7 @@ int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* p
     memcpy(pColumnInfoData->pData, pSource->pData, pSource->varmeta.length);
     pColumnInfoData->varmeta.length = pSource->varmeta.length;
   } else {
-    char* tmp = realloc(pColumnInfoData->nullbitmap, BitmapLen(numOfRows));
+    char* tmp = taosMemoryRealloc(pColumnInfoData->nullbitmap, BitmapLen(numOfRows));
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -298,7 +298,7 @@ int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* p
     memcpy(pColumnInfoData->nullbitmap, pSource->nullbitmap, BitmapLen(numOfRows));
 
     int32_t newSize = numOfRows * pColumnInfoData->info.bytes;
-    tmp = realloc(pColumnInfoData->pData, newSize);
+    tmp = taosMemoryRealloc(pColumnInfoData->pData, newSize);
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -349,7 +349,7 @@ int32_t blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc) {
     uint32_t newLen = colDataGetLength(pCol1, pSrc->info.rows);
 
     int32_t newSize = oldLen + newLen;
-    char*   tmp = realloc(pCol2->pData, newSize);
+    char*   tmp = taosMemoryRealloc(pCol2->pData, newSize);
     if (tmp != NULL) {
       pCol2->pData = tmp;
       colDataMergeCol(pCol2, pDest->info.rows, pCol1, pSrc->info.rows);
@@ -453,7 +453,7 @@ SSDataBlock* blockDataExtractBlock(SSDataBlock* pBlock, int32_t startIndex, int3
     return NULL;
   }
 
-  SSDataBlock* pDst = calloc(1, sizeof(SSDataBlock));
+  SSDataBlock* pDst = taosMemoryCalloc(1, sizeof(SSDataBlock));
   if (pDst == NULL) {
     return NULL;
   }
@@ -470,10 +470,10 @@ SSDataBlock* blockDataExtractBlock(SSDataBlock* pBlock, int32_t startIndex, int3
 
     if (IS_VAR_DATA_TYPE(pSrcCol->info.type)) {
       SVarColAttr* pAttr = &colInfo.varmeta;
-      pAttr->offset = calloc(rowCount, sizeof(int32_t));
+      pAttr->offset = taosMemoryCalloc(rowCount, sizeof(int32_t));
     } else {
-      colInfo.nullbitmap = calloc(1, BitmapLen(rowCount));
-      colInfo.pData = calloc(rowCount, colInfo.info.bytes);
+      colInfo.nullbitmap = taosMemoryCalloc(1, BitmapLen(rowCount));
+      colInfo.pData = taosMemoryCalloc(rowCount, colInfo.info.bytes);
     }
 
     taosArrayPush(pDst->pDataBlock, &colInfo);
@@ -562,7 +562,7 @@ int32_t blockDataFromBuf(SSDataBlock* pBlock, const char* buf) {
 
     if (IS_VAR_DATA_TYPE(pCol->info.type)) {
       if (pCol->varmeta.allocLen < colLength) {
-        char* tmp = realloc(pCol->pData, colLength);
+        char* tmp = taosMemoryRealloc(pCol->pData, colLength);
         if (tmp == NULL) {
           return TSDB_CODE_OUT_OF_MEMORY;
         }
@@ -587,11 +587,11 @@ size_t blockDataGetRowSize(SSDataBlock* pBlock) {
   if (pBlock->info.rowSize == 0) {
     size_t rowSize = 0;
 
-  size_t numOfCols = pBlock->info.numOfCols;
-  for (int32_t i = 0; i < numOfCols; ++i) {
-    SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);
-    rowSize += pColInfo->info.bytes;
-  }
+    size_t numOfCols = pBlock->info.numOfCols;
+    for (int32_t i = 0; i < numOfCols; ++i) {
+      SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);
+      rowSize += pColInfo->info.bytes;
+    }
 
     pBlock->info.rowSize = rowSize;
   }
@@ -610,7 +610,7 @@ size_t blockDataGetSerialMetaSize(const SSDataBlock* pBlock) {
 }
 
 SSchema* blockDataExtractSchema(const SSDataBlock* pBlock, int32_t* numOfCols) {
-  SSchema* pSchema = calloc(pBlock->info.numOfCols, sizeof(SSchema));
+  SSchema* pSchema = taosMemoryCalloc(pBlock->info.numOfCols, sizeof(SSchema));
   for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
     SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
     pSchema[i].bytes = pColInfoData->info.bytes;
@@ -637,7 +637,7 @@ double blockDataGetSerialRowSize(const SSDataBlock* pBlock) {
     if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {
       rowSize += sizeof(int32_t);
     } else {
-      rowSize += 1/8.0;  // one bit for each record
+      rowSize += 1 / 8.0;  // one bit for each record
     }
   }
 
@@ -819,7 +819,7 @@ static SColumnInfoData* createHelpColInfoData(const SSDataBlock* pDataBlock) {
   int32_t rows = pDataBlock->info.rows;
   int32_t numOfCols = pDataBlock->info.numOfCols;
 
-  SColumnInfoData* pCols = calloc(numOfCols, sizeof(SColumnInfoData));
+  SColumnInfoData* pCols = taosMemoryCalloc(numOfCols, sizeof(SColumnInfoData));
   if (pCols == NULL) {
     return NULL;
   }
@@ -829,14 +829,14 @@ static SColumnInfoData* createHelpColInfoData(const SSDataBlock* pDataBlock) {
     pCols[i].info = pColInfoData->info;
 
     if (IS_VAR_DATA_TYPE(pCols[i].info.type)) {
-      pCols[i].varmeta.offset = calloc(rows, sizeof(int32_t));
-      pCols[i].pData = calloc(1, pColInfoData->varmeta.length);
+      pCols[i].varmeta.offset = taosMemoryCalloc(rows, sizeof(int32_t));
+      pCols[i].pData = taosMemoryCalloc(1, pColInfoData->varmeta.length);
 
       pCols[i].varmeta.length = pColInfoData->varmeta.length;
       pCols[i].varmeta.allocLen = pCols[i].varmeta.length;
     } else {
-      pCols[i].nullbitmap = calloc(1, BitmapLen(rows));
-      pCols[i].pData = calloc(rows, pCols[i].info.bytes);
+      pCols[i].nullbitmap = taosMemoryCalloc(1, BitmapLen(rows));
+      pCols[i].pData = taosMemoryCalloc(rows, pCols[i].info.bytes);
     }
   }
 
@@ -851,22 +851,22 @@ static void copyBackToBlock(SSDataBlock* pDataBlock, SColumnInfoData* pCols) {
     pColInfoData->info = pCols[i].info;
 
     if (IS_VAR_DATA_TYPE(pColInfoData->info.type)) {
-      tfree(pColInfoData->varmeta.offset);
+      taosMemoryFreeClear(pColInfoData->varmeta.offset);
       pColInfoData->varmeta = pCols[i].varmeta;
     } else {
-      tfree(pColInfoData->nullbitmap);
+      taosMemoryFreeClear(pColInfoData->nullbitmap);
       pColInfoData->nullbitmap = pCols[i].nullbitmap;
     }
 
-    tfree(pColInfoData->pData);
+    taosMemoryFreeClear(pColInfoData->pData);
     pColInfoData->pData = pCols[i].pData;
   }
 
-  tfree(pCols);
+  taosMemoryFreeClear(pCols);
 }
 
 static int32_t* createTupleIndex(size_t rows) {
-  int32_t* index = calloc(rows, sizeof(int32_t));
+  int32_t* index = taosMemoryCalloc(rows, sizeof(int32_t));
   if (index == NULL) {
     return NULL;
   }
@@ -878,7 +878,7 @@ static int32_t* createTupleIndex(size_t rows) {
   return index;
 }
 
-static void destroyTupleIndex(int32_t* index) { tfree(index); }
+static void destroyTupleIndex(int32_t* index) { taosMemoryFreeClear(index); }
 
 static __compar_fn_t getComparFn(int32_t type, int32_t order) {
   switch (type) {
@@ -1019,8 +1019,8 @@ SHelper* createTupleIndex_rv(int32_t numOfRows, SArray* pOrderInfo, SSDataBlock*
 
   size_t len = sortValLengthPerRow * pBlock->info.rows;
 
-  char*    buf = calloc(1, len);
-  SHelper* phelper = calloc(numOfRows, sizeof(SHelper));
+  char*    buf = taosMemoryCalloc(1, len);
+  SHelper* phelper = taosMemoryCalloc(numOfRows, sizeof(SHelper));
   for (int32_t i = 0; i < numOfRows; ++i) {
     phelper[i].index = i;
     phelper[i].pData = buf + sortValLengthPerRow * i;
@@ -1163,7 +1163,7 @@ int32_t blockDataEnsureColumnCapacity(SColumnInfoData* pColumn, uint32_t numOfRo
   }
 
   if (IS_VAR_DATA_TYPE(pColumn->info.type)) {
-    char* tmp = realloc(pColumn->varmeta.offset, sizeof(int32_t) * numOfRows);
+    char* tmp = taosMemoryRealloc(pColumn->varmeta.offset, sizeof(int32_t) * numOfRows);
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -1173,9 +1173,9 @@ int32_t blockDataEnsureColumnCapacity(SColumnInfoData* pColumn, uint32_t numOfRo
 
     pColumn->varmeta.length = 0;
     pColumn->varmeta.allocLen = 0;
-    tfree(pColumn->pData);
+    taosMemoryFreeClear(pColumn->pData);
   } else {
-    char* tmp = realloc(pColumn->nullbitmap, BitmapLen(numOfRows));
+    char* tmp = taosMemoryRealloc(pColumn->nullbitmap, BitmapLen(numOfRows));
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -1183,7 +1183,7 @@ int32_t blockDataEnsureColumnCapacity(SColumnInfoData* pColumn, uint32_t numOfRo
     pColumn->nullbitmap = tmp;
     memset(pColumn->nullbitmap, 0, BitmapLen(numOfRows));
     assert(pColumn->info.bytes);
-    tmp = realloc(pColumn->pData, numOfRows * pColumn->info.bytes);
+    tmp = taosMemoryRealloc(pColumn->pData, numOfRows * pColumn->info.bytes);
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
@@ -1214,14 +1214,14 @@ void* blockDataDestroy(SSDataBlock* pBlock) {
   }
 
   blockDestroyInner(pBlock);
-  tfree(pBlock);
+  taosMemoryFreeClear(pBlock);
   return NULL;
 }
 
 SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock) {
   int32_t numOfCols = pDataBlock->info.numOfCols;
 
-  SSDataBlock* pBlock = calloc(1, sizeof(SSDataBlock));
+  SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock));
   pBlock->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
 
   pBlock->info.numOfCols = numOfCols;
@@ -1318,12 +1318,101 @@ int32_t tEncodeDataBlocks(void** buf, const SArray* blocks) {
   return tlen;
 }
 
-void* tDecodeDataBlocks(const void* buf, SArray* blocks) {
+void* tDecodeDataBlocks(const void* buf, SArray** blocks) {
   int32_t sz;
   buf = taosDecodeFixedI32(buf, &sz);
+
+  *blocks = taosArrayInit(sz, sizeof(SSDataBlock));
   for (int32_t i = 0; i < sz; i++) {
     SSDataBlock pBlock = {0};
     buf = tDecodeDataBlock(buf, &pBlock);
+    taosArrayPush(*blocks, &pBlock);
   }
   return (void*)buf;
 }
+
+static char* formatTimestamp(char* buf, int64_t val, int precision) {
+  time_t  tt;
+  int32_t ms = 0;
+  if (precision == TSDB_TIME_PRECISION_NANO) {
+    tt = (time_t)(val / 1000000000);
+    ms = val % 1000000000;
+  } else if (precision == TSDB_TIME_PRECISION_MICRO) {
+    tt = (time_t)(val / 1000000);
+    ms = val % 1000000;
+  } else {
+    tt = (time_t)(val / 1000);
+    ms = val % 1000;
+  }
+
+  /* comment out as it make testcases like select_with_tags.sim fail.
+    but in windows, this may cause the call to localtime crash if tt < 0,
+    need to find a better solution.
+    if (tt < 0) {
+      tt = 0;
+    }
+    */
+
+#ifdef WINDOWS
+  if (tt < 0) tt = 0;
+#endif
+  if (tt <= 0 && ms < 0) {
+    tt--;
+    if (precision == TSDB_TIME_PRECISION_NANO) {
+      ms += 1000000000;
+    } else if (precision == TSDB_TIME_PRECISION_MICRO) {
+      ms += 1000000;
+    } else {
+      ms += 1000;
+    }
+  }
+
+  struct tm* ptm = localtime(&tt);
+  size_t     pos = strftime(buf, 35, "%Y-%m-%d %H:%M:%S", ptm);
+
+  if (precision == TSDB_TIME_PRECISION_NANO) {
+    sprintf(buf + pos, ".%09d", ms);
+  } else if (precision == TSDB_TIME_PRECISION_MICRO) {
+    sprintf(buf + pos, ".%06d", ms);
+  } else {
+    sprintf(buf + pos, ".%03d", ms);
+  }
+
+  return buf;
+}
+void blockDebugShowData(const SArray* dataBlocks) {
+  char    pBuf[128];
+  int32_t sz = taosArrayGetSize(dataBlocks);
+  for (int32_t i = 0; i < sz; i++) {
+    SSDataBlock* pDataBlock = taosArrayGet(dataBlocks, i);
+    int32_t      colNum = pDataBlock->info.numOfCols;
+    int32_t      rows = pDataBlock->info.rows;
+    for (int32_t j = 0; j < rows; j++) {
+      printf("|");
+      for (int32_t k = 0; k < colNum; k++) {
+        SColumnInfoData* pColInfoData = taosArrayGet(pDataBlock->pDataBlock, k);
+        void*            var = POINTER_SHIFT(pColInfoData->pData, j * pColInfoData->info.bytes);
+        switch (pColInfoData->info.type) {
+          case TSDB_DATA_TYPE_TIMESTAMP:
+            formatTimestamp(pBuf, *(uint64_t*)var, TSDB_TIME_PRECISION_MILLI);
+            printf(" %25s |", pBuf);
+            break;
+          case TSDB_DATA_TYPE_INT:
+            printf(" %15d |", *(int32_t*)var);
+            break;
+          case TSDB_DATA_TYPE_UINT:
+            printf(" %15u |", *(uint32_t*)var);
+            break;
+          case TSDB_DATA_TYPE_BIGINT:
+            printf(" %15ld |", *(int64_t*)var);
+            break;
+          case TSDB_DATA_TYPE_UBIGINT:
+            printf(" %15lu |", *(uint64_t*)var);
+            break;
+        }
+      }
+      printf("\n");
+    }
+  }
+}
+

source/common/src/tdataformat.c

@@ -37,7 +37,7 @@ int tdAllocMemForCol(SDataCol *pCol, int maxPoints) {
 #endif
 
   if (pCol->spaceSize < spaceNeeded) {
-    void *ptr = realloc(pCol->pData, spaceNeeded);
+    void *ptr = taosMemoryRealloc(pCol->pData, spaceNeeded);
     if (ptr == NULL) {
       uDebug("malloc failure, size:%" PRId64 " failed, reason:%s", (int64_t)spaceNeeded, strerror(errno));
       return -1;
@@ -66,7 +66,7 @@ int tdAllocMemForCol(SDataCol *pCol, int maxPoints) {
  */
 STSchema *tdDupSchema(const STSchema *pSchema) {
   int       tlen = sizeof(STSchema) + sizeof(STColumn) * schemaNCols(pSchema);
-  STSchema *tSchema = (STSchema *)malloc(tlen);
+  STSchema *tSchema = (STSchema *)taosMemoryMalloc(tlen);
   if (tSchema == NULL) return NULL;
 
   memcpy((void *)tSchema, (void *)pSchema, tlen);
@@ -127,7 +127,7 @@ int tdInitTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version) {
   if (pBuilder == NULL) return -1;
 
   pBuilder->tCols = 256;
-  pBuilder->columns = (STColumn *)malloc(sizeof(STColumn) * pBuilder->tCols);
+  pBuilder->columns = (STColumn *)taosMemoryMalloc(sizeof(STColumn) * pBuilder->tCols);
   if (pBuilder->columns == NULL) return -1;
 
   tdResetTSchemaBuilder(pBuilder, version);
@@ -136,7 +136,7 @@ int tdInitTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version) {
 
 void tdDestroyTSchemaBuilder(STSchemaBuilder *pBuilder) {
   if (pBuilder) {
-    tfree(pBuilder->columns);
+    taosMemoryFreeClear(pBuilder->columns);
   }
 }
 
@@ -153,7 +153,7 @@ int tdAddColToSchema(STSchemaBuilder *pBuilder, int8_t type, int16_t colId, int1
 
   if (pBuilder->nCols >= pBuilder->tCols) {
     pBuilder->tCols *= 2;
-    STColumn *columns = (STColumn *)realloc(pBuilder->columns, sizeof(STColumn) * pBuilder->tCols);
+    STColumn *columns = (STColumn *)taosMemoryRealloc(pBuilder->columns, sizeof(STColumn) * pBuilder->tCols);
     if (columns == NULL) return -1;
     pBuilder->columns = columns;
   }
@@ -191,7 +191,7 @@ STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder) {
 
   int tlen = sizeof(STSchema) + sizeof(STColumn) * pBuilder->nCols;
 
-  STSchema *pSchema = (STSchema *)malloc(tlen);
+  STSchema *pSchema = (STSchema *)taosMemoryMalloc(tlen);
   if (pSchema == NULL) return NULL;
 
   schemaVersion(pSchema) = pBuilder->version;
@@ -221,7 +221,7 @@ void tdInitDataRow(SDataRow row, STSchema *pSchema) {
 SDataRow tdNewDataRowFromSchema(STSchema *pSchema) {
   int32_t size = dataRowMaxBytesFromSchema(pSchema);
 
-  SDataRow row = malloc(size);
+  SDataRow row = taosMemoryMalloc(size);
   if (row == NULL) return NULL;
 
   tdInitDataRow(row, pSchema);
@@ -232,11 +232,11 @@ SDataRow tdNewDataRowFromSchema(STSchema *pSchema) {
  * Free the SDataRow object
  */
 void tdFreeDataRow(SDataRow row) {
-  if (row) free(row);
+  if (row) taosMemoryFree(row);
 }
 
 SDataRow tdDataRowDup(SDataRow row) {
-  SDataRow trow = malloc(dataRowLen(row));
+  SDataRow trow = taosMemoryMalloc(dataRowLen(row));
   if (trow == NULL) return NULL;
 
   dataRowCpy(trow, row);
@@ -244,7 +244,7 @@ SDataRow tdDataRowDup(SDataRow row) {
 }
 
 SMemRow tdMemRowDup(SMemRow row) {
-  SMemRow trow = malloc(memRowTLen(row));
+  SMemRow trow = taosMemoryMalloc(memRowTLen(row));
   if (trow == NULL) return NULL;
 
   memRowCpy(trow, row);
@@ -348,7 +348,7 @@ void *dataColSetOffset(SDataCol *pCol, int nEle) {
 }
 
 SDataCols *tdNewDataCols(int maxCols, int maxRows) {
-  SDataCols *pCols = (SDataCols *)calloc(1, sizeof(SDataCols));
+  SDataCols *pCols = (SDataCols *)taosMemoryCalloc(1, sizeof(SDataCols));
   if (pCols == NULL) {
     uDebug("malloc failure, size:%" PRId64 " failed, reason:%s", (int64_t)sizeof(SDataCols), strerror(errno));
     return NULL;
@@ -360,7 +360,7 @@ SDataCols *tdNewDataCols(int maxCols, int maxRows) {
   pCols->numOfCols = 0;
 
   if (maxCols > 0) {
-    pCols->cols = (SDataCol *)calloc(maxCols, sizeof(SDataCol));
+    pCols->cols = (SDataCol *)taosMemoryCalloc(maxCols, sizeof(SDataCol));
     if (pCols->cols == NULL) {
       uDebug("malloc failure, size:%" PRId64 " failed, reason:%s", (int64_t)sizeof(SDataCol) * maxCols,
              strerror(errno));
@@ -384,7 +384,7 @@ int tdInitDataCols(SDataCols *pCols, STSchema *pSchema) {
   int oldMaxCols = pCols->maxCols;
   if (schemaNCols(pSchema) > oldMaxCols) {
     pCols->maxCols = schemaNCols(pSchema);
-    void *ptr = (SDataCol *)realloc(pCols->cols, sizeof(SDataCol) * pCols->maxCols);
+    void *ptr = (SDataCol *)taosMemoryRealloc(pCols->cols, sizeof(SDataCol) * pCols->maxCols);
     if (ptr == NULL) return -1;
     pCols->cols = ptr;
     for (i = oldMaxCols; i < pCols->maxCols; i++) {
@@ -411,12 +411,12 @@ SDataCols *tdFreeDataCols(SDataCols *pCols) {
       int maxCols = pCols->maxCols;
       for (i = 0; i < maxCols; i++) {
         SDataCol *pCol = &pCols->cols[i];
-        tfree(pCol->pData);
+        taosMemoryFreeClear(pCol->pData);
       }
-      free(pCols->cols);
+      taosMemoryFree(pCols->cols);
       pCols->cols = NULL;
     }
-    free(pCols);
+    taosMemoryFree(pCols);
   }
   return NULL;
 }
@@ -641,7 +641,7 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
 #endif
 
 SKVRow tdKVRowDup(SKVRow row) {
-  SKVRow trow = malloc(kvRowLen(row));
+  SKVRow trow = taosMemoryMalloc(kvRowLen(row));
   if (trow == NULL) return NULL;
 
   kvRowCpy(trow, row);
@@ -674,7 +674,7 @@ int tdSetKVRowDataOfCol(SKVRow *orow, int16_t colId, int8_t type, void *value) {
     int oRowCols = kvRowNCols(row);
 
     ASSERT(diff > 0);
-    nrow = malloc(nRowLen);
+    nrow = taosMemoryMalloc(nRowLen);
     if (nrow == NULL) return -1;
 
     kvRowSetLen(nrow, nRowLen);
@@ -692,7 +692,7 @@ int tdSetKVRowDataOfCol(SKVRow *orow, int16_t colId, int8_t type, void *value) {
     tdSortKVRowByColIdx(nrow);
 
     *orow = nrow;
-    free(row);
+    taosMemoryFree(row);
   } else {
     ASSERT(((SColIdx *)ptr)->colId == colId);
     if (IS_VAR_DATA_TYPE(type)) {
@@ -703,7 +703,7 @@ int tdSetKVRowDataOfCol(SKVRow *orow, int16_t colId, int8_t type, void *value) {
       } else {  // need to reallocate the memory
         int16_t nlen = kvRowLen(row) + (varDataTLen(value) - varDataTLen(pOldVal));
         ASSERT(nlen > 0);
-        nrow = malloc(nlen);
+        nrow = taosMemoryMalloc(nlen);
         if (nrow == NULL) return -1;
 
         kvRowSetLen(nrow, nlen);
@@ -728,7 +728,7 @@ int tdSetKVRowDataOfCol(SKVRow *orow, int16_t colId, int8_t type, void *value) {
         }
 
         *orow = nrow;
-        free(row);
+        taosMemoryFree(row);
       }
     } else {
       memcpy(kvRowColVal(row, (SColIdx *)ptr), value, TYPE_BYTES[type]);
@@ -757,21 +757,21 @@ void *tdDecodeKVRow(void *buf, SKVRow *row) {
 int tdInitKVRowBuilder(SKVRowBuilder *pBuilder) {
   pBuilder->tCols = 128;
   pBuilder->nCols = 0;
-  pBuilder->pColIdx = (SColIdx *)malloc(sizeof(SColIdx) * pBuilder->tCols);
+  pBuilder->pColIdx = (SColIdx *)taosMemoryMalloc(sizeof(SColIdx) * pBuilder->tCols);
   if (pBuilder->pColIdx == NULL) return -1;
   pBuilder->alloc = 1024;
   pBuilder->size = 0;
-  pBuilder->buf = malloc(pBuilder->alloc);
+  pBuilder->buf = taosMemoryMalloc(pBuilder->alloc);
   if (pBuilder->buf == NULL) {
-    free(pBuilder->pColIdx);
+    taosMemoryFree(pBuilder->pColIdx);
     return -1;
   }
   return 0;
 }
 
 void tdDestroyKVRowBuilder(SKVRowBuilder *pBuilder) {
-  tfree(pBuilder->pColIdx);
-  tfree(pBuilder->buf);
+  taosMemoryFreeClear(pBuilder->pColIdx);
+  taosMemoryFreeClear(pBuilder->buf);
 }
 
 void tdResetKVRowBuilder(SKVRowBuilder *pBuilder) {
@@ -785,7 +785,7 @@ SKVRow tdGetKVRowFromBuilder(SKVRowBuilder *pBuilder) {
 
   tlen += TD_KV_ROW_HEAD_SIZE;
 
-  SKVRow row = malloc(tlen);
+  SKVRow row = taosMemoryMalloc(tlen);
   if (row == NULL) return NULL;
 
   kvRowSetNCols(row, pBuilder->nCols);

source/common/src/tglobal.c

@@ -122,7 +122,7 @@ bool tsRetrieveBlockingModel = 0;
 // last_row(*), first(*), last_row(ts, col1, col2) query, the result fields will be the original column name
 bool tsKeepOriginalColumnName = 0;
 
-// long query death-lock
+// kill long query
 bool tsDeadLockKillQuery = 0;
 
 // tsdb config

source/common/src/tmsg.c

@@ -371,7 +371,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
     case TD_SUPER_TABLE:
       buf = taosDecodeFixedI64(buf, &(pReq->stbCfg.suid));
       buf = taosDecodeFixedU32(buf, &(pReq->stbCfg.nCols));
-      pReq->stbCfg.pSchema = (SSchema *)malloc(pReq->stbCfg.nCols * sizeof(SSchema));
+      pReq->stbCfg.pSchema = (SSchema *)taosMemoryMalloc(pReq->stbCfg.nCols * sizeof(SSchema));
       for (uint32_t i = 0; i < pReq->stbCfg.nCols; i++) {
         buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pSchema[i].type));
         buf = taosDecodeFixedI32(buf, &(pReq->stbCfg.pSchema[i].colId));
@@ -379,7 +379,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
         buf = taosDecodeStringTo(buf, pReq->stbCfg.pSchema[i].name);
       }
       buf = taosDecodeFixedU32(buf, &pReq->stbCfg.nTagCols);
-      pReq->stbCfg.pTagSchema = (SSchema *)malloc(pReq->stbCfg.nTagCols * sizeof(SSchema));
+      pReq->stbCfg.pTagSchema = (SSchema *)taosMemoryMalloc(pReq->stbCfg.nTagCols * sizeof(SSchema));
       for (uint32_t i = 0; i < pReq->stbCfg.nTagCols; i++) {
         buf = taosDecodeFixedI8(buf, &(pReq->stbCfg.pTagSchema[i].type));
         buf = taosDecodeFixedI32(buf, &pReq->stbCfg.pTagSchema[i].colId);
@@ -388,7 +388,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
       }
       buf = taosDecodeFixedI16(buf, &(pReq->stbCfg.nBSmaCols));
       if (pReq->stbCfg.nBSmaCols > 0) {
-        pReq->stbCfg.pBSmaCols = (col_id_t *)malloc(pReq->stbCfg.nBSmaCols * sizeof(col_id_t));
+        pReq->stbCfg.pBSmaCols = (col_id_t *)taosMemoryMalloc(pReq->stbCfg.nBSmaCols * sizeof(col_id_t));
         for (col_id_t i = 0; i < pReq->stbCfg.nBSmaCols; ++i) {
           buf = taosDecodeFixedI16(buf, pReq->stbCfg.pBSmaCols + i);
         }
@@ -396,7 +396,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
         pReq->stbCfg.pBSmaCols = NULL;
       }
       if (pReq->rollup) {
-        pReq->stbCfg.pRSmaParam = (SRSmaParam *)malloc(sizeof(SRSmaParam));
+        pReq->stbCfg.pRSmaParam = (SRSmaParam *)taosMemoryMalloc(sizeof(SRSmaParam));
         SRSmaParam *param = pReq->stbCfg.pRSmaParam;
         buf = taosDecodeFixedU32(buf, (uint32_t *)&param->xFilesFactor);
         buf = taosDecodeFixedI8(buf, &param->delayUnit);
@@ -419,7 +419,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
       break;
     case TD_NORMAL_TABLE:
       buf = taosDecodeFixedU32(buf, &pReq->ntbCfg.nCols);
-      pReq->ntbCfg.pSchema = (SSchema *)malloc(pReq->ntbCfg.nCols * sizeof(SSchema));
+      pReq->ntbCfg.pSchema = (SSchema *)taosMemoryMalloc(pReq->ntbCfg.nCols * sizeof(SSchema));
       for (uint32_t i = 0; i < pReq->ntbCfg.nCols; i++) {
         buf = taosDecodeFixedI8(buf, &pReq->ntbCfg.pSchema[i].type);
         buf = taosDecodeFixedI32(buf, &pReq->ntbCfg.pSchema[i].colId);
@@ -428,7 +428,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
       }
       buf = taosDecodeFixedI16(buf, &(pReq->ntbCfg.nBSmaCols));
       if (pReq->ntbCfg.nBSmaCols > 0) {
-        pReq->ntbCfg.pBSmaCols = (col_id_t *)malloc(pReq->ntbCfg.nBSmaCols * sizeof(col_id_t));
+        pReq->ntbCfg.pBSmaCols = (col_id_t *)taosMemoryMalloc(pReq->ntbCfg.nBSmaCols * sizeof(col_id_t));
         for (col_id_t i = 0; i < pReq->ntbCfg.nBSmaCols; ++i) {
           buf = taosDecodeFixedI16(buf, pReq->ntbCfg.pBSmaCols + i);
         }
@@ -436,7 +436,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
         pReq->ntbCfg.pBSmaCols = NULL;
       }
       if (pReq->rollup) {
-        pReq->ntbCfg.pRSmaParam = (SRSmaParam *)malloc(sizeof(SRSmaParam));
+        pReq->ntbCfg.pRSmaParam = (SRSmaParam *)taosMemoryMalloc(sizeof(SRSmaParam));
         SRSmaParam *param = pReq->ntbCfg.pRSmaParam;
         buf = taosDecodeFixedU32(buf, (uint32_t *)&param->xFilesFactor);
         buf = taosDecodeFixedI8(buf, &param->delayUnit);
@@ -608,7 +608,7 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
   }
 
   if (pReq->commentLen > 0) {
-    pReq->comment = malloc(pReq->commentLen);
+    pReq->comment = taosMemoryMalloc(pReq->commentLen);
     if (pReq->comment == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->comment) < 0) return -1;
   }
@@ -623,7 +623,7 @@ void tFreeSMCreateStbReq(SMCreateStbReq *pReq) {
   taosArrayDestroy(pReq->pColumns);
   taosArrayDestroy(pReq->pTags);
   taosArrayDestroy(pReq->pSmas);
-  tfree(pReq->comment);
+  taosMemoryFreeClear(pReq->comment);
   pReq->pColumns = NULL;
   pReq->pTags = NULL;
   pReq->pSmas = NULL;
@@ -770,22 +770,22 @@ int32_t tDeserializeSMCreateSmaReq(void *buf, int32_t bufLen, SMCreateSmaReq *pR
   if (tDecodeI32(&decoder, &pReq->sqlLen) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->astLen) < 0) return -1;
   if (pReq->exprLen > 0) {
-    pReq->expr = malloc(pReq->exprLen);
+    pReq->expr = taosMemoryMalloc(pReq->exprLen);
     if (pReq->expr == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->expr) < 0) return -1;
   }
   if (pReq->tagsFilterLen > 0) {
-    pReq->tagsFilter = malloc(pReq->tagsFilterLen);
+    pReq->tagsFilter = taosMemoryMalloc(pReq->tagsFilterLen);
     if (pReq->tagsFilter == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->tagsFilter) < 0) return -1;
   }
   if (pReq->sqlLen > 0) {
-    pReq->sql = malloc(pReq->sqlLen);
+    pReq->sql = taosMemoryMalloc(pReq->sqlLen);
     if (pReq->sql == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
   }
   if (pReq->astLen > 0) {
-    pReq->ast = malloc(pReq->astLen);
+    pReq->ast = taosMemoryMalloc(pReq->astLen);
     if (pReq->ast == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
   }
@@ -796,10 +796,10 @@ int32_t tDeserializeSMCreateSmaReq(void *buf, int32_t bufLen, SMCreateSmaReq *pR
 }
 
 void tFreeSMCreateSmaReq(SMCreateSmaReq *pReq) {
-  tfree(pReq->expr);
-  tfree(pReq->tagsFilter);
-  tfree(pReq->sql);
-  tfree(pReq->ast);
+  taosMemoryFreeClear(pReq->expr);
+  taosMemoryFreeClear(pReq->tagsFilter);
+  taosMemoryFreeClear(pReq->sql);
+  taosMemoryFreeClear(pReq->ast);
 }
 
 int32_t tSerializeSMDropSmaReq(void *buf, int32_t bufLen, SMDropSmaReq *pReq) {
@@ -1987,7 +1987,7 @@ int32_t tDeserializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->payloadLen) < 0) return -1;
   if (pReq->payloadLen > 0) {
-    pReq->payload = malloc(pReq->payloadLen);
+    pReq->payload = taosMemoryMalloc(pReq->payloadLen);
     if (pReq->payload == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->payload) < 0) return -1;
   }
@@ -1997,7 +1997,7 @@ int32_t tDeserializeSShowReq(void *buf, int32_t bufLen, SShowReq *pReq) {
   return 0;
 }
 
-void tFreeSShowReq(SShowReq *pReq) { tfree(pReq->payload); }
+void tFreeSShowReq(SShowReq *pReq) { taosMemoryFreeClear(pReq->payload); }
 
 int32_t tSerializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq *pReq) {
   SCoder encoder = {0};
@@ -2071,7 +2071,7 @@ static int32_t tDecodeSTableMetaRsp(SCoder *pDecoder, STableMetaRsp *pRsp) {
   if (tDecodeI32(pDecoder, &pRsp->vgId) < 0) return -1;
 
   int32_t totalCols = pRsp->numOfTags + pRsp->numOfColumns;
-  pRsp->pSchemas = malloc(sizeof(SSchema) * totalCols);
+  pRsp->pSchemas = taosMemoryMalloc(sizeof(SSchema) * totalCols);
   if (pRsp->pSchemas == NULL) return -1;
 
   for (int32_t i = 0; i < totalCols; ++i) {
@@ -2152,7 +2152,7 @@ int32_t tDeserializeSTableMetaBatchRsp(void *buf, int32_t bufLen, STableMetaBatc
   return 0;
 }
 
-void tFreeSTableMetaRsp(STableMetaRsp *pRsp) { tfree(pRsp->pSchemas); }
+void tFreeSTableMetaRsp(STableMetaRsp *pRsp) { taosMemoryFreeClear(pRsp->pSchemas); }
 
 void tFreeSTableMetaBatchRsp(STableMetaBatchRsp *pRsp) {
   int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
@@ -2304,13 +2304,13 @@ int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicR
   if (tDecodeI32(&decoder, &astLen) < 0) return -1;
 
   if (sqlLen > 0) {
-    pReq->sql = calloc(1, sqlLen + 1);
+    pReq->sql = taosMemoryCalloc(1, sqlLen + 1);
     if (pReq->sql == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
   }
 
   if (astLen > 0) {
-    pReq->ast = calloc(1, astLen + 1);
+    pReq->ast = taosMemoryCalloc(1, astLen + 1);
     if (pReq->ast == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
   }
@@ -2322,8 +2322,8 @@ int32_t tDeserializeSCMCreateTopicReq(void *buf, int32_t bufLen, SCMCreateTopicR
 }
 
 void tFreeSCMCreateTopicReq(SCMCreateTopicReq *pReq) {
-  tfree(pReq->sql);
-  tfree(pReq->ast);
+  taosMemoryFreeClear(pReq->sql);
+  taosMemoryFreeClear(pReq->ast);
 }
 
 int32_t tSerializeSCMCreateTopicRsp(void *buf, int32_t bufLen, const SCMCreateTopicRsp *pRsp) {
@@ -2871,7 +2871,6 @@ int32_t tSerializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *pR
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
 
   if (tStartEncode(&encoder) < 0) return -1;
-  if (tEncodeU64(&encoder, pRsp->seqId) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->epId.nodeId) < 0) return -1;
   if (tEncodeU16(&encoder, pRsp->epId.ep.port) < 0) return -1;
   if (tEncodeCStr(&encoder, pRsp->epId.ep.fqdn) < 0) return -1;
@@ -2900,7 +2899,6 @@ int32_t tDeserializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *
   tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
 
   if (tStartDecode(&decoder) < 0) return -1;
-  if (tDecodeU64(&decoder, &pRsp->seqId) < 0) return -1;
   if (tDecodeI32(&decoder, &pRsp->epId.nodeId) < 0) return -1;
   if (tDecodeU16(&decoder, &pRsp->epId.ep.port) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pRsp->epId.ep.fqdn) < 0) return -1;
@@ -3074,13 +3072,13 @@ int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStrea
   if (tDecodeI32(&decoder, &astLen) < 0) return -1;
 
   if (sqlLen > 0) {
-    pReq->sql = calloc(1, sqlLen + 1);
+    pReq->sql = taosMemoryCalloc(1, sqlLen + 1);
     if (pReq->sql == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->sql) < 0) return -1;
   }
 
   if (astLen > 0) {
-    pReq->ast = calloc(1, astLen + 1);
+    pReq->ast = taosMemoryCalloc(1, astLen + 1);
     if (pReq->ast == NULL) return -1;
     if (tDecodeCStrTo(&decoder, pReq->ast) < 0) return -1;
   }
@@ -3091,51 +3089,6 @@ int32_t tDeserializeSCMCreateStreamReq(void *buf, int32_t bufLen, SCMCreateStrea
 }
 
 void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {
-  tfree(pReq->sql);
-  tfree(pReq->ast);
-}
-
-int32_t tEncodeSStreamTask(SCoder *pEncoder, const SStreamTask *pTask) {
-  /*if (tStartEncode(pEncoder) < 0) return -1;*/
-  if (tEncodeI64(pEncoder, pTask->streamId) < 0) return -1;
-  if (tEncodeI32(pEncoder, pTask->taskId) < 0) return -1;
-  if (tEncodeI32(pEncoder, pTask->level) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->status) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->parallelizable) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->nextOpDst) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->sourceType) < 0) return -1;
-  if (tEncodeI8(pEncoder, pTask->sinkType) < 0) return -1;
-  if (pTask->sinkType == STREAM_SINK_TYPE__ASSIGNED) {
-    if (tEncodeI32(pEncoder, pTask->sinkVgId) < 0) return -1;
-    if (tEncodeSEpSet(pEncoder, &pTask->NextOpEp) < 0) return -1;
-  }
-  if (tEncodeCStr(pEncoder, pTask->qmsg) < 0) return -1;
-  /*tEndEncode(pEncoder);*/
-  return pEncoder->pos;
-}
-
-int32_t tDecodeSStreamTask(SCoder *pDecoder, SStreamTask *pTask) {
-  /*if (tStartDecode(pDecoder) < 0) return -1;*/
-  if (tDecodeI64(pDecoder, &pTask->streamId) < 0) return -1;
-  if (tDecodeI32(pDecoder, &pTask->taskId) < 0) return -1;
-  if (tDecodeI32(pDecoder, &pTask->level) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->status) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->parallelizable) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->nextOpDst) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->sourceType) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pTask->sinkType) < 0) return -1;
-  if (pTask->sinkType == STREAM_SINK_TYPE__ASSIGNED) {
-    if (tDecodeI32(pDecoder, &pTask->sinkVgId) < 0) return -1;
-    if (tDecodeSEpSet(pDecoder, &pTask->NextOpEp) < 0) return -1;
-  }
-  if (tDecodeCStrAlloc(pDecoder, &pTask->qmsg) < 0) return -1;
-  /*tEndDecode(pDecoder);*/
-  return 0;
-}
-
-void tFreeSStreamTask(SStreamTask *pTask) {
-  // TODO
-  /*free(pTask->qmsg);*/
-  /*free(pTask->executor);*/
-  /*free(pTask);*/
+  taosMemoryFreeClear(pReq->sql);
+  taosMemoryFreeClear(pReq->ast);
 }

source/common/src/tname.c

@@ -30,13 +30,13 @@ SColumnFilterInfo* tFilterInfoDup(const SColumnFilterInfo* src, int32_t numOfFil
     return NULL;
   }
 
-  SColumnFilterInfo* pFilter = calloc(1, numOfFilters * sizeof(SColumnFilterInfo));
+  SColumnFilterInfo* pFilter = taosMemoryCalloc(1, numOfFilters * sizeof(SColumnFilterInfo));
 
   memcpy(pFilter, src, sizeof(SColumnFilterInfo) * numOfFilters);
   for (int32_t j = 0; j < numOfFilters; ++j) {
     if (pFilter[j].filterstr) {
       size_t len = (size_t) pFilter[j].len + 1 * TSDB_NCHAR_SIZE;
-      pFilter[j].pz = (int64_t) calloc(1, len);
+      pFilter[j].pz = (int64_t) taosMemoryCalloc(1, len);
 
       memcpy((char*)pFilter[j].pz, (char*)src[j].pz, (size_t) pFilter[j].len);
     }
@@ -171,7 +171,7 @@ bool tNameIsValid(const SName* name) {
 SName* tNameDup(const SName* name) {
   assert(name != NULL);
 
-  SName* p = malloc(sizeof(SName));
+  SName* p = taosMemoryMalloc(sizeof(SName));
   memcpy(p, name, sizeof(SName));
   return p;
 }

source/common/src/trow.c

@@ -119,7 +119,7 @@ int trbWriteCol(SRowBuilder *pRB, void *pData, col_id_t cid) {
 #endif
 
 STSRow *tdRowDup(STSRow *row) {
-  STSRow *trow = malloc(TD_ROW_LEN(row));
+  STSRow *trow = taosMemoryMalloc(TD_ROW_LEN(row));
   if (trow == NULL) return NULL;
 
   tdRowCpy(trow, row);

source/common/src/ttszip.c

@@ -30,7 +30,7 @@ static int32_t STSBufUpdateHeader(STSBuf* pTSBuf, STSBufFileHeader* pHeader);
  * @return
  */
 STSBuf* tsBufCreate(bool autoDelete, int32_t order) {
-  STSBuf* pTSBuf = calloc(1, sizeof(STSBuf));
+  STSBuf* pTSBuf = taosMemoryCalloc(1, sizeof(STSBuf));
   if (pTSBuf == NULL) {
     return NULL;
   }
@@ -41,7 +41,7 @@ STSBuf* tsBufCreate(bool autoDelete, int32_t order) {
   // pTSBuf->pFile = fopen(pTSBuf->path, "wb+");
   pTSBuf->pFile = taosOpenFile(pTSBuf->path, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_READ | TD_FILE_TRUNC);
   if (pTSBuf->pFile == NULL) {
-    free(pTSBuf);
+    taosMemoryFree(pTSBuf);
     return NULL;
   }
 
@@ -66,7 +66,7 @@ STSBuf* tsBufCreate(bool autoDelete, int32_t order) {
 }
 
 STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
-  STSBuf* pTSBuf = calloc(1, sizeof(STSBuf));
+  STSBuf* pTSBuf = taosMemoryCalloc(1, sizeof(STSBuf));
   if (pTSBuf == NULL) {
     return NULL;
   }
@@ -78,7 +78,7 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
   // pTSBuf->pFile = fopen(pTSBuf->path, "rb+");
   pTSBuf->pFile = taosOpenFile(pTSBuf->path, TD_FILE_WRITE | TD_FILE_READ);
   if (pTSBuf->pFile == NULL) {
-    free(pTSBuf);
+    taosMemoryFree(pTSBuf);
     return NULL;
   }
 
@@ -101,7 +101,7 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
 
   if (header.numOfGroup > pTSBuf->numOfAlloc) {
     pTSBuf->numOfAlloc = header.numOfGroup;
-    STSGroupBlockInfoEx* tmp = realloc(pTSBuf->pData, sizeof(STSGroupBlockInfoEx) * pTSBuf->numOfAlloc);
+    STSGroupBlockInfoEx* tmp = taosMemoryRealloc(pTSBuf->pData, sizeof(STSGroupBlockInfoEx) * pTSBuf->numOfAlloc);
     if (tmp == NULL) {
       tsBufDestroy(pTSBuf);
       return NULL;
@@ -122,7 +122,7 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
 
   size_t infoSize = sizeof(STSGroupBlockInfo) * pTSBuf->numOfGroups;
 
-  STSGroupBlockInfo* buf = (STSGroupBlockInfo*)calloc(1, infoSize);
+  STSGroupBlockInfo* buf = (STSGroupBlockInfo*)taosMemoryCalloc(1, infoSize);
   if (buf == NULL) {
     tsBufDestroy(pTSBuf);
     return NULL;
@@ -137,7 +137,7 @@ STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete) {
     STSGroupBlockInfoEx* pBlockList = &pTSBuf->pData[i];
     memcpy(&pBlockList->info, &buf[i], sizeof(STSGroupBlockInfo));
   }
-  free(buf);
+  taosMemoryFree(buf);
 
   ret = taosLSeekFile(pTSBuf->pFile, 0, SEEK_END);
   UNUSED(ret);
@@ -166,11 +166,11 @@ void* tsBufDestroy(STSBuf* pTSBuf) {
     return NULL;
   }
 
-  tfree(pTSBuf->assistBuf);
-  tfree(pTSBuf->tsData.rawBuf);
+  taosMemoryFreeClear(pTSBuf->assistBuf);
+  taosMemoryFreeClear(pTSBuf->tsData.rawBuf);
 
-  tfree(pTSBuf->pData);
-  tfree(pTSBuf->block.payload);
+  taosMemoryFreeClear(pTSBuf->pData);
+  taosMemoryFreeClear(pTSBuf->block.payload);
 
   if (!pTSBuf->remainOpen) {
     taosCloseFile(&pTSBuf->pFile);
@@ -184,7 +184,7 @@ void* tsBufDestroy(STSBuf* pTSBuf) {
   }
 
   taosVariantDestroy(&pTSBuf->block.tag);
-  free(pTSBuf);
+  taosMemoryFree(pTSBuf);
   return NULL;
 }
 
@@ -200,7 +200,7 @@ static STSGroupBlockInfoEx* addOneGroupInfo(STSBuf* pTSBuf, int32_t id) {
     uint32_t newSize = (uint32_t)(pTSBuf->numOfAlloc * 1.5);
     assert((int32_t)newSize > pTSBuf->numOfAlloc);
 
-    STSGroupBlockInfoEx* tmp = (STSGroupBlockInfoEx*)realloc(pTSBuf->pData, sizeof(STSGroupBlockInfoEx) * newSize);
+    STSGroupBlockInfoEx* tmp = (STSGroupBlockInfoEx*)taosMemoryRealloc(pTSBuf->pData, sizeof(STSGroupBlockInfoEx) * newSize);
     if (tmp == NULL) {
       return NULL;
     }
@@ -240,7 +240,7 @@ static STSGroupBlockInfoEx* addOneGroupInfo(STSBuf* pTSBuf, int32_t id) {
 static void shrinkBuffer(STSList* ptsData) {
   // shrink tmp buffer size if it consumes too many memory compared to the pre-defined size
   if (ptsData->allocSize >= ptsData->threshold * 2) {
-    char* rawBuf = realloc(ptsData->rawBuf, MEM_BUF_SIZE);
+    char* rawBuf = taosMemoryRealloc(ptsData->rawBuf, MEM_BUF_SIZE);
     if (rawBuf) {
       ptsData->rawBuf = rawBuf;
       ptsData->allocSize = MEM_BUF_SIZE;
@@ -322,7 +322,7 @@ static void writeDataToDisk(STSBuf* pTSBuf) {
 static void expandBuffer(STSList* ptsData, int32_t inputSize) {
   if (ptsData->allocSize - ptsData->len < inputSize) {
     int32_t newSize = inputSize + ptsData->len;
-    char*   tmp = realloc(ptsData->rawBuf, (size_t)newSize);
+    char*   tmp = taosMemoryRealloc(ptsData->rawBuf, (size_t)newSize);
     if (tmp == NULL) {
       // todo
     }
@@ -366,7 +366,7 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {
   // NOTE: mix types tags are not supported
   size_t sz = 0;
   if (pBlock->tag.nType == TSDB_DATA_TYPE_BINARY || pBlock->tag.nType == TSDB_DATA_TYPE_NCHAR) {
-    char* tp = realloc(pBlock->tag.pz, pBlock->tag.nLen + 1);
+    char* tp = taosMemoryRealloc(pBlock->tag.pz, pBlock->tag.nLen + 1);
     assert(tp != NULL);
 
     memset(tp, 0, pBlock->tag.nLen + 1);
@@ -812,7 +812,7 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf) {
     if (pDestBuf->numOfAlloc < newSize) {
       pDestBuf->numOfAlloc = newSize;
 
-      STSGroupBlockInfoEx* tmp = realloc(pDestBuf->pData, sizeof(STSGroupBlockInfoEx) * newSize);
+      STSGroupBlockInfoEx* tmp = taosMemoryRealloc(pDestBuf->pData, sizeof(STSGroupBlockInfoEx) * newSize);
       if (tmp == NULL) {
         return -1;
       }
@@ -1028,13 +1028,13 @@ static STSBuf* allocResForTSBuf(STSBuf* pTSBuf) {
   const int32_t INITIAL_GROUPINFO_SIZE = 4;
 
   pTSBuf->numOfAlloc = INITIAL_GROUPINFO_SIZE;
-  pTSBuf->pData = calloc(pTSBuf->numOfAlloc, sizeof(STSGroupBlockInfoEx));
+  pTSBuf->pData = taosMemoryCalloc(pTSBuf->numOfAlloc, sizeof(STSGroupBlockInfoEx));
   if (pTSBuf->pData == NULL) {
     tsBufDestroy(pTSBuf);
     return NULL;
   }
 
-  pTSBuf->tsData.rawBuf = malloc(MEM_BUF_SIZE);
+  pTSBuf->tsData.rawBuf = taosMemoryMalloc(MEM_BUF_SIZE);
   if (pTSBuf->tsData.rawBuf == NULL) {
     tsBufDestroy(pTSBuf);
     return NULL;
@@ -1044,13 +1044,13 @@ static STSBuf* allocResForTSBuf(STSBuf* pTSBuf) {
   pTSBuf->tsData.threshold = MEM_BUF_SIZE;
   pTSBuf->tsData.allocSize = MEM_BUF_SIZE;
 
-  pTSBuf->assistBuf = malloc(MEM_BUF_SIZE);
+  pTSBuf->assistBuf = taosMemoryMalloc(MEM_BUF_SIZE);
   if (pTSBuf->assistBuf == NULL) {
     tsBufDestroy(pTSBuf);
     return NULL;
   }
 
-  pTSBuf->block.payload = malloc(MEM_BUF_SIZE);
+  pTSBuf->block.payload = taosMemoryMalloc(MEM_BUF_SIZE);
   if (pTSBuf->block.payload == NULL) {
     tsBufDestroy(pTSBuf);
     return NULL;
@@ -1079,7 +1079,7 @@ void tsBufGetGroupIdList(STSBuf* pTSBuf, int32_t* num, int32_t** id) {
     return;
   }
 
-  (*id) = malloc(tsBufGetNumOfGroup(pTSBuf) * sizeof(int32_t));
+  (*id) = taosMemoryMalloc(tsBufGetNumOfGroup(pTSBuf) * sizeof(int32_t));
 
   for (int32_t i = 0; i < size; ++i) {
     (*id)[i] = pTSBuf->pData[i].info.id;

source/common/src/tvariant.c

@@ -199,14 +199,14 @@ void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uin
     case TSDB_DATA_TYPE_NCHAR: {  // here we get the nchar length from raw binary bits length
       size_t lenInwchar = len / TSDB_NCHAR_SIZE;
 
-      pVar->ucs4 = calloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE);
+      pVar->ucs4 = taosMemoryCalloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE);
       memcpy(pVar->ucs4, pz, lenInwchar * TSDB_NCHAR_SIZE);
       pVar->nLen = (int32_t)len;
 
       break;
     }
     case TSDB_DATA_TYPE_BINARY: {  // todo refactor, extract a method
-      pVar->pz = calloc(len + 1, sizeof(char));
+      pVar->pz = taosMemoryCalloc(len + 1, sizeof(char));
       memcpy(pVar->pz, pz, len);
       pVar->nLen = (int32_t)len;
       break;
@@ -224,7 +224,7 @@ void taosVariantDestroy(SVariant *pVar) {
   if (pVar == NULL) return;
 
   if (pVar->nType == TSDB_DATA_TYPE_BINARY || pVar->nType == TSDB_DATA_TYPE_NCHAR) {
-    tfree(pVar->pz);
+    taosMemoryFreeClear(pVar->pz);
     pVar->nLen = 0;
   }
 
@@ -233,7 +233,7 @@ void taosVariantDestroy(SVariant *pVar) {
     size_t num = taosArrayGetSize(pVar->arr);
     for (size_t i = 0; i < num; i++) {
       void *p = taosArrayGetP(pVar->arr, i);
-      free(p);
+      taosMemoryFree(p);
     }
     taosArrayDestroy(pVar->arr);
     pVar->arr = NULL;
@@ -254,7 +254,7 @@ void taosVariantAssign(SVariant *pDst, const SVariant *pSrc) {
   pDst->nType = pSrc->nType;
   if (pSrc->nType == TSDB_DATA_TYPE_BINARY || pSrc->nType == TSDB_DATA_TYPE_NCHAR) {
     int32_t len = pSrc->nLen + TSDB_NCHAR_SIZE;
-    char   *p = realloc(pDst->pz, len);
+    char   *p = taosMemoryRealloc(pDst->pz, len);
     assert(p);
 
     memset(p, 0, len);
@@ -402,18 +402,18 @@ static int32_t toBinary(SVariant *pVariant, char **pDest, int32_t *pDestSize) {
 
   // it is a in-place convert type for SVariant, local buffer is needed
   if (*pDest == pVariant->pz) {
-    pBuf = calloc(1, INITIAL_ALLOC_SIZE);
+    pBuf = taosMemoryCalloc(1, INITIAL_ALLOC_SIZE);
   }
 
   if (pVariant->nType == TSDB_DATA_TYPE_NCHAR) {
     size_t newSize = pVariant->nLen * TSDB_NCHAR_SIZE;
     if (pBuf != NULL) {
       if (newSize >= INITIAL_ALLOC_SIZE) {
-        pBuf = realloc(pBuf, newSize + 1);
+        pBuf = taosMemoryRealloc(pBuf, newSize + 1);
       }
 
       taosUcs4ToMbs(pVariant->ucs4, (int32_t)newSize, pBuf);
-      free(pVariant->ucs4);
+      taosMemoryFree(pVariant->ucs4);
       pBuf[newSize] = 0;
     } else {
       taosUcs4ToMbs(pVariant->ucs4, (int32_t)newSize, *pDest);
@@ -460,23 +460,23 @@ static int32_t toNchar(SVariant *pVariant, char **pDest, int32_t *pDestSize) {
   }
 
   if (*pDest == pVariant->pz) {
-    TdUcs4 *pWStr = calloc(1, (nLen + 1) * TSDB_NCHAR_SIZE);
+    TdUcs4 *pWStr = taosMemoryCalloc(1, (nLen + 1) * TSDB_NCHAR_SIZE);
     bool     ret = taosMbsToUcs4(pDst, nLen, pWStr, (nLen + 1) * TSDB_NCHAR_SIZE, NULL);
     if (!ret) {
-      tfree(pWStr);
+      taosMemoryFreeClear(pWStr);
       return -1;
     }
 
     // free the binary buffer in the first place
     if (pVariant->nType == TSDB_DATA_TYPE_BINARY) {
-      free(pVariant->ucs4);
+      taosMemoryFree(pVariant->ucs4);
     }
 
     pVariant->ucs4 = pWStr;
     *pDestSize = taosUcs4len(pVariant->ucs4);
 
     // shrink the allocate memory, no need to check here.
-    char *tmp = realloc(pVariant->ucs4, (*pDestSize + 1) * TSDB_NCHAR_SIZE);
+    char *tmp = taosMemoryRealloc(pVariant->ucs4, (*pDestSize + 1) * TSDB_NCHAR_SIZE);
     assert(tmp != NULL);
 
     pVariant->ucs4 = (TdUcs4 *)tmp;
@@ -526,7 +526,7 @@ static FORCE_INLINE int32_t convertToInteger(SVariant *pVariant, int64_t *result
 
     if (token.type == TK_NULL) {
       if (releaseVariantPtr) {
-        free(pVariant->pz);
+        taosMemoryFree(pVariant->pz);
         pVariant->nLen = 0;
       }
 
@@ -547,7 +547,7 @@ static FORCE_INLINE int32_t convertToInteger(SVariant *pVariant, int64_t *result
     }
 
     if (releaseVariantPtr) {
-      free(pVariant->pz);
+      taosMemoryFree(pVariant->pz);
       pVariant->nLen = 0;
     }
 
@@ -566,7 +566,7 @@ static FORCE_INLINE int32_t convertToInteger(SVariant *pVariant, int64_t *result
     if (token.type == TK_FLOAT) {
       double v = wcstod(pVariant->ucs4, &endPtr);
       if (releaseVariantPtr) {
-        free(pVariant->pz);
+        taosMemoryFree(pVariant->pz);
         pVariant->nLen = 0;
       }
       
@@ -577,7 +577,7 @@ static FORCE_INLINE int32_t convertToInteger(SVariant *pVariant, int64_t *result
       *result = (int64_t)v;
     } else if (token.type == TK_NULL) {
       if (releaseVariantPtr) {
-        free(pVariant->pz);
+        taosMemoryFree(pVariant->pz);
         pVariant->nLen = 0;
       }
       setNull((char *)result, type, tDataTypes[type].bytes);
@@ -585,7 +585,7 @@ static FORCE_INLINE int32_t convertToInteger(SVariant *pVariant, int64_t *result
     } else {
       int64_t val = wcstoll(pVariant->ucs4, &endPtr, 10);
       if (releaseVariantPtr) {
-        free(pVariant->pz);
+        taosMemoryFree(pVariant->pz);
         pVariant->nLen = 0;
       }
       
@@ -971,21 +971,21 @@ int32_t taosVariantTypeSetType(SVariant *pVariant, char type) {
         errno = 0;
         double v = strtod(pVariant->pz, NULL);
         if ((errno == ERANGE && v == -1) || (isinf(v) || isnan(v))) {
-          free(pVariant->pz);
+          taosMemoryFree(pVariant->pz);
           return -1;
         }
 
-        free(pVariant->pz);
+        taosMemoryFree(pVariant->pz);
         pVariant->d = v;
       } else if (pVariant->nType == TSDB_DATA_TYPE_NCHAR) {
         errno = 0;
         double v = wcstod(pVariant->ucs4, NULL);
         if ((errno == ERANGE && v == -1) || (isinf(v) || isnan(v))) {
-          free(pVariant->pz);
+          taosMemoryFree(pVariant->pz);
           return -1;
         }
 
-        free(pVariant->pz);
+        taosMemoryFree(pVariant->pz);
         pVariant->d = v;
       } else if (pVariant->nType >= TSDB_DATA_TYPE_BOOL && pVariant->nType <= TSDB_DATA_TYPE_BIGINT) {
         double tmp = (double)pVariant->i;

source/common/test/commonTests.cpp

@@ -99,7 +99,7 @@ TEST(testCase, toInteger_test) {
 }
 
 TEST(testCase, Datablock_test) {
-  SSDataBlock* b = static_cast<SSDataBlock*>(calloc(1, sizeof(SSDataBlock)));
+  SSDataBlock* b = static_cast<SSDataBlock*>(taosMemoryCalloc(1, sizeof(SSDataBlock)));
   b->info.numOfCols = 2;
   b->pDataBlock = taosArrayInit(4, sizeof(SColumnInfoData));
 
@@ -108,8 +108,8 @@ TEST(testCase, Datablock_test) {
   infoData.info.type = TSDB_DATA_TYPE_INT;
   infoData.info.colId = 1;
 
-  infoData.pData = (char*) calloc(40, infoData.info.bytes);
-  infoData.nullbitmap = (char*) calloc(1, sizeof(char) * (40/8));
+  infoData.pData = (char*) taosMemoryCalloc(40, infoData.info.bytes);
+  infoData.nullbitmap = (char*) taosMemoryCalloc(1, sizeof(char) * (40/8));
   taosArrayPush(b->pDataBlock, &infoData);
 
   SColumnInfoData infoData1 = {0};
@@ -117,7 +117,7 @@ TEST(testCase, Datablock_test) {
   infoData1.info.type = TSDB_DATA_TYPE_BINARY;
   infoData1.info.colId = 2;
 
-  infoData1.varmeta.offset = (int32_t*) calloc(40, sizeof(uint32_t));
+  infoData1.varmeta.offset = (int32_t*) taosMemoryCalloc(40, sizeof(uint32_t));
   taosArrayPush(b->pDataBlock, &infoData1);
 
   char* str = "the value of: %d";
@@ -178,7 +178,7 @@ TEST(testCase, Datablock_test) {
 
 #if 0
 TEST(testCase, non_var_dataBlock_split_test) {
-  SSDataBlock* b = static_cast<SSDataBlock*>(calloc(1, sizeof(SSDataBlock)));
+  SSDataBlock* b = static_cast<SSDataBlock*>(taosMemoryCalloc(1, sizeof(SSDataBlock)));
   b->info.numOfCols = 2;
   b->pDataBlock = taosArrayInit(4, sizeof(SColumnInfoData));
 
@@ -189,8 +189,8 @@ TEST(testCase, non_var_dataBlock_split_test) {
 
   int32_t numOfRows = 1000000;
 
-  infoData.pData = (char*) calloc(numOfRows, infoData.info.bytes);
-  infoData.nullbitmap = (char*) calloc(1, sizeof(char) * (numOfRows/8));
+  infoData.pData = (char*) taosMemoryCalloc(numOfRows, infoData.info.bytes);
+  infoData.nullbitmap = (char*) taosMemoryCalloc(1, sizeof(char) * (numOfRows/8));
   taosArrayPush(b->pDataBlock, &infoData);
 
   SColumnInfoData infoData1 = {0};
@@ -198,8 +198,8 @@ TEST(testCase, non_var_dataBlock_split_test) {
   infoData1.info.type = TSDB_DATA_TYPE_TINYINT;
   infoData1.info.colId = 2;
 
-  infoData1.pData = (char*) calloc(numOfRows, infoData.info.bytes);
-  infoData1.nullbitmap = (char*) calloc(1, sizeof(char) * (numOfRows/8));
+  infoData1.pData = (char*) taosMemoryCalloc(numOfRows, infoData.info.bytes);
+  infoData1.nullbitmap = (char*) taosMemoryCalloc(1, sizeof(char) * (numOfRows/8));
   taosArrayPush(b->pDataBlock, &infoData1);
 
   for(int32_t i = 0; i < numOfRows; ++i) {
@@ -233,7 +233,7 @@ TEST(testCase, non_var_dataBlock_split_test) {
 #endif
 
 TEST(testCase, var_dataBlock_split_test) {
-  SSDataBlock* b = static_cast<SSDataBlock*>(calloc(1, sizeof(SSDataBlock)));
+  SSDataBlock* b = static_cast<SSDataBlock*>(taosMemoryCalloc(1, sizeof(SSDataBlock)));
   b->info.numOfCols = 2;
   b->pDataBlock = taosArrayInit(4, sizeof(SColumnInfoData));
 
@@ -244,8 +244,8 @@ TEST(testCase, var_dataBlock_split_test) {
   infoData.info.type = TSDB_DATA_TYPE_INT;
   infoData.info.colId = 1;
 
-  infoData.pData = (char*) calloc(numOfRows, infoData.info.bytes);
-  infoData.nullbitmap = (char*) calloc(1, sizeof(char) * (numOfRows/8));
+  infoData.pData = (char*) taosMemoryCalloc(numOfRows, infoData.info.bytes);
+  infoData.nullbitmap = (char*) taosMemoryCalloc(1, sizeof(char) * (numOfRows/8));
   taosArrayPush(b->pDataBlock, &infoData);
 
   SColumnInfoData infoData1 = {0};
@@ -253,7 +253,7 @@ TEST(testCase, var_dataBlock_split_test) {
   infoData1.info.type = TSDB_DATA_TYPE_BINARY;
   infoData1.info.colId = 2;
 
-  infoData1.varmeta.offset = (int32_t*) calloc(numOfRows, sizeof(uint32_t));
+  infoData1.varmeta.offset = (int32_t*) taosMemoryCalloc(numOfRows, sizeof(uint32_t));
   taosArrayPush(b->pDataBlock, &infoData1);
 
   char buf[41] = {0};

source/dnode/bnode/src/bnode.c

@@ -16,12 +16,12 @@
 #include "bndInt.h"
 
 SBnode *bndOpen(const char *path, const SBnodeOpt *pOption) {
-  SBnode *pBnode = calloc(1, sizeof(SBnode));
+  SBnode *pBnode = taosMemoryCalloc(1, sizeof(SBnode));
   pBnode->msgCb = pOption->msgCb;
   return pBnode;
 }
 
-void bndClose(SBnode *pBnode) { free(pBnode); }
+void bndClose(SBnode *pBnode) { taosMemoryFree(pBnode); }
 
 int32_t bndGetLoad(SBnode *pBnode, SBnodeLoad *pLoad) { return 0; }
 

source/dnode/mgmt/bnode/src/bmInt.c

@@ -73,7 +73,7 @@ int32_t bmDrop(SMgmtWrapper *pWrapper) {
   bmCloseImp(pMgmt);
   taosRemoveDir(pMgmt->path);
   pWrapper->pMgmt = NULL;
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   dInfo("bnode-mgmt is dropped");
   return 0;
 }
@@ -85,13 +85,13 @@ static void bmClose(SMgmtWrapper *pWrapper) {
   dInfo("bnode-mgmt start to cleanup");
   bmCloseImp(pMgmt);
   pWrapper->pMgmt = NULL;
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   dInfo("bnode-mgmt is cleaned up");
 }
 
 int32_t bmOpen(SMgmtWrapper *pWrapper) {
   dInfo("bnode-mgmt start to init");
-  SBnodeMgmt *pMgmt = calloc(1, sizeof(SBnodeMgmt));
+  SBnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SBnodeMgmt));
   if (pMgmt == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;

source/dnode/mgmt/container/src/dndExec.c

@@ -139,7 +139,7 @@ static void dndConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRsp, int32_t
   dTrace("msg:%p, get from parent queue", pRsp);
   pRsp->pCont = pCont;
   dndSendRpcRsp(pWrapper, pRsp);
-  free(pRsp);
+  taosMemoryFree(pRsp);
 }
 
 static int32_t dndRunInMultiProcess(SDnode *pDnode) {
@@ -174,8 +174,8 @@ static int32_t dndRunInMultiProcess(SDnode *pDnode) {
                      .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
                      .parentQueueSize = 1024 * 1024 * 2,  // size will be a configuration item
                      .parentConsumeFp = (ProcConsumeFp)dndConsumeParentQueue,
-                     .parentdMallocHeadFp = (ProcMallocFp)malloc,
-                     .parentFreeHeadFp = (ProcFreeFp)free,
+                     .parentdMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
+                     .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
                      .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
                      .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
                      .testFlag = 0,

source/dnode/mgmt/container/src/dndFile.c

@@ -20,7 +20,7 @@ int32_t dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed) {
   int32_t   code = TSDB_CODE_NODE_PARSE_FILE_ERROR;
   int32_t   len = 0;
   int32_t   maxLen = 1024;
-  char     *content = calloc(1, maxLen + 1);
+  char     *content = taosMemoryCalloc(1, maxLen + 1);
   cJSON    *root = NULL;
   char      file[PATH_MAX];
   TdFilePtr pFile = NULL;
@@ -57,7 +57,7 @@ int32_t dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed) {
   dDebug("succcessed to read file %s, deployed:%d", file, *pDeployed);
 
 _OVER:
-  if (content != NULL) free(content);
+  if (content != NULL) taosMemoryFree(content);
   if (root != NULL) cJSON_Delete(root);
   if (pFile != NULL) taosCloseFile(&pFile);
 
@@ -78,7 +78,7 @@ int32_t dndWriteFile(SMgmtWrapper *pWrapper, bool deployed) {
 
   int32_t len = 0;
   int32_t maxLen = 1024;
-  char   *content = calloc(1, maxLen + 1);
+  char   *content = taosMemoryCalloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
   len += snprintf(content + len, maxLen - len, "  \"deployed\": %d\n", deployed);
@@ -87,7 +87,7 @@ int32_t dndWriteFile(SMgmtWrapper *pWrapper, bool deployed) {
   taosWriteFile(pFile, content, len);
   taosFsyncFile(pFile);
   taosCloseFile(&pFile);
-  free(content);
+  taosMemoryFree(content);
 
   char realfile[PATH_MAX];
   snprintf(realfile, sizeof(realfile), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);

source/dnode/mgmt/container/src/dndInt.c

@@ -134,6 +134,7 @@ void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
   dndGetStartup(pDnode, pStartup);
 
   dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
-  SRpcMsg rpcRsp = {.handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq)};
+  SRpcMsg rpcRsp = {
+      .handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq), .ahandle = pReq->ahandle};
   rpcSendResponse(&rpcRsp);
 }

source/dnode/mgmt/container/src/dndObj.c

@@ -39,19 +39,19 @@ static int32_t dndInitMemory(SDnode *pDnode, const SDnodeOpt *pOption) {
 static void dndClearMemory(SDnode *pDnode) {
   for (ENodeType n = 0; n < NODE_MAX; ++n) {
     SMgmtWrapper *pMgmt = &pDnode->wrappers[n];
-    tfree(pMgmt->path);
+    taosMemoryFreeClear(pMgmt->path);
   }
   if (pDnode->pLockFile != NULL) {
     taosUnLockFile(pDnode->pLockFile);
     taosCloseFile(&pDnode->pLockFile);
     pDnode->pLockFile = NULL;
   }
-  tfree(pDnode->localEp);
-  tfree(pDnode->localFqdn);
-  tfree(pDnode->firstEp);
-  tfree(pDnode->secondEp);
-  tfree(pDnode->dataDir);
-  free(pDnode);
+  taosMemoryFreeClear(pDnode->localEp);
+  taosMemoryFreeClear(pDnode->localFqdn);
+  taosMemoryFreeClear(pDnode->firstEp);
+  taosMemoryFreeClear(pDnode->secondEp);
+  taosMemoryFreeClear(pDnode->dataDir);
+  taosMemoryFree(pDnode);
   dDebug("dnode object memory is cleared, data:%p", pDnode);
 }
 
@@ -61,7 +61,7 @@ SDnode *dndCreate(const SDnodeOpt *pOption) {
   char    path[PATH_MAX] = {0};
   SDnode *pDnode = NULL;
 
-  pDnode = calloc(1, sizeof(SDnode));
+  pDnode = taosMemoryCalloc(1, sizeof(SDnode));
   if (pDnode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;

source/dnode/mgmt/dnode/src/dmFile.c

@@ -24,7 +24,7 @@ int32_t dmReadFile(SDnodeMgmt *pMgmt) {
   int32_t   code = TSDB_CODE_NODE_PARSE_FILE_ERROR;
   int32_t   len = 0;
   int32_t   maxLen = 256 * 1024;
-  char     *content = calloc(1, maxLen + 1);
+  char     *content = taosMemoryCalloc(1, maxLen + 1);
   cJSON    *root = NULL;
   char      file[PATH_MAX];
   TdFilePtr pFile = NULL;
@@ -134,7 +134,7 @@ int32_t dmReadFile(SDnodeMgmt *pMgmt) {
   dmPrintDnodes(pMgmt);
 
 PRASE_DNODE_OVER:
-  if (content != NULL) free(content);
+  if (content != NULL) taosMemoryFree(content);
   if (root != NULL) cJSON_Delete(root);
   if (pFile != NULL) taosCloseFile(&pFile);
 
@@ -171,7 +171,7 @@ int32_t dmWriteFile(SDnodeMgmt *pMgmt) {
 
   int32_t len = 0;
   int32_t maxLen = 256 * 1024;
-  char   *content = calloc(1, maxLen + 1);
+  char   *content = taosMemoryCalloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
   len += snprintf(content + len, maxLen - len, "  \"dnodeId\": %d,\n", pDnode->dnodeId);
@@ -197,7 +197,7 @@ int32_t dmWriteFile(SDnodeMgmt *pMgmt) {
   taosWriteFile(pFile, content, len);
   taosFsyncFile(pFile);
   taosCloseFile(&pFile);
-  free(content);
+  taosMemoryFree(content);
 
   char realfile[PATH_MAX];
   snprintf(realfile, sizeof(realfile), "%s%smnode.json", pMgmt->path, TD_DIRSEP);

source/dnode/mgmt/dnode/src/dmInt.c

@@ -80,7 +80,7 @@ static int32_t dmStart(SMgmtWrapper *pWrapper) {
 
 int32_t dmInit(SMgmtWrapper *pWrapper) {
   SDnode     *pDnode = pWrapper->pDnode;
-  SDnodeMgmt *pMgmt = calloc(1, sizeof(SDnodeMgmt));
+  SDnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SDnodeMgmt));
   dInfo("dnode-mgmt start to init");
 
   pDnode->dnodeId = 0;
@@ -138,7 +138,7 @@ void dmCleanup(SMgmtWrapper *pWrapper) {
 
   taosWUnLockLatch(&pMgmt->latch);
 
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   pWrapper->pMgmt = NULL;
   dInfo("dnode-mgmt is cleaned up");
 }

source/dnode/mgmt/dnode/src/dmWorker.c

@@ -23,7 +23,7 @@
 
 static void *dmThreadRoutine(void *param) {
   SDnodeMgmt *pMgmt = param;
-  SDnode     *pDnode = pMgmt->pDnode;
+  SDnode *    pDnode = pMgmt->pDnode;
   int64_t     lastStatusTime = taosGetTimestampMs();
   int64_t     lastMonitorTime = lastStatusTime;
 
@@ -55,7 +55,7 @@ static void *dmThreadRoutine(void *param) {
 static void dmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   SDnodeMgmt *pMgmt = pInfo->ahandle;
 
-  SDnode  *pDnode = pMgmt->pDnode;
+  SDnode * pDnode = pMgmt->pDnode;
   SRpcMsg *pRpc = &pMsg->rpcMsg;
   int32_t  code = -1;
   dTrace("msg:%p, will be processed in dnode queue", pMsg);

source/dnode/mgmt/mnode/inc/mmInt.h

@@ -28,6 +28,7 @@ typedef struct SMnodeMgmt {
   SDnode       *pDnode;
   SMgmtWrapper *pWrapper;
   const char   *path;
+  SSingleWorker queryWorker;
   SSingleWorker readWorker;
   SSingleWorker writeWorker;
   SSingleWorker syncWorker;
@@ -57,11 +58,13 @@ void    mmStopWorker(SMnodeMgmt *pMgmt);
 int32_t mmProcessWriteMsg(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t mmProcessSyncMsg(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t mmProcessReadMsg(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t mmProcessQueryMsg(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t mmPutMsgToWriteQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpcMsg);
 int32_t mmPutMsgToReadQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpcMsg);
+int32_t mmPutMsgToQueryQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_DND_MNODE_INT_H_*/
+#endif /*_TD_DND_MNODE_INT_H_*/
\ No newline at end of file

source/dnode/mgmt/mnode/src/mmFile.c

@@ -20,7 +20,7 @@ int32_t mmReadFile(SMnodeMgmt *pMgmt, bool *pDeployed) {
   int32_t   code = TSDB_CODE_NODE_PARSE_FILE_ERROR;
   int32_t   len = 0;
   int32_t   maxLen = 4096;
-  char     *content = calloc(1, maxLen + 1);
+  char     *content = taosMemoryCalloc(1, maxLen + 1);
   cJSON    *root = NULL;
   char      file[PATH_MAX];
   TdFilePtr pFile = NULL;
@@ -97,7 +97,7 @@ int32_t mmReadFile(SMnodeMgmt *pMgmt, bool *pDeployed) {
   dDebug("succcessed to read file %s, deployed:%d", file, *pDeployed);
 
 PRASE_MNODE_OVER:
-  if (content != NULL) free(content);
+  if (content != NULL) taosMemoryFree(content);
   if (root != NULL) cJSON_Delete(root);
   if (pFile != NULL) taosCloseFile(&pFile);
 
@@ -118,7 +118,7 @@ int32_t mmWriteFile(SMnodeMgmt *pMgmt, bool deployed) {
 
   int32_t len = 0;
   int32_t maxLen = 4096;
-  char   *content = calloc(1, maxLen + 1);
+  char   *content = taosMemoryCalloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
   len += snprintf(content + len, maxLen - len, "  \"deployed\": %d,\n", deployed);
@@ -139,7 +139,7 @@ int32_t mmWriteFile(SMnodeMgmt *pMgmt, bool deployed) {
   taosWriteFile(pFile, content, len);
   taosFsyncFile(pFile);
   taosCloseFile(&pFile);
-  free(content);
+  taosMemoryFree(content);
 
   char realfile[PATH_MAX];
   snprintf(realfile, sizeof(realfile), "%s%smnode.json", pMgmt->path, TD_DIRSEP);

source/dnode/mgmt/mnode/src/mmInt.c

@@ -45,7 +45,8 @@ static void mmInitOption(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
 
   SMsgCb msgCb = {0};
   msgCb.pWrapper = pMgmt->pWrapper;
-  msgCb.queueFps[QUERY_QUEUE] = mmPutMsgToReadQueue;
+  msgCb.queueFps[QUERY_QUEUE] = mmPutMsgToQueryQueue;
+  msgCb.queueFps[READ_QUEUE] = mmPutMsgToReadQueue;
   msgCb.queueFps[WRITE_QUEUE] = mmPutMsgToWriteQueue;
   msgCb.sendReqFp = dndSendReqToDnode;
   msgCb.sendMnodeReqFp = dndSendReqToMnode;
@@ -177,7 +178,7 @@ int32_t mmDrop(SMgmtWrapper *pWrapper) {
   mmCloseImp(pMgmt);
   taosRemoveDir(pMgmt->path);
   pWrapper->pMgmt = NULL;
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   dInfo("mnode-mgmt is dropped");
   return 0;
 }
@@ -189,7 +190,7 @@ static void mmClose(SMgmtWrapper *pWrapper) {
   dInfo("mnode-mgmt start to cleanup");
   mmCloseImp(pMgmt);
   pWrapper->pMgmt = NULL;
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   dInfo("mnode-mgmt is cleaned up");
 }
 
@@ -200,7 +201,7 @@ int32_t mmOpenFromMsg(SMgmtWrapper *pWrapper, SDCreateMnodeReq *pReq) {
     return -1;
   }
 
-  SMnodeMgmt *pMgmt = calloc(1, sizeof(SMnodeMgmt));
+  SMnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SMnodeMgmt));
   if (pMgmt == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -258,4 +259,4 @@ int32_t mmMonitorMnodeInfo(SMgmtWrapper *pWrapper, SMonClusterInfo *pClusterInfo
                          SMonGrantInfo *pGrantInfo) {
   SMnodeMgmt *pMgmt = pWrapper->pMgmt;
   return mndGetMonitorInfo(pMgmt->pMnode, pClusterInfo, pVgroupInfo, pGrantInfo);
-}
+}
\ No newline at end of file

source/dnode/mgmt/mnode/src/mmMsg.c

@@ -156,9 +156,10 @@ void mmInitMsgHandles(SMgmtWrapper *pWrapper) {
   dndSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA_RSP, (NodeMsgFp)mmProcessWriteMsg, VND_VGID);
   dndSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA_RSP, (NodeMsgFp)mmProcessWriteMsg, VND_VGID);
 
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, (NodeMsgFp)mmProcessReadMsg, MND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, (NodeMsgFp)mmProcessReadMsg, MND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, (NodeMsgFp)mmProcessReadMsg, MND_VGID);
-  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, (NodeMsgFp)mmProcessReadMsg, MND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY, (NodeMsgFp)mmProcessQueryMsg, MND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, (NodeMsgFp)mmProcessQueryMsg, MND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_FETCH, (NodeMsgFp)mmProcessQueryMsg, MND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, (NodeMsgFp)mmProcessQueryMsg, MND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, (NodeMsgFp)mmProcessQueryMsg, MND_VGID);
 
 }

source/dnode/mgmt/mnode/src/mmWorker.c

@@ -44,6 +44,30 @@ static void mmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   taosFreeQitem(pMsg);
 }
 
+static void mmProcessQueryQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+  SMnodeMgmt *pMgmt = pInfo->ahandle;
+
+  dTrace("msg:%p, will be processed in mnode queue", pMsg);
+  SRpcMsg *pRpc = &pMsg->rpcMsg;
+  int32_t  code = -1;
+
+  pMsg->pNode = pMgmt->pMnode;
+  code = mndProcessMsg(pMsg);
+
+  if (pRpc->msgType & 1U) {
+    if (pRpc->handle == NULL) return;
+    if (code != 0) {
+      SRpcMsg rsp = {.handle = pRpc->handle, .code = code, .ahandle = pRpc->ahandle};
+      dndSendRsp(pMgmt->pWrapper, &rsp);
+    }
+  }
+
+  dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
+  rpcFreeCont(pRpc->pCont);
+  taosFreeQitem(pMsg);
+}
+
+
 static int32_t mmPutMsgToWorker(SMnodeMgmt *pMgmt, SSingleWorker *pWorker, SNodeMsg *pMsg) {
   dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
   return taosWriteQitem(pWorker->queue, pMsg);
@@ -61,6 +85,10 @@ int32_t mmProcessReadMsg(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return mmPutMsgToWorker(pMgmt, &pMgmt->readWorker, pMsg);
 }
 
+int32_t mmProcessQueryMsg(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  return mmPutMsgToWorker(pMgmt, &pMgmt->queryWorker, pMsg);
+}
+
 static int32_t mmPutRpcMsgToWorker(SMnodeMgmt *pMgmt, SSingleWorker *pWorker, SRpcMsg *pRpc) {
   SNodeMsg *pMsg = taosAllocateQitem(sizeof(SNodeMsg));
   if (pMsg == NULL) {
@@ -90,8 +118,20 @@ int32_t mmPutMsgToReadQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
   return mmPutRpcMsgToWorker(pMgmt, &pMgmt->readWorker, pRpc);
 }
 
+int32_t mmPutMsgToQueryQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
+  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+  return mmPutRpcMsgToWorker(pMgmt, &pMgmt->queryWorker, pRpc);
+}
+
+
 int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
   SSingleWorkerCfg cfg = {.minNum = 0, .maxNum = 1, .name = "mnode-read", .fp = (FItem)mmProcessQueue, .param = pMgmt};
+  SSingleWorkerCfg queryCfg = {.minNum = 0, .maxNum = 1, .name = "mnode-query", .fp = (FItem)mmProcessQueryQueue, .param = pMgmt};
+
+  if (tSingleWorkerInit(&pMgmt->queryWorker, &queryCfg) != 0) {
+    dError("failed to start mnode-query worker since %s", terrstr());
+    return -1;
+  }
 
   if (tSingleWorkerInit(&pMgmt->readWorker, &cfg) != 0) {
     dError("failed to start mnode-read worker since %s", terrstr());
@@ -114,6 +154,7 @@ int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
 
 void mmStopWorker(SMnodeMgmt *pMgmt) {
   tSingleWorkerCleanup(&pMgmt->readWorker);
+  tSingleWorkerCleanup(&pMgmt->queryWorker);
   tSingleWorkerCleanup(&pMgmt->writeWorker);
   tSingleWorkerCleanup(&pMgmt->syncWorker);
   dDebug("mnode workers are closed");

source/dnode/mgmt/qnode/src/qmInt.c

@@ -76,7 +76,7 @@ int32_t qmDrop(SMgmtWrapper *pWrapper) {
   qmCloseImp(pMgmt);
   taosRemoveDir(pMgmt->path);
   pWrapper->pMgmt = NULL;
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   dInfo("qnode-mgmt is dropped");
   return 0;
 }
@@ -88,13 +88,13 @@ static void qmClose(SMgmtWrapper *pWrapper) {
   dInfo("qnode-mgmt start to cleanup");
   qmCloseImp(pMgmt);
   pWrapper->pMgmt = NULL;
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   dInfo("qnode-mgmt is cleaned up");
 }
 
 int32_t qmOpen(SMgmtWrapper *pWrapper) {
   dInfo("qnode-mgmt start to init");
-  SQnodeMgmt *pMgmt = calloc(1, sizeof(SQnodeMgmt));
+  SQnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SQnodeMgmt));
   if (pMgmt == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;

source/dnode/mgmt/snode/src/smInt.c

@@ -73,7 +73,7 @@ int32_t smDrop(SMgmtWrapper *pWrapper) {
   smCloseImp(pMgmt);
   taosRemoveDir(pMgmt->path);
   pWrapper->pMgmt = NULL;
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   dInfo("snode-mgmt is dropped");
   return 0;
 }
@@ -85,13 +85,13 @@ static void smClose(SMgmtWrapper *pWrapper) {
   dInfo("snode-mgmt start to cleanup");
   smCloseImp(pMgmt);
   pWrapper->pMgmt = NULL;
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   dInfo("snode-mgmt is cleaned up");
 }
 
 int32_t smOpen(SMgmtWrapper *pWrapper) {
   dInfo("snode-mgmt start to init");
-  SSnodeMgmt *pMgmt = calloc(1, sizeof(SSnodeMgmt));
+  SSnodeMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SSnodeMgmt));
   if (pMgmt == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;

source/dnode/mgmt/snode/src/smWorker.c

@@ -51,7 +51,7 @@ int32_t smStartWorker(SSnodeMgmt *pMgmt) {
   }
 
   for (int32_t i = 0; i < SND_UNIQUE_THREAD_NUM; i++) {
-    SMultiWorker *pUniqueWorker = malloc(sizeof(SMultiWorker));
+    SMultiWorker *pUniqueWorker = taosMemoryMalloc(sizeof(SMultiWorker));
     if (pUniqueWorker == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
@@ -96,14 +96,15 @@ void smStopWorker(SSnodeMgmt *pMgmt) {
 
 static FORCE_INLINE int32_t smGetSWIdFromMsg(SRpcMsg *pMsg) {
   SMsgHead *pHead = pMsg->pCont;
-  pHead->streamTaskId = htonl(pHead->streamTaskId);
-  return pHead->streamTaskId % SND_UNIQUE_THREAD_NUM;
+  pHead->vgId = htonl(pHead->vgId);
+  return pHead->vgId % SND_UNIQUE_THREAD_NUM;
 }
 
 static FORCE_INLINE int32_t smGetSWTypeFromMsg(SRpcMsg *pMsg) {
-  SStreamExecMsgHead *pHead = pMsg->pCont;
-  pHead->workerType = htonl(pHead->workerType);
-  return pHead->workerType;
+  /*SMsgHead *pHead = pMsg->pCont;*/
+  /*pHead->workerType = htonl(pHead->workerType);*/
+  /*return pHead->workerType;*/
+  return 0;
 }
 
 int32_t smProcessMgmtMsg(SSnodeMgmt *pMgmt, SNodeMsg *pMsg) {

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

@@ -98,7 +98,7 @@ class Testbase {
 
 #define CheckBinaryByte(b, len)                   \
   {                                               \
-    char* bytes = (char*)calloc(1, len);          \
+    char* bytes = (char*)taosMemoryCalloc(1, len);          \
     for (int32_t i = 0; i < len - 1; ++i) {       \
       bytes[i] = b;                               \
     }                                             \

source/dnode/mgmt/test/sut/src/client.cpp

@@ -25,9 +25,9 @@ static void processClientRsp(void* parent, SRpcMsg* pRsp, SEpSet* pEpSet) {
 
 void TestClient::SetRpcRsp(SRpcMsg* rsp) {
   if (this->pRsp) {
-    free(this->pRsp);
+    taosMemoryFree(this->pRsp);
   }
-  this->pRsp = (SRpcMsg*)calloc(1, sizeof(SRpcMsg));
+  this->pRsp = (SRpcMsg*)taosMemoryCalloc(1, sizeof(SRpcMsg));
   this->pRsp->msgType = rsp->msgType;
   this->pRsp->code = rsp->code;
   this->pRsp->pCont = rsp->pCont;

source/dnode/mgmt/vnode/inc/vmInt.h

@@ -33,6 +33,7 @@ typedef struct SVnodesMgmt {
   SQWorkerPool  fetchPool;
   SWWorkerPool  syncPool;
   SWWorkerPool  writePool;
+  SWWorkerPool  mergePool;
   const char   *path;
   SDnode       *pDnode;
   SMgmtWrapper *pWrapper;
@@ -63,6 +64,7 @@ typedef struct {
   STaosQueue   *pApplyQ;
   STaosQueue   *pQueryQ;
   STaosQueue   *pFetchQ;
+  STaosQueue   *pMergeQ;
   SMgmtWrapper *pWrapper;
 } SVnodeObj;
 
@@ -110,10 +112,11 @@ int32_t vmProcessWriteMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t vmProcessSyncMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t vmProcessQueryMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t vmProcessFetchMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t vmProcessMergeMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t vmProcessMgmtMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_DND_VNODES_INT_H_*/
+#endif /*_TD_DND_VNODES_INT_H_*/
\ No newline at end of file

source/dnode/mgmt/vnode/src/vmFile.c

@@ -21,7 +21,7 @@ SVnodeObj **vmGetVnodesFromHash(SVnodesMgmt *pMgmt, int32_t *numOfVnodes) {
 
   int32_t     num = 0;
   int32_t     size = taosHashGetSize(pMgmt->hash);
-  SVnodeObj **pVnodes = calloc(size, sizeof(SVnodeObj *));
+  SVnodeObj **pVnodes = taosMemoryCalloc(size, sizeof(SVnodeObj *));
 
   void *pIter = taosHashIterate(pMgmt->hash, NULL);
   while (pIter) {
@@ -48,7 +48,7 @@ int32_t vmGetVnodesFromFile(SVnodesMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t *n
   int32_t      code = TSDB_CODE_NODE_PARSE_FILE_ERROR;
   int32_t      len = 0;
   int32_t      maxLen = 30000;
-  char        *content = calloc(1, maxLen + 1);
+  char        *content = taosMemoryCalloc(1, maxLen + 1);
   cJSON       *root = NULL;
   FILE        *fp = NULL;
   char         file[PATH_MAX];
@@ -85,7 +85,7 @@ int32_t vmGetVnodesFromFile(SVnodesMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t *n
 
   int32_t vnodesNum = cJSON_GetArraySize(vnodes);
   if (vnodesNum > 0) {
-    pCfgs = calloc(vnodesNum, sizeof(SWrapperCfg));
+    pCfgs = taosMemoryCalloc(vnodesNum, sizeof(SWrapperCfg));
     if (pCfgs == NULL) {
       dError("failed to read %s since out of memory", file);
       goto PRASE_VNODE_OVER;
@@ -140,7 +140,7 @@ int32_t vmGetVnodesFromFile(SVnodesMgmt *pMgmt, SWrapperCfg **ppCfgs, int32_t *n
   dInfo("succcessed to read file %s", file);
 
 PRASE_VNODE_OVER:
-  if (content != NULL) free(content);
+  if (content != NULL) taosMemoryFree(content);
   if (root != NULL) cJSON_Delete(root);
   if (pFile != NULL) taosCloseFile(&pFile);
 
@@ -166,7 +166,7 @@ int32_t vmWriteVnodesToFile(SVnodesMgmt *pMgmt) {
 
   int32_t len = 0;
   int32_t maxLen = 65536;
-  char   *content = calloc(1, maxLen + 1);
+  char   *content = taosMemoryCalloc(1, maxLen + 1);
 
   len += snprintf(content + len, maxLen - len, "{\n");
   len += snprintf(content + len, maxLen - len, "  \"vnodes\": [\n");
@@ -190,7 +190,7 @@ int32_t vmWriteVnodesToFile(SVnodesMgmt *pMgmt) {
   taosWriteFile(pFile, content, len);
   taosFsyncFile(pFile);
   taosCloseFile(&pFile);
-  free(content);
+  taosMemoryFree(content);
   terrno = 0;
 
   for (int32_t i = 0; i < numOfVnodes; ++i) {
@@ -199,7 +199,7 @@ int32_t vmWriteVnodesToFile(SVnodesMgmt *pMgmt) {
   }
 
   if (pVnodes != NULL) {
-    free(pVnodes);
+    taosMemoryFree(pVnodes);
   }
 
   dDebug("successed to write %s", realfile);

source/dnode/mgmt/vnode/src/vmInt.c

@@ -46,7 +46,7 @@ void vmReleaseVnode(SVnodesMgmt *pMgmt, SVnodeObj *pVnode) {
 }
 
 int32_t vmOpenVnode(SVnodesMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl) {
-  SVnodeObj *pVnode = calloc(1, sizeof(SVnodeObj));
+  SVnodeObj *pVnode = taosMemoryCalloc(1, sizeof(SVnodeObj));
   if (pVnode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -107,9 +107,9 @@ void vmCloseVnode(SVnodesMgmt *pMgmt, SVnodeObj *pVnode) {
     vnodeDestroy(pVnode->path);
   }
 
-  free(pVnode->path);
-  free(pVnode->db);
-  free(pVnode);
+  taosMemoryFree(pVnode->path);
+  taosMemoryFree(pVnode->db);
+  taosMemoryFree(pVnode);
 }
 
 static void *vmOpenVnodeFunc(void *param) {
@@ -183,11 +183,11 @@ static int32_t vmOpenVnodes(SVnodesMgmt *pMgmt) {
 #endif
   int32_t vnodesPerThread = numOfVnodes / threadNum + 1;
 
-  SVnodeThread *threads = calloc(threadNum, sizeof(SVnodeThread));
+  SVnodeThread *threads = taosMemoryCalloc(threadNum, sizeof(SVnodeThread));
   for (int32_t t = 0; t < threadNum; ++t) {
     threads[t].threadIndex = t;
     threads[t].pMgmt = pMgmt;
-    threads[t].pCfgs = calloc(vnodesPerThread, sizeof(SWrapperCfg));
+    threads[t].pCfgs = taosMemoryCalloc(vnodesPerThread, sizeof(SWrapperCfg));
   }
 
   for (int32_t v = 0; v < numOfVnodes; ++v) {
@@ -217,10 +217,10 @@ static int32_t vmOpenVnodes(SVnodesMgmt *pMgmt) {
     if (pThread->vnodeNum > 0 && taosCheckPthreadValid(pThread->thread)) {
       taosThreadJoin(pThread->thread, NULL);
     }
-    free(pThread->pCfgs);
+    taosMemoryFree(pThread->pCfgs);
   }
-  free(threads);
-  free(pCfgs);
+  taosMemoryFree(threads);
+  taosMemoryFree(pCfgs);
 
   if (pMgmt->state.openVnodes != pMgmt->state.totalVnodes) {
     dError("there are total vnodes:%d, opened:%d", pMgmt->state.totalVnodes, pMgmt->state.openVnodes);
@@ -242,7 +242,7 @@ static void vmCloseVnodes(SVnodesMgmt *pMgmt) {
   }
 
   if (pVnodes != NULL) {
-    free(pVnodes);
+    taosMemoryFree(pVnodes);
   }
 
   if (pMgmt->hash != NULL) {
@@ -262,14 +262,14 @@ static void vmCleanup(SMgmtWrapper *pWrapper) {
   vmStopWorker(pMgmt);
   vnodeCleanup();
   // walCleanUp();
-  free(pMgmt);
+  taosMemoryFree(pMgmt);
   pWrapper->pMgmt = NULL;
   dInfo("vnode-mgmt is cleaned up");
 }
 
 static int32_t vmInit(SMgmtWrapper *pWrapper) {
   SDnode      *pDnode = pWrapper->pDnode;
-  SVnodesMgmt *pMgmt = calloc(1, sizeof(SVnodesMgmt));
+  SVnodesMgmt *pMgmt = taosMemoryCalloc(1, sizeof(SVnodesMgmt));
   int32_t      code = -1;
 
   dInfo("vnode-mgmt start to init");

source/dnode/mgmt/vnode/src/vmMsg.c

@@ -280,6 +280,8 @@ void vmInitMsgHandles(SMgmtWrapper *pWrapper) {
   dndSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY, (NodeMsgFp)vmProcessWriteMsg, VND_VGID);
   dndSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
   dndSetMsgHandle(pWrapper, TDMT_VND_TASK_EXEC, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_PIPE_EXEC, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
+  dndSetMsgHandle(pWrapper, TDMT_VND_TASK_MERGE_EXEC, (NodeMsgFp)vmProcessMergeMsg, VND_VGID);
   dndSetMsgHandle(pWrapper, TDMT_VND_STREAM_TRIGGER, (NodeMsgFp)vmProcessFetchMsg, VND_VGID);
 
   dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_VNODE, (NodeMsgFp)vmProcessMgmtMsg, VND_VGID);

source/dnode/mgmt/vnode/src/vmWorker.c

@@ -117,7 +117,7 @@ static void vmProcessWriteQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
     if (pRsp != NULL) {
       pRsp->ahandle = pRpc->ahandle;
       dndSendRsp(pVnode->pWrapper, pRsp);
-      free(pRsp);
+      taosMemoryFree(pRsp);
     } else {
       if (code != 0 && terrno != 0) code = terrno;
       vmSendRsp(pVnode->pWrapper, pMsg, code);
@@ -165,8 +165,8 @@ static int32_t vmPutNodeMsgToQueue(SVnodesMgmt *pMgmt, SNodeMsg *pMsg, EQueueTyp
   int32_t  code = -1;
 
   SMsgHead *pHead = pRpc->pCont;
-  pHead->contLen = htonl(pHead->contLen);
-  pHead->vgId = htonl(pHead->vgId);
+  pHead->contLen = ntohl(pHead->contLen);
+  pHead->vgId = ntohl(pHead->vgId);
 
   SVnodeObj *pVnode = vmAcquireVnode(pMgmt, pHead->vgId);
   if (pVnode == NULL) {
@@ -191,6 +191,10 @@ static int32_t vmPutNodeMsgToQueue(SVnodesMgmt *pMgmt, SNodeMsg *pMsg, EQueueTyp
       dTrace("msg:%p, will be written into vnode-sync queue", pMsg);
       code = taosWriteQitem(pVnode->pSyncQ, pMsg);
       break;
+    case MERGE_QUEUE:
+      dTrace("msg:%p, will be written into vnode-merge queue", pMsg);
+      code = taosWriteQitem(pVnode->pMergeQ, pMsg);
+      break;
     default:
       terrno = TSDB_CODE_INVALID_PARA;
       break;
@@ -208,6 +212,8 @@ int32_t vmProcessQueryMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) { return vmPutNode
 
 int32_t vmProcessFetchMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) { return vmPutNodeMsgToQueue(pMgmt, pMsg, FETCH_QUEUE); }
 
+int32_t vmProcessMergeMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) { return vmPutNodeMsgToQueue(pMgmt, pMsg, MERGE_QUEUE); }
+
 int32_t vmProcessMgmtMsg(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
   SSingleWorker *pWorker = &pMgmt->mgmtWorker;
   dTrace("msg:%p, will be written to vnode-mgmt queue, worker:%s", pMsg, pWorker->name);
@@ -239,6 +245,10 @@ static int32_t vmPutRpcMsgToQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc, EQueueT
         dTrace("msg:%p, will be put into vnode-apply queue", pMsg);
         code = taosWriteQitem(pVnode->pApplyQ, pMsg);
         break;
+      case MERGE_QUEUE:
+        dTrace("msg:%p, will be put into vnode-merge queue", pMsg);
+        code = taosWriteQitem(pVnode->pMergeQ, pMsg);
+        break;
       default:
         terrno = TSDB_CODE_INVALID_PARA;
         break;
@@ -260,6 +270,10 @@ int32_t vmPutMsgToApplyQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
   return vmPutRpcMsgToQueue(pWrapper, pRpc, APPLY_QUEUE);
 }
 
+int32_t vmPutMsgToMergeQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
+  return vmPutRpcMsgToQueue(pWrapper, pRpc, MERGE_QUEUE);
+}
+
 int32_t vmGetQueueSize(SMgmtWrapper *pWrapper, int32_t vgId, EQueueType qtype) {
   int32_t    size = -1;
   SVnodeObj *pVnode = vmAcquireVnode(pWrapper->pMgmt, vgId);
@@ -280,6 +294,9 @@ int32_t vmGetQueueSize(SMgmtWrapper *pWrapper, int32_t vgId, EQueueType qtype) {
       case APPLY_QUEUE:
         size = taosQueueSize(pVnode->pApplyQ);
         break;
+      case MERGE_QUEUE:
+        size = taosQueueSize(pVnode->pMergeQ);
+        break;
       default:
         break;
     }
@@ -291,12 +308,13 @@ int32_t vmGetQueueSize(SMgmtWrapper *pWrapper, int32_t vgId, EQueueType qtype) {
 int32_t vmAllocQueue(SVnodesMgmt *pMgmt, SVnodeObj *pVnode) {
   pVnode->pWriteQ = tWWorkerAllocQueue(&pMgmt->writePool, pVnode, (FItems)vmProcessWriteQueue);
   pVnode->pApplyQ = tWWorkerAllocQueue(&pMgmt->writePool, pVnode, (FItems)vmProcessApplyQueue);
+  pVnode->pMergeQ = tWWorkerAllocQueue(&pMgmt->mergePool, pVnode, (FItems)vmProcessMergeMsg);
   pVnode->pSyncQ = tWWorkerAllocQueue(&pMgmt->syncPool, pVnode, (FItems)vmProcessSyncQueue);
   pVnode->pFetchQ = tQWorkerAllocQueue(&pMgmt->fetchPool, pVnode, (FItem)vmProcessFetchQueue);
   pVnode->pQueryQ = tQWorkerAllocQueue(&pMgmt->queryPool, pVnode, (FItem)vmProcessQueryQueue);
 
   if (pVnode->pApplyQ == NULL || pVnode->pWriteQ == NULL || pVnode->pSyncQ == NULL || pVnode->pFetchQ == NULL ||
-      pVnode->pQueryQ == NULL) {
+      pVnode->pQueryQ == NULL || pVnode->pMergeQ == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -310,12 +328,14 @@ void vmFreeQueue(SVnodesMgmt *pMgmt, SVnodeObj *pVnode) {
   tQWorkerFreeQueue(&pMgmt->fetchPool, pVnode->pFetchQ);
   tWWorkerFreeQueue(&pMgmt->writePool, pVnode->pWriteQ);
   tWWorkerFreeQueue(&pMgmt->writePool, pVnode->pApplyQ);
+  tWWorkerFreeQueue(&pMgmt->mergePool, pVnode->pMergeQ);
   tWWorkerFreeQueue(&pMgmt->syncPool, pVnode->pSyncQ);
   pVnode->pWriteQ = NULL;
   pVnode->pApplyQ = NULL;
   pVnode->pSyncQ = NULL;
   pVnode->pFetchQ = NULL;
   pVnode->pQueryQ = NULL;
+  pVnode->pMergeQ = NULL;
   dDebug("vgId:%d, vnode queue is freed", pVnode->vgId);
 }
 
@@ -326,6 +346,7 @@ int32_t vmStartWorker(SVnodesMgmt *pMgmt) {
   int32_t maxQueryThreads = minQueryThreads;
   int32_t maxWriteThreads = TMAX(tsNumOfCores, 1);
   int32_t maxSyncThreads = TMAX(tsNumOfCores / 2, 1);
+  int32_t maxMergeThreads = 1;
 
   SQWorkerPool *pQPool = &pMgmt->queryPool;
   pQPool->name = "vnode-query";
@@ -349,6 +370,11 @@ int32_t vmStartWorker(SVnodesMgmt *pMgmt) {
   pWPool->max = maxSyncThreads;
   if (tWWorkerInit(pWPool) != 0) return -1;
 
+  pWPool = &pMgmt->mergePool;
+  pWPool->name = "vnode-merge";
+  pWPool->max = maxMergeThreads;
+  if (tWWorkerInit(pWPool) != 0) return -1;
+
   SSingleWorkerCfg cfg = {
       .minNum = 1, .maxNum = 1, .name = "vnode-mgmt", .fp = (FItem)vmProcessMgmtQueue, .param = pMgmt};
   if (tSingleWorkerInit(&pMgmt->mgmtWorker, &cfg) != 0) {
@@ -366,5 +392,6 @@ void vmStopWorker(SVnodesMgmt *pMgmt) {
   tQWorkerCleanup(&pMgmt->queryPool);
   tWWorkerCleanup(&pMgmt->writePool);
   tWWorkerCleanup(&pMgmt->syncPool);
+  tWWorkerCleanup(&pMgmt->mergePool);
   dDebug("vnode workers are closed");
 }

source/dnode/mnode/impl/CMakeLists.txt

@@ -6,7 +6,7 @@ target_include_directories(
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    mnode scheduler sdb wal transport cjson sync monitor parser
+    mnode scheduler sdb wal transport cjson sync monitor executor qworker stream parser
 )
 
 if(${BUILD_TEST})

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

@@ -26,6 +26,7 @@
 #include "tlog.h"
 #include "tmsg.h"
 #include "trpc.h"
+#include "tstream.h"
 #include "ttimer.h"
 
 #include "mnode.h"
@@ -441,7 +442,7 @@ static FORCE_INLINE void* tDecodeSMqConsumerEp(void** buf, SMqConsumerEp* pConsu
 
 static FORCE_INLINE void tDeleteSMqConsumerEp(SMqConsumerEp* pConsumerEp) {
   if (pConsumerEp) {
-    tfree(pConsumerEp->qmsg);
+    taosMemoryFreeClear(pConsumerEp->qmsg);
   }
 }
 
@@ -510,7 +511,7 @@ typedef struct {
 } SMqSubscribeObj;
 
 static FORCE_INLINE SMqSubscribeObj* tNewSubscribeObj() {
-  SMqSubscribeObj* pSub = calloc(1, sizeof(SMqSubscribeObj));
+  SMqSubscribeObj* pSub = taosMemoryCalloc(1, sizeof(SMqSubscribeObj));
   if (pSub == NULL) {
     return NULL;
   }
@@ -537,10 +538,10 @@ static FORCE_INLINE SMqSubscribeObj* tNewSubscribeObj() {
   return pSub;
 
 _err:
-  tfree(pSub->consumers);
-  tfree(pSub->lostConsumers);
-  tfree(pSub->unassignedVg);
-  tfree(pSub);
+  taosMemoryFreeClear(pSub->consumers);
+  taosMemoryFreeClear(pSub->lostConsumers);
+  taosMemoryFreeClear(pSub->unassignedVg);
+  taosMemoryFreeClear(pSub);
   return NULL;
 }
 
@@ -729,13 +730,15 @@ typedef struct {
   int32_t  vgNum;
   SRWLatch lock;
   int8_t   status;
+  int8_t   sourceType;
+  int8_t   sinkType;
   // int32_t  sqlLen;
   int32_t sinkVgId;  // 0 for automatic
   char*   sql;
   char*   logicalPlan;
   char*   physicalPlan;
-  SArray* tasks;  // SArray<SArray<SStreamTask>>
-  SArray* ColAlias;
+  SArray* tasks;     // SArray<SArray<SStreamTask>>
+  SArray* ColAlias;  // SArray<char*>
 } SStreamObj;
 
 int32_t tEncodeSStreamObj(SCoder* pEncoder, const SStreamObj* pObj);

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

@@ -59,6 +59,8 @@ typedef struct SMnodeLoad {
   int64_t compStorage;
 } SMnodeLoad;
 
+typedef struct SQWorkerMgmt SQHandle;
+
 typedef struct {
   const char  *name;
   MndInitFp    initFp;
@@ -112,6 +114,7 @@ typedef struct SMnode {
   SSdb             *pSdb;
   SMgmtWrapper     *pWrapper;
   SArray           *pSteps;
+  SQHandle         *pQuery;
   SShowMgmt         showMgmt;
   SProfileMgmt      profileMgmt;
   STelemMgmt        telemMgmt;
@@ -119,7 +122,7 @@ typedef struct SMnode {
   SHashObj         *infosMeta;
   SGrantInfo        grant;
   MndMsgFp          msgFp[TDMT_MAX];
-  SMsgCb            msgCb;
+  SMsgCb            msgCb;  
 } SMnode;
 
 void    mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp);

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

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_MND_QUERY_H_
+#define _TD_MND_QUERY_H_
+
+#include "mndInt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t  mndInitQuery(SMnode *pMnode);
+void     mndCleanupQuery(SMnode *pMnode);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_MND_QUERY_H_*/

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

@@ -158,7 +158,7 @@ static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw) {
 ACCT_DECODE_OVER:
   if (terrno != 0) {
     mError("acct:%s, failed to decode from raw:%p since %s", pAcct->acct, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 

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

@@ -126,7 +126,7 @@ static SSdbRow *mndBnodeActionDecode(SSdbRaw *pRaw) {
 BNODE_DECODE_OVER:
   if (terrno != 0) {
     mError("bnode:%d, failed to decode from raw:%p since %s", pObj->id, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 
@@ -191,7 +191,7 @@ static int32_t mndSetCreateBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   createReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -206,7 +206,7 @@ static int32_t mndSetCreateBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   action.acceptableCode = TSDB_CODE_NODE_ALREADY_DEPLOYED;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 
@@ -218,7 +218,7 @@ static int32_t mndSetCreateBnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
   dropReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -233,7 +233,7 @@ static int32_t mndSetCreateBnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
   action.acceptableCode = TSDB_CODE_NODE_NOT_DEPLOYED;
 
   if (mndTransAppendUndoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 
@@ -341,7 +341,7 @@ static int32_t mndSetDropBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SBn
   dropReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -356,7 +356,7 @@ static int32_t mndSetDropBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SBn
   action.acceptableCode = TSDB_CODE_NODE_NOT_DEPLOYED;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 

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

@@ -116,7 +116,7 @@ static SSdbRow *mndClusterActionDecode(SSdbRaw *pRaw) {
 CLUSTER_DECODE_OVER:
   if (terrno != 0) {
     mError("cluster:%" PRId64 ", failed to decode from raw:%p since %s", pCluster->id, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 

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

@@ -54,7 +54,7 @@ int32_t mndInitConsumer(SMnode *pMnode) {
 void mndCleanupConsumer(SMnode *pMnode) {}
 
 SMqConsumerObj *mndCreateConsumer(int64_t consumerId, const char *cgroup) {
-  SMqConsumerObj *pConsumer = calloc(1, sizeof(SMqConsumerObj));
+  SMqConsumerObj *pConsumer = taosMemoryCalloc(1, sizeof(SMqConsumerObj));
   if (pConsumer == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -79,7 +79,7 @@ SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
   SSdbRaw *pRaw = sdbAllocRaw(SDB_CONSUMER, MND_CONSUMER_VER_NUMBER, size);
   if (pRaw == NULL) goto CM_ENCODE_OVER;
 
-  buf = malloc(tlen);
+  buf = taosMemoryMalloc(tlen);
   if (buf == NULL) goto CM_ENCODE_OVER;
 
   void *abuf = buf;
@@ -94,7 +94,7 @@ SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
   terrno = TSDB_CODE_SUCCESS;
 
 CM_ENCODE_OVER:
-  tfree(buf);
+  taosMemoryFreeClear(buf);
   if (terrno != 0) {
     mError("consumer:%" PRId64 ", failed to encode to raw:%p since %s", pConsumer->consumerId, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -126,7 +126,7 @@ SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw) {
   int32_t dataPos = 0;
   int32_t len;
   SDB_GET_INT32(pRaw, dataPos, &len, CM_DECODE_OVER);
-  buf = malloc(len);
+  buf = taosMemoryMalloc(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);
@@ -138,10 +138,10 @@ SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_SUCCESS;
 
 CM_DECODE_OVER:
-  tfree(buf);
+  taosMemoryFreeClear(buf);
   if (terrno != TSDB_CODE_SUCCESS) {
     mError("consumer:%" PRId64 ", failed to decode from raw:%p since %s", pConsumer->consumerId, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 

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

@@ -193,7 +193,7 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
 DB_DECODE_OVER:
   if (terrno != 0) {
     mError("db:%s, failed to decode from raw:%p since %s", pDb->name, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 
@@ -370,7 +370,7 @@ static int32_t mndSetCreateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
       action.msgType = TDMT_DND_CREATE_VNODE;
       action.acceptableCode = TSDB_CODE_DND_VNODE_ALREADY_DEPLOYED;
       if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-        free(pReq);
+        taosMemoryFree(pReq);
         return -1;
       }
     }
@@ -401,7 +401,7 @@ static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
       action.msgType = TDMT_DND_DROP_VNODE;
       action.acceptableCode = TSDB_CODE_DND_VNODE_NOT_DEPLOYED;
       if (mndTransAppendUndoAction(pTrans, &action) != 0) {
-        free(pReq);
+        taosMemoryFree(pReq);
         return -1;
       }
     }
@@ -483,7 +483,7 @@ static int32_t mndCreateDb(SMnode *pMnode, SNodeMsg *pReq, SCreateDbReq *pCreate
   code = 0;
 
 CREATE_DB_OVER:
-  free(pVgroups);
+  taosMemoryFree(pVgroups);
   mndTransDrop(pTrans);
   return code;
 }
@@ -622,7 +622,7 @@ static int32_t mndBuildUpdateVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
     action.contLen = contLen;
     action.msgType = TDMT_DND_ALTER_VNODE;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       return -1;
     }
   }
@@ -802,7 +802,7 @@ static int32_t mndBuildDropVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *
     action.msgType = TDMT_DND_DROP_VNODE;
     action.acceptableCode = TSDB_CODE_DND_VNODE_NOT_DEPLOYED;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       return -1;
     }
   }
@@ -845,7 +845,7 @@ static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bo
   if (useRpcMalloc) {
     pRsp = rpcMallocCont(rspLen);
   } else {
-    pRsp = malloc(rspLen);
+    pRsp = taosMemoryMalloc(rspLen);
   }
 
   if (pRsp == NULL) {
@@ -1034,7 +1034,9 @@ static int32_t mndProcessUseDbReq(SNodeMsg *pReq) {
       usedbRsp.vgVersion = usedbReq.vgVersion;
       code = 0;
     }
-    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);    
+    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);  
+
+    // no jump, need to construct rsp
   } else {
     pDb = mndAcquireDb(pMnode, usedbReq.db);
     if (pDb == NULL) {
@@ -1156,7 +1158,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
   }
 
   int32_t rspLen = tSerializeSUseDbBatchRsp(NULL, 0, &batchUseRsp);
-  void   *pRsp = malloc(rspLen);
+  void   *pRsp = taosMemoryMalloc(rspLen);
   if (pRsp == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     tFreeSUseDbBatchRsp(&batchUseRsp);

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

@@ -164,7 +164,7 @@ static SSdbRow *mndDnodeActionDecode(SSdbRaw *pRaw) {
 DNODE_DECODE_OVER:
   if (terrno != 0) {
     mError("dnode:%d, failed to decode from raw:%p since %s", pDnode->id, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 

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

@@ -127,8 +127,8 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, FUNC_DECODE_OVER)
   SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, FUNC_DECODE_OVER)
 
-  pFunc->pComment = calloc(1, pFunc->commentSize);
-  pFunc->pCode = calloc(1, pFunc->codeSize);
+  pFunc->pComment = taosMemoryCalloc(1, pFunc->commentSize);
+  pFunc->pCode = taosMemoryCalloc(1, pFunc->codeSize);
   if (pFunc->pComment == NULL || pFunc->pCode == NULL) {
     goto FUNC_DECODE_OVER;
   }
@@ -142,7 +142,7 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
 FUNC_DECODE_OVER:
   if (terrno != 0) {
     mError("func:%s, failed to decode from raw:%p since %s", pFunc->name, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 
@@ -157,8 +157,8 @@ static int32_t mndFuncActionInsert(SSdb *pSdb, SFuncObj *pFunc) {
 
 static int32_t mndFuncActionDelete(SSdb *pSdb, SFuncObj *pFunc) {
   mTrace("func:%s, perform delete action, row:%p", pFunc->name, pFunc);
-  tfree(pFunc->pCode);
-  tfree(pFunc->pComment);
+  taosMemoryFreeClear(pFunc->pCode);
+  taosMemoryFreeClear(pFunc->pComment);
   return 0;
 }
 
@@ -196,8 +196,8 @@ static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCr
   func.signature = pCreate->signature;
   func.commentSize = pCreate->commentSize;
   func.codeSize = pCreate->codeSize;
-  func.pComment = malloc(func.commentSize);
-  func.pCode = malloc(func.codeSize);
+  func.pComment = taosMemoryMalloc(func.commentSize);
+  func.pCode = taosMemoryMalloc(func.codeSize);
   if (func.pCode == NULL || func.pCode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto CREATE_FUNC_OVER;
@@ -228,8 +228,8 @@ static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCr
   code = 0;
 
 CREATE_FUNC_OVER:
-  free(func.pCode);
-  free(func.pComment);
+  taosMemoryFree(func.pCode);
+  taosMemoryFree(func.pComment);
   mndTransDrop(pTrans);
   return code;
 }

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

@@ -19,6 +19,7 @@
 #define SYSTABLE_SCH_TABLE_NAME_LEN ((TSDB_TABLE_NAME_LEN - 1) + VARSTR_HEADER_SIZE)
 #define SYSTABLE_SCH_DB_NAME_LEN    ((TSDB_DB_NAME_LEN - 1) + VARSTR_HEADER_SIZE)
 
+//!!!! Note: only APPEND columns in below tables, NO insert !!!!
 static const SInfosTableSchema dnodesSchema[] = {{.name = "id",             .bytes = 2,   .type = TSDB_DATA_TYPE_SMALLINT},
                                                  {.name = "endpoint",       .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY},
                                                  {.name = "vnodes",         .bytes = 2,   .type = TSDB_DATA_TYPE_SMALLINT},
@@ -152,7 +153,7 @@ static const SInfosTableMeta infosMeta[] = {{TSDB_INS_TABLE_DNODES, dnodesSchema
 
 //connection/application/
 int32_t mndInitInfosTableSchema(const SInfosTableSchema *pSrc, int32_t colNum, SSchema **pDst) {
-  SSchema *schema = calloc(colNum, sizeof(SSchema));
+  SSchema *schema = taosMemoryCalloc(colNum, sizeof(SSchema));
   if (NULL == schema) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -210,7 +211,7 @@ int32_t mndBuildInsTableSchema(SMnode *pMnode, const char *dbFName, const char *
 
   *pRsp = *meta;
   
-  pRsp->pSchemas = calloc(meta->numOfColumns, sizeof(SSchema));
+  pRsp->pSchemas = taosMemoryCalloc(meta->numOfColumns, sizeof(SSchema));
   if (pRsp->pSchemas == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     pRsp->pSchemas = NULL;
@@ -241,7 +242,7 @@ void mndCleanupInfos(SMnode *pMnode) {
   while (pIter) {
     STableMetaRsp *meta = (STableMetaRsp *)pIter;
 
-    tfree(meta->pSchemas);
+    taosMemoryFreeClear(meta->pSchemas);
     
     pIter = taosHashIterate(pMnode->infosMeta, pIter);
   }

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

@@ -180,7 +180,7 @@ static SSdbRow *mndMnodeActionDecode(SSdbRaw *pRaw) {
 MNODE_DECODE_OVER:
   if (terrno != 0) {
     mError("mnode:%d, failed to decode from raw:%p since %s", pObj->id, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 
@@ -313,7 +313,7 @@ static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDno
 
     createReq.dnodeId = pMObj->id;
     int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, &createReq);
-    void   *pReq = malloc(contLen);
+    void   *pReq = taosMemoryMalloc(contLen);
     tSerializeSDCreateMnodeReq(pReq, contLen, &createReq);
 
     action.epSet = mndGetDnodeEpset(pMObj->pDnode);
@@ -323,7 +323,7 @@ static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDno
     action.acceptableCode = TSDB_CODE_NODE_ALREADY_DEPLOYED;
 
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pMObj);
       return -1;
@@ -338,7 +338,7 @@ static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDno
 
     createReq.dnodeId = pObj->id;
     int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, &createReq);
-    void   *pReq = malloc(contLen);
+    void   *pReq = taosMemoryMalloc(contLen);
     tSerializeSDCreateMnodeReq(pReq, contLen, &createReq);
 
     action.epSet = mndGetDnodeEpset(pDnode);
@@ -347,7 +347,7 @@ static int32_t mndSetCreateMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDno
     action.msgType = TDMT_DND_CREATE_MNODE;
     action.acceptableCode = TSDB_CODE_NODE_ALREADY_DEPLOYED;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       return -1;
     }
   }
@@ -483,7 +483,7 @@ static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnode
 
       alterReq.dnodeId = pMObj->id;
       int32_t contLen = tSerializeSDCreateMnodeReq(NULL, 0, &alterReq);
-      void   *pReq = malloc(contLen);
+      void   *pReq = taosMemoryMalloc(contLen);
       tSerializeSDCreateMnodeReq(pReq, contLen, &alterReq);
 
       action.epSet = mndGetDnodeEpset(pMObj->pDnode);
@@ -493,7 +493,7 @@ static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnode
       action.acceptableCode = TSDB_CODE_NODE_ALREADY_DEPLOYED;
 
       if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-        free(pReq);
+        taosMemoryFree(pReq);
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pMObj);
         return -1;
@@ -510,7 +510,7 @@ static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnode
     SDDropMnodeReq dropReq = {0};
     dropReq.dnodeId = pObj->id;
     int32_t contLen = tSerializeSMCreateDropMnodeReq(NULL, 0, &dropReq);
-    void   *pReq = malloc(contLen);
+    void   *pReq = taosMemoryMalloc(contLen);
     tSerializeSMCreateDropMnodeReq(pReq, contLen, &dropReq);
 
     action.epSet = mndGetDnodeEpset(pDnode);
@@ -519,7 +519,7 @@ static int32_t mndSetDropMnodeRedoActions(SMnode *pMnode, STrans *pTrans, SDnode
     action.msgType = TDMT_DND_DROP_MNODE;
     action.acceptableCode = TSDB_CODE_NODE_NOT_DEPLOYED;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       return -1;
     }
   }

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

@@ -59,7 +59,7 @@ SSdbRaw *mndOffsetActionEncode(SMqOffsetObj *pOffset) {
   SSdbRaw *pRaw = sdbAllocRaw(SDB_OFFSET, MND_OFFSET_VER_NUMBER, size);
   if (pRaw == NULL) goto OFFSET_ENCODE_OVER;
 
-  buf = malloc(tlen);
+  buf = taosMemoryMalloc(tlen);
   if (buf == NULL) goto OFFSET_ENCODE_OVER;
 
   void *abuf = buf;
@@ -74,7 +74,7 @@ SSdbRaw *mndOffsetActionEncode(SMqOffsetObj *pOffset) {
   terrno = TSDB_CODE_SUCCESS;
 
 OFFSET_ENCODE_OVER:
-  tfree(buf);
+  taosMemoryFreeClear(buf);
   if (terrno != TSDB_CODE_SUCCESS) {
     mError("offset:%s, failed to encode to raw:%p since %s", pOffset->key, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -107,7 +107,7 @@ SSdbRow *mndOffsetActionDecode(SSdbRaw *pRaw) {
   int32_t dataPos = 0;
   int32_t tlen;
   SDB_GET_INT32(pRaw, dataPos, &tlen, OFFSET_DECODE_OVER);
-  buf = malloc(tlen + 1);
+  buf = taosMemoryMalloc(tlen + 1);
   if (buf == NULL) goto OFFSET_DECODE_OVER;
   SDB_GET_BINARY(pRaw, dataPos, buf, tlen, OFFSET_DECODE_OVER);
   SDB_GET_RESERVE(pRaw, dataPos, MND_OFFSET_RESERVE_SIZE, OFFSET_DECODE_OVER);
@@ -119,10 +119,10 @@ SSdbRow *mndOffsetActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_SUCCESS;
 
 OFFSET_DECODE_OVER:
-  tfree(buf);
+  taosMemoryFreeClear(buf);
   if (terrno != TSDB_CODE_SUCCESS) {
     mError("offset:%s, failed to decode from raw:%p since %s", pOffset->key, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 

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

@@ -130,7 +130,7 @@ static SConnObj *mndCreateConn(SMnode *pMnode, SRpcConnInfo *pInfo, int32_t pid,
 }
 
 static void mndFreeConn(SConnObj *pConn) {
-  tfree(pConn->pQueries);
+  taosMemoryFreeClear(pConn->pQueries);
   mTrace("conn:%d, is destroyed, data:%p", pConn->id, pConn);
 }
 
@@ -260,7 +260,7 @@ static int32_t mndSaveQueryStreamList(SConnObj *pConn, SHeartBeatReq *pReq) {
 
   if (numOfQueries > 0) {
     if (pConn->pQueries == NULL) {
-      pConn->pQueries = calloc(sizeof(SQueryDesc), QUERY_SAVE_SIZE);
+      pConn->pQueries = taosMemoryCalloc(sizeof(SQueryDesc), QUERY_SAVE_SIZE);
     }
 
     pConn->numOfQueries = TMIN(QUERY_SAVE_SIZE, numOfQueries);
@@ -276,7 +276,7 @@ static int32_t mndSaveQueryStreamList(SConnObj *pConn, SHeartBeatReq *pReq) {
 
 static SClientHbRsp *mndMqHbBuildRsp(SMnode *pMnode, SClientHbReq *pReq) {
 #if 0
-  SClientHbRsp* pRsp = malloc(sizeof(SClientHbRsp));
+  SClientHbRsp* pRsp = taosMemoryMalloc(sizeof(SClientHbRsp));
   if (pRsp == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -292,7 +292,7 @@ static SClientHbRsp *mndMqHbBuildRsp(SMnode *pMnode, SClientHbReq *pReq) {
   SHashObj* pObj =  pReq->info;
   SKv* pKv = taosHashGet(pObj, "mq-tmp", strlen("mq-tmp") + 1);
   if (pKv == NULL) {
-    free(pRsp);
+    taosMemoryFree(pRsp);
     return NULL;
   }
   SMqHbMsg mqHb;
@@ -325,7 +325,7 @@ static SClientHbRsp *mndMqHbBuildRsp(SMnode *pMnode, SClientHbReq *pReq) {
     taosArrayPush(batchRsp.batchRsps, &innerBatchRsp);
   }
   int32_t tlen = taosEncodeSMqHbBatchRsp(NULL, &batchRsp);
-  void* buf = malloc(tlen);
+  void* buf = taosMemoryMalloc(tlen);
   if (buf == NULL) {
     //TODO
     return NULL;
@@ -402,7 +402,7 @@ static int32_t mndProcessHeartBeatReq(SNodeMsg *pReq) {
       SClientHbRsp *pRsp = mndMqHbBuildRsp(pMnode, pHbReq);
       if (pRsp != NULL) {
         taosArrayPush(batchRsp.rsps, pRsp);
-        free(pRsp);
+        taosMemoryFree(pRsp);
       }
     }
   }
@@ -418,7 +418,7 @@ static int32_t mndProcessHeartBeatReq(SNodeMsg *pReq) {
     int32_t       kvNum = (rsp->info) ? taosArrayGetSize(rsp->info) : 0;
     for (int32_t n = 0; n < kvNum; ++n) {
       SKv *kv = taosArrayGet(rsp->info, n);
-      tfree(kv->value);
+      taosMemoryFreeClear(kv->value);
     }
     taosArrayDestroy(rsp->info);
   }

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

@@ -128,7 +128,7 @@ static SSdbRow *mndQnodeActionDecode(SSdbRaw *pRaw) {
 QNODE_DECODE_OVER:
   if (terrno != 0) {
     mError("qnode:%d, failed to decode from raw:%p since %s", pObj->id, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 
@@ -193,7 +193,7 @@ static int32_t mndSetCreateQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   createReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -208,7 +208,7 @@ static int32_t mndSetCreateQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   action.acceptableCode = TSDB_CODE_NODE_ALREADY_DEPLOYED;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 
@@ -220,7 +220,7 @@ static int32_t mndSetCreateQnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
   dropReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -235,7 +235,7 @@ static int32_t mndSetCreateQnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
   action.acceptableCode = TSDB_CODE_NODE_NOT_DEPLOYED;
 
   if (mndTransAppendUndoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 
@@ -343,7 +343,7 @@ static int32_t mndSetDropQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SQn
   dropReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -358,7 +358,7 @@ static int32_t mndSetDropQnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SQn
   action.acceptableCode = TSDB_CODE_NODE_NOT_DEPLOYED;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 
@@ -474,7 +474,7 @@ static int32_t mndProcessQnodeListReq(SNodeMsg *pReq) {
   }
 
   int32_t rspLen = tSerializeSQnodeListRsp(NULL, 0, &qlistRsp);
-  void   *pRsp = malloc(rspLen);
+  void   *pRsp = taosMemoryMalloc(rspLen);
   if (pRsp == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto QNODE_LIST_OVER;

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

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mndQuery.h"
+#include "mndMnode.h"
+#include "executor.h"
+#include "qworker.h"
+
+int32_t mndProcessQueryMsg(SNodeMsg *pReq) {
+  mTrace("message in query queue is processing");
+  SMnode *pMnode = pReq->pNode;
+  SReadHandle handle = {0};
+
+  switch (pReq->rpcMsg.msgType) {
+    case TDMT_VND_QUERY:
+      return qWorkerProcessQueryMsg(&handle, pMnode->pQuery, &pReq->rpcMsg);
+    case TDMT_VND_QUERY_CONTINUE:
+      return qWorkerProcessCQueryMsg(&handle, pMnode->pQuery, &pReq->rpcMsg);
+    default:
+      mError("unknown msg type:%d in query queue", pReq->rpcMsg.msgType);
+      return TSDB_CODE_VND_APP_ERROR;
+  }
+}
+
+int32_t mndProcessFetchMsg(SNodeMsg *pReq) {
+  mTrace("message in fetch queue is processing");
+  SMnode *pMnode = pReq->pNode;
+  
+  switch (pReq->rpcMsg.msgType) {
+    case TDMT_VND_FETCH:
+      return qWorkerProcessFetchMsg(pMnode, pMnode->pQuery, &pReq->rpcMsg);
+    case TDMT_VND_DROP_TASK:
+      return qWorkerProcessDropMsg(pMnode, pMnode->pQuery, &pReq->rpcMsg);
+    case TDMT_VND_QUERY_HEARTBEAT:
+      return qWorkerProcessHbMsg(pMnode, pMnode->pQuery, &pReq->rpcMsg);
+    default:
+      mError("unknown msg type:%d in fetch queue", pReq->rpcMsg.msgType);
+      return TSDB_CODE_VND_APP_ERROR;
+  }
+}
+
+int32_t mndInitQuery(SMnode *pMnode) {
+  int32_t code = qWorkerInit(NODE_TYPE_MNODE, MND_VGID, NULL, (void **)&pMnode->pQuery, &pMnode->msgCb);
+  if (code) {
+    return code;
+  }
+
+  mndSetMsgHandle(pMnode, TDMT_VND_QUERY, mndProcessQueryMsg);
+  mndSetMsgHandle(pMnode, TDMT_VND_QUERY_CONTINUE, mndProcessQueryMsg);
+  mndSetMsgHandle(pMnode, TDMT_VND_FETCH, mndProcessFetchMsg);
+  mndSetMsgHandle(pMnode, TDMT_VND_DROP_TASK, mndProcessFetchMsg);
+  mndSetMsgHandle(pMnode, TDMT_VND_QUERY_HEARTBEAT, mndProcessFetchMsg);
+
+  return 0;
+}
+
+void mndCleanupQuery(SMnode *pMnode) { qWorkerDestroy((void **)&pMnode->pQuery); }
+

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

@@ -41,12 +41,12 @@ int32_t mndPersistTaskDeployReq(STrans* pTrans, SStreamTask* pTask, const SEpSet
   int32_t size = encoder.pos;
   int32_t tlen = sizeof(SMsgHead) + size;
   tCoderClear(&encoder);
-  void* buf = malloc(tlen);
+  void* buf = taosMemoryMalloc(tlen);
   if (buf == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
-  ((SMsgHead*)buf)->streamTaskId = htonl(nodeId);
+  ((SMsgHead*)buf)->vgId = htonl(nodeId);
   void* abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, abuf, size, TD_ENCODER);
   tEncodeSStreamTask(&encoder, pTask);
@@ -58,7 +58,7 @@ int32_t mndPersistTaskDeployReq(STrans* pTrans, SStreamTask* pTask, const SEpSet
   action.contLen = tlen;
   action.msgType = type;
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    free(buf);
+    taosMemoryFree(buf);
     return -1;
   }
   return 0;
@@ -66,10 +66,13 @@ int32_t mndPersistTaskDeployReq(STrans* pTrans, SStreamTask* pTask, const SEpSet
 
 int32_t mndAssignTaskToVg(SMnode* pMnode, STrans* pTrans, SStreamTask* pTask, SSubplan* plan, const SVgObj* pVgroup) {
   int32_t msgLen;
+  pTask->nodeId = pVgroup->vgId;
+  pTask->epSet = mndGetVgroupEpset(pMnode, pVgroup);
+
   plan->execNode.nodeId = pVgroup->vgId;
-  plan->execNode.epSet = mndGetVgroupEpset(pMnode, pVgroup);
+  plan->execNode.epSet = pTask->epSet;
 
-  if (qSubPlanToString(plan, &pTask->qmsg, &msgLen) < 0) {
+  if (qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen) < 0) {
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
     return -1;
   }
@@ -86,10 +89,14 @@ SSnodeObj* mndSchedFetchSnode(SMnode* pMnode) {
 int32_t mndAssignTaskToSnode(SMnode* pMnode, STrans* pTrans, SStreamTask* pTask, SSubplan* plan,
                              const SSnodeObj* pSnode) {
   int32_t msgLen;
-  plan->execNode.nodeId = pSnode->id;
-  plan->execNode.epSet = mndAcquireEpFromSnode(pMnode, pSnode);
 
-  if (qSubPlanToString(plan, &pTask->qmsg, &msgLen) < 0) {
+  pTask->nodeId = 0;
+  pTask->epSet = mndAcquireEpFromSnode(pMnode, pSnode);
+
+  plan->execNode.nodeId = 0;
+  plan->execNode.epSet = pTask->epSet;
+
+  if (qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen) < 0) {
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
     return -1;
   }
@@ -97,9 +104,23 @@ int32_t mndAssignTaskToSnode(SMnode* pMnode, STrans* pTrans, SStreamTask* pTask,
   return 0;
 }
 
+SVgObj* mndSchedFetchOneVg(SMnode* pMnode, int64_t dbUid) {
+  void*   pIter = NULL;
+  SVgObj* pVgroup = NULL;
+  while (1) {
+    pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
+    if (pIter == NULL) break;
+    if (pVgroup->dbUid != dbUid) {
+      sdbRelease(pMnode->pSdb, pVgroup);
+      continue;
+    }
+    return pVgroup;
+  }
+  return pVgroup;
+}
+
 int32_t mndScheduleStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStream) {
   SSdb*       pSdb = pMnode->pSdb;
-  SVgObj*     pVgroup = NULL;
   SQueryPlan* pPlan = qStringToQueryPlan(pStream->physicalPlan);
   if (pPlan == NULL) {
     terrno = TSDB_CODE_QRY_INVALID_INPUT;
@@ -108,74 +129,144 @@ int32_t mndScheduleStream(SMnode* pMnode, STrans* pTrans, SStreamObj* pStream) {
   ASSERT(pStream->vgNum == 0);
 
   int32_t totLevel = LIST_LENGTH(pPlan->pSubplans);
-  pStream->tasks = taosArrayInit(totLevel, sizeof(SArray));
-  int32_t lastUsedVgId = 0;
+  ASSERT(totLevel <= 2);
+  pStream->tasks = taosArrayInit(totLevel, sizeof(void*));
 
   for (int32_t level = 0; level < totLevel; level++) {
-    SArray*        taskOneLevel = taosArrayInit(0, sizeof(SStreamTask));
+    SArray*        taskOneLevel = taosArrayInit(0, sizeof(void*));
     SNodeListNode* inner = nodesListGetNode(pPlan->pSubplans, level);
-    int32_t        opNum = LIST_LENGTH(inner->pNodeList);
-    ASSERT(opNum == 1);
+    ASSERT(LIST_LENGTH(inner->pNodeList) == 1);
 
     SSubplan* plan = nodesListGetNode(inner->pNodeList, 0);
-    if (level == 0) {
+
+    // if (level == totLevel - 1 /* or no snode */) {
+    if (level == totLevel - 1) {
+      // last level, source, must assign to vnode
+      // must be scan type
       ASSERT(plan->subplanType == SUBPLAN_TYPE_SCAN);
+
+      // replicate task to each vnode
       void* pIter = NULL;
       while (1) {
+        SVgObj* pVgroup;
         pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
         if (pIter == NULL) break;
         if (pVgroup->dbUid != pStream->dbUid) {
           sdbRelease(pSdb, pVgroup);
           continue;
         }
+        SStreamTask* pTask = tNewSStreamTask(pStream->uid);
+        // source part
+        pTask->sourceType = TASK_SOURCE__SCAN;
+
+        // sink part
+        if (level == 0) {
+          // only for inplace
+          pTask->sinkType = TASK_SINK__SHOW;
+          pTask->showSink.reserved = 0;
+        } else {
+          pTask->sinkType = TASK_SINK__NONE;
+        }
 
-        lastUsedVgId = pVgroup->vgId;
-        pStream->vgNum++;
+        // dispatch part
+        if (level == 0) {
+          pTask->dispatchType = TASK_DISPATCH__NONE;
+          // if inplace sink, no dispatcher
+          // if fixed ep, add fixed ep dispatcher
+          // if shuffle, add shuffle dispatcher
+        } else {
+          // add fixed ep dispatcher
+          int32_t lastLevel = level - 1;
+          ASSERT(lastLevel == 0);
+          SArray* pArray = taosArrayGetP(pStream->tasks, lastLevel);
+          // one merge only
+          ASSERT(taosArrayGetSize(pArray) == 1);
+          SStreamTask* lastLevelTask = taosArrayGetP(pArray, lastLevel);
+          pTask->dispatchMsgType = TDMT_VND_TASK_MERGE_EXEC;
+          pTask->dispatchType = TASK_DISPATCH__FIXED;
 
-        SStreamTask* pTask = streamTaskNew(pStream->uid);
-        pTask->level = level;
-        pTask->sourceType = 1;
-        pTask->sinkType = level == totLevel - 1 ? 1 : 0;
-        pTask->parallelizable = 1;
+          pTask->fixedEpDispatcher.nodeId = lastLevelTask->nodeId;
+          pTask->fixedEpDispatcher.epSet = lastLevelTask->epSet;
+        }
+
+        // exec part
+        pTask->execType = TASK_EXEC__PIPE;
+        pTask->exec.parallelizable = 1;
         if (mndAssignTaskToVg(pMnode, pTrans, pTask, plan, pVgroup) < 0) {
           sdbRelease(pSdb, pVgroup);
           qDestroyQueryPlan(pPlan);
           return -1;
         }
-        taosArrayPush(taskOneLevel, pTask);
+        sdbRelease(pSdb, pVgroup);
+        taosArrayPush(taskOneLevel, &pTask);
       }
     } else {
-      SStreamTask* pTask = streamTaskNew(pStream->uid);
-      pTask->level = level;
-      pTask->sourceType = 0;
-      pTask->sinkType = level == totLevel - 1 ? 1 : 0;
-      pTask->parallelizable = plan->subplanType == SUBPLAN_TYPE_SCAN;
-      pTask->nextOpDst = STREAM_NEXT_OP_DST__VND;
-
-      SSnodeObj* pSnode = mndSchedFetchSnode(pMnode);
-      if (pSnode == NULL || tsStreamSchedV) {
-        ASSERT(lastUsedVgId != 0);
-        SVgObj* pVg = mndAcquireVgroup(pMnode, lastUsedVgId);
-        if (mndAssignTaskToVg(pMnode, pTrans, pTask, plan, pVg) < 0) {
-          sdbRelease(pSdb, pVg);
-          qDestroyQueryPlan(pPlan);
-          return -1;
-        }
-        sdbRelease(pSdb, pVg);
-      } else {
-        if (mndAssignTaskToSnode(pMnode, pTrans, pTask, plan, pSnode) < 0) {
-          sdbRelease(pSdb, pSnode);
-          qDestroyQueryPlan(pPlan);
-          return -1;
-        }
+      // merge plan
+
+      // TODO if has snode, assign to snode
+
+      // else, assign to vnode
+      ASSERT(plan->subplanType == SUBPLAN_TYPE_MERGE);
+      SStreamTask* pTask = tNewSStreamTask(pStream->uid);
+
+      // source part, currently only support multi source
+      pTask->sourceType = TASK_SOURCE__PIPE;
+
+      // sink part
+      pTask->sinkType = TASK_SINK__SHOW;
+      /*pTask->sinkType = TASK_SINK__NONE;*/
+
+      // dispatch part
+      pTask->dispatchType = TASK_DISPATCH__SHUFFLE;
+      pTask->dispatchMsgType = TDMT_VND_TASK_WRITE_EXEC;
+
+      // exec part
+      pTask->execType = TASK_EXEC__MERGE;
+      pTask->exec.parallelizable = 0;
+      SVgObj* pVgroup = mndSchedFetchOneVg(pMnode, pStream->dbUid);
+      ASSERT(pVgroup);
+      if (mndAssignTaskToVg(pMnode, pTrans, pTask, plan, pVgroup) < 0) {
+        sdbRelease(pSdb, pVgroup);
+        qDestroyQueryPlan(pPlan);
+        return -1;
+      }
+      sdbRelease(pSdb, pVgroup);
+      taosArrayPush(taskOneLevel, &pTask);
+    }
+
+    taosArrayPush(pStream->tasks, &taskOneLevel);
+  }
+
+  if (totLevel == 2) {
+    void* pIter = NULL;
+    while (1) {
+      SVgObj* pVgroup;
+      pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
+      if (pIter == NULL) break;
+      if (pVgroup->dbUid != pStream->dbUid) {
+        sdbRelease(pSdb, pVgroup);
+        continue;
       }
-      sdbRelease(pMnode->pSdb, pSnode);
+      SStreamTask* pTask = tNewSStreamTask(pStream->uid);
 
-      taosArrayPush(taskOneLevel, pTask);
+      // source part
+      pTask->sourceType = TASK_SOURCE__MERGE;
+
+      // sink part
+      pTask->sinkType = TASK_SINK__SHOW;
+
+      // dispatch part
+      pTask->dispatchType = TASK_DISPATCH__NONE;
+
+      // exec part
+      pTask->execType = TASK_EXEC__NONE;
+      pTask->exec.parallelizable = 0;
     }
-    taosArrayPush(pStream->tasks, taskOneLevel);
   }
+
+  // free memory
   qDestroyQueryPlan(pPlan);
+
   return 0;
 }
 

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

@@ -146,7 +146,7 @@ static int32_t mndProcessShowReq(SNodeMsg *pReq) {
   }
 
   showRsp.showId = pShow->id;
-  showRsp.tableMeta.pSchemas = calloc(TSDB_MAX_COLUMNS, sizeof(SSchema));
+  showRsp.tableMeta.pSchemas = taosMemoryCalloc(TSDB_MAX_COLUMNS, sizeof(SSchema));
   if (showRsp.tableMeta.pSchemas == NULL) {
     mndReleaseShowObj(pShow, true);
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -357,6 +357,13 @@ static int32_t mndProcessRetrieveSysTableReq(SNodeMsg *pReq) {
   // if free flag is set, client wants to clean the resources
   if ((retrieveReq.free & TSDB_QUERY_TYPE_FREE_RESOURCE) != TSDB_QUERY_TYPE_FREE_RESOURCE) {
     rowsRead = (*retrieveFp)(pReq, (SShowObj*) pShow, pRsp->data, rowsToRead);
+    if (rowsRead < 0) {
+      terrno = rowsRead;
+      rpcFreeCont(pRsp);
+      mDebug("show:0x%" PRIx64 ", retrieve completed", pShow->id);
+      mndReleaseShowObj((SShowObj*) pShow, true);
+      return -1;
+    }
   }
 
   mDebug("show:0x%" PRIx64 ", stop retrieve data, rowsRead:%d rowsToRead:%d", pShow->id, rowsRead, rowsToRead);

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

@@ -160,25 +160,25 @@ static SSdbRow *mndSmaActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT32(pRaw, dataPos, &pSma->astLen, _OVER)
 
   if (pSma->exprLen > 0) {
-    pSma->expr = calloc(pSma->exprLen, 1);
+    pSma->expr = taosMemoryCalloc(pSma->exprLen, 1);
     if (pSma->expr == NULL) goto _OVER;
     SDB_GET_BINARY(pRaw, dataPos, pSma->expr, pSma->exprLen, _OVER)
   }
 
   if (pSma->tagsFilterLen > 0) {
-    pSma->tagsFilter = calloc(pSma->tagsFilterLen, 1);
+    pSma->tagsFilter = taosMemoryCalloc(pSma->tagsFilterLen, 1);
     if (pSma->tagsFilter == NULL) goto _OVER;
     SDB_GET_BINARY(pRaw, dataPos, pSma->tagsFilter, pSma->tagsFilterLen, _OVER)
   }
 
   if (pSma->sqlLen > 0) {
-    pSma->sql = calloc(pSma->sqlLen, 1);
+    pSma->sql = taosMemoryCalloc(pSma->sqlLen, 1);
     if (pSma->sql == NULL) goto _OVER;
     SDB_GET_BINARY(pRaw, dataPos, pSma->sql, pSma->sqlLen, _OVER)
   }
 
   if (pSma->astLen > 0) {
-    pSma->ast = calloc(pSma->astLen, 1);
+    pSma->ast = taosMemoryCalloc(pSma->astLen, 1);
     if (pSma->ast == NULL) goto _OVER;
     SDB_GET_BINARY(pRaw, dataPos, pSma->ast, pSma->astLen, _OVER)
   }
@@ -189,9 +189,9 @@ static SSdbRow *mndSmaActionDecode(SSdbRaw *pRaw) {
 _OVER:
   if (terrno != 0) {
     mError("sma:%s, failed to decode from raw:%p since %s", pSma->name, pRaw, terrstr());
-    tfree(pSma->expr);
-    tfree(pSma->tagsFilter);
-    tfree(pRow);
+    taosMemoryFreeClear(pSma->expr);
+    taosMemoryFreeClear(pSma->tagsFilter);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 
@@ -206,8 +206,8 @@ static int32_t mndSmaActionInsert(SSdb *pSdb, SSmaObj *pSma) {
 
 static int32_t mndSmaActionDelete(SSdb *pSdb, SSmaObj *pSma) {
   mTrace("sma:%s, perform delete action, row:%p", pSma->name, pSma);
-  tfree(pSma->tagsFilter);
-  tfree(pSma->expr);
+  taosMemoryFreeClear(pSma->tagsFilter);
+  taosMemoryFreeClear(pSma->expr);
   return 0;
 }
 
@@ -261,7 +261,7 @@ static void *mndBuildVCreateSmaReq(SMnode *pMnode, SVgObj *pVgroup, SSmaObj *pSm
   req.tSma.tagsFilter = pSma->tagsFilter;
 
   int32_t   contLen = tSerializeSVCreateTSmaReq(NULL, &req) + sizeof(SMsgHead);
-  SMsgHead *pHead = malloc(contLen);
+  SMsgHead *pHead = taosMemoryMalloc(contLen);
   if (pHead == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -287,7 +287,7 @@ static void *mndBuildVDropSmaReq(SMnode *pMnode, SVgObj *pVgroup, SSmaObj *pSma,
   tstrncpy(req.indexName, (char *)tNameGetTableName(&name), TSDB_INDEX_NAME_LEN);
 
   int32_t   contLen = tSerializeSVDropTSmaReq(NULL, &req) + sizeof(SMsgHead);
-  SMsgHead *pHead = malloc(contLen);
+  SMsgHead *pHead = taosMemoryMalloc(contLen);
   if (pHead == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -349,7 +349,7 @@ static int32_t mndSetCreateSmaRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     action.contLen = contLen;
     action.msgType = TDMT_VND_CREATE_SMA;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
       return -1;
@@ -382,25 +382,25 @@ static int32_t mndCreateSma(SMnode *pMnode, SNodeMsg *pReq, SMCreateSmaReq *pCre
   smaObj.astLen = pCreate->astLen;
 
   if (smaObj.exprLen > 0) {
-    smaObj.expr = malloc(smaObj.exprLen);
+    smaObj.expr = taosMemoryMalloc(smaObj.exprLen);
     if (smaObj.expr == NULL) goto _OVER;
     memcpy(smaObj.expr, pCreate->expr, smaObj.exprLen);
   }
 
   if (smaObj.tagsFilterLen > 0) {
-    smaObj.tagsFilter = malloc(smaObj.tagsFilterLen);
+    smaObj.tagsFilter = taosMemoryMalloc(smaObj.tagsFilterLen);
     if (smaObj.tagsFilter == NULL) goto _OVER;
     memcpy(smaObj.tagsFilter, pCreate->tagsFilter, smaObj.tagsFilterLen);
   }
 
   if (smaObj.sqlLen > 0) {
-    smaObj.sql = malloc(smaObj.sqlLen);
+    smaObj.sql = taosMemoryMalloc(smaObj.sqlLen);
     if (smaObj.sql == NULL) goto _OVER;
     memcpy(smaObj.sql, pCreate->sql, smaObj.sqlLen);
   }
 
   if (smaObj.astLen > 0) {
-    smaObj.ast = malloc(smaObj.astLen);
+    smaObj.ast = taosMemoryMalloc(smaObj.astLen);
     if (smaObj.ast == NULL) goto _OVER;
     memcpy(smaObj.ast, pCreate->ast, smaObj.astLen);
   }
@@ -596,7 +596,7 @@ static int32_t mndSetDropSmaRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
     action.msgType = TDMT_VND_DROP_SMA;
     action.acceptableCode = TSDB_CODE_VND_SMA_NOT_EXIST;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
       return -1;

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

@@ -135,7 +135,7 @@ static SSdbRow *mndSnodeActionDecode(SSdbRaw *pRaw) {
 SNODE_DECODE_OVER:
   if (terrno != 0) {
     mError("snode:%d, failed to decode from raw:%p since %s", pObj->id, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 
@@ -200,7 +200,7 @@ static int32_t mndSetCreateSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   createReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &createReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -215,7 +215,7 @@ static int32_t mndSetCreateSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S
   action.acceptableCode = TSDB_CODE_NODE_ALREADY_DEPLOYED;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 
@@ -227,7 +227,7 @@ static int32_t mndSetCreateSnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
   dropReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -242,7 +242,7 @@ static int32_t mndSetCreateSnodeUndoActions(STrans *pTrans, SDnodeObj *pDnode, S
   action.acceptableCode = TSDB_CODE_NODE_NOT_DEPLOYED;
 
   if (mndTransAppendUndoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 
@@ -352,7 +352,7 @@ static int32_t mndSetDropSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SSn
   dropReq.dnodeId = pDnode->id;
 
   int32_t contLen = tSerializeSMCreateDropQSBNodeReq(NULL, 0, &dropReq);
-  void   *pReq = malloc(contLen);
+  void   *pReq = taosMemoryMalloc(contLen);
   if (pReq == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -367,7 +367,7 @@ static int32_t mndSetDropSnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, SSn
   action.acceptableCode = TSDB_CODE_NODE_NOT_DEPLOYED;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-    free(pReq);
+    taosMemoryFree(pReq);
     return -1;
   }
 

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

@@ -175,9 +175,9 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT32(pRaw, dataPos, &pStb->numOfSmas, STB_DECODE_OVER)
   SDB_GET_INT32(pRaw, dataPos, &pStb->commentLen, STB_DECODE_OVER)
 
-  pStb->pColumns = calloc(pStb->numOfColumns, sizeof(SSchema));
-  pStb->pTags = calloc(pStb->numOfTags, sizeof(SSchema));
-  pStb->pSmas = calloc(pStb->numOfSmas, sizeof(SSchema));
+  pStb->pColumns = taosMemoryCalloc(pStb->numOfColumns, sizeof(SSchema));
+  pStb->pTags = taosMemoryCalloc(pStb->numOfTags, sizeof(SSchema));
+  pStb->pSmas = taosMemoryCalloc(pStb->numOfSmas, sizeof(SSchema));
   if (pStb->pColumns == NULL || pStb->pTags == NULL || pStb->pSmas == NULL) {
     goto STB_DECODE_OVER;
   }
@@ -207,7 +207,7 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
   }
 
   if (pStb->commentLen > 0) {
-    pStb->comment = calloc(pStb->commentLen, 1);
+    pStb->comment = taosMemoryCalloc(pStb->commentLen, 1);
     if (pStb->comment == NULL) goto STB_DECODE_OVER;
     SDB_GET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, STB_DECODE_OVER)
   }
@@ -218,10 +218,10 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
 STB_DECODE_OVER:
   if (terrno != 0) {
     mError("stb:%s, failed to decode from raw:%p since %s", pStb->name, pRaw, terrstr());
-    tfree(pStb->pColumns);
-    tfree(pStb->pTags);
-    tfree(pStb->comment);
-    tfree(pRow);
+    taosMemoryFreeClear(pStb->pColumns);
+    taosMemoryFreeClear(pStb->pTags);
+    taosMemoryFreeClear(pStb->comment);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 
@@ -236,9 +236,9 @@ static int32_t mndStbActionInsert(SSdb *pSdb, SStbObj *pStb) {
 
 static int32_t mndStbActionDelete(SSdb *pSdb, SStbObj *pStb) {
   mTrace("stb:%s, perform delete action, row:%p", pStb->name, pStb);
-  tfree(pStb->pColumns);
-  tfree(pStb->pTags);
-  tfree(pStb->comment);
+  taosMemoryFreeClear(pStb->pColumns);
+  taosMemoryFreeClear(pStb->pTags);
+  taosMemoryFreeClear(pStb->comment);
   return 0;
 }
 
@@ -248,9 +248,9 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOld, SStbObj *pNew) {
   taosWLockLatch(&pOld->lock);
 
   if (pOld->numOfColumns < pNew->numOfColumns) {
-    void *pColumns = malloc(pNew->numOfColumns * sizeof(SSchema));
+    void *pColumns = taosMemoryMalloc(pNew->numOfColumns * sizeof(SSchema));
     if (pColumns != NULL) {
-      free(pOld->pColumns);
+      taosMemoryFree(pOld->pColumns);
       pOld->pColumns = pColumns;
     } else {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -260,9 +260,9 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOld, SStbObj *pNew) {
   }
 
   if (pOld->numOfTags < pNew->numOfTags) {
-    void *pTags = malloc(pNew->numOfTags * sizeof(SSchema));
+    void *pTags = taosMemoryMalloc(pNew->numOfTags * sizeof(SSchema));
     if (pTags != NULL) {
-      free(pOld->pTags);
+      taosMemoryFree(pOld->pTags);
       pOld->pTags = pTags;
     } else {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -272,9 +272,9 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOld, SStbObj *pNew) {
   }
 
   if (pOld->numOfSmas < pNew->numOfSmas) {
-    void *pSmas = malloc(pNew->numOfSmas * sizeof(SSchema));
+    void *pSmas = taosMemoryMalloc(pNew->numOfSmas * sizeof(SSchema));
     if (pSmas != NULL) {
-      free(pOld->pSmas);
+      taosMemoryFree(pOld->pSmas);
       pOld->pSmas = pSmas;
     } else {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -284,9 +284,9 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOld, SStbObj *pNew) {
   }
 
   if (pOld->commentLen < pNew->commentLen) {
-    void *comment = malloc(pNew->commentLen);
+    void *comment = taosMemoryMalloc(pNew->commentLen);
     if (comment != NULL) {
-      free(pOld->comment);
+      taosMemoryFree(pOld->comment);
       pOld->comment = comment;
     } else {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -353,7 +353,7 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
   req.stbCfg.pTagSchema = pStb->pTags;
 
   int32_t   contLen = tSerializeSVCreateTbReq(NULL, &req) + sizeof(SMsgHead);
-  SMsgHead *pHead = malloc(contLen);
+  SMsgHead *pHead = taosMemoryMalloc(contLen);
   if (pHead == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -380,7 +380,7 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb,
   req.suid = pStb->uid;
 
   int32_t   contLen = tSerializeSVDropTbReq(NULL, &req) + sizeof(SMsgHead);
-  SMsgHead *pHead = malloc(contLen);
+  SMsgHead *pHead = taosMemoryMalloc(contLen);
   if (pHead == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -508,7 +508,7 @@ static int32_t mndSetCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     action.contLen = contLen;
     action.msgType = TDMT_VND_CREATE_STB;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
       return -1;
@@ -547,7 +547,7 @@ static int32_t mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     action.contLen = contLen;
     action.msgType = TDMT_VND_DROP_STB;
     if (mndTransAppendUndoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
       return -1;
@@ -584,7 +584,7 @@ static int32_t mndCreateStb(SMnode *pMnode, SNodeMsg *pReq, SMCreateStbReq *pCre
   stbObj.numOfSmas = pCreate->numOfSmas;
   stbObj.commentLen = pCreate->commentLen;
   if (stbObj.commentLen > 0) {
-    stbObj.comment = calloc(stbObj.commentLen, 1);
+    stbObj.comment = taosMemoryCalloc(stbObj.commentLen, 1);
     if (stbObj.comment == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
@@ -592,9 +592,9 @@ static int32_t mndCreateStb(SMnode *pMnode, SNodeMsg *pReq, SMCreateStbReq *pCre
     memcpy(stbObj.comment, pCreate->comment, stbObj.commentLen);
   }
 
-  stbObj.pColumns = malloc(stbObj.numOfColumns * sizeof(SSchema));
-  stbObj.pTags = malloc(stbObj.numOfTags * sizeof(SSchema));
-  stbObj.pSmas = malloc(stbObj.numOfSmas * sizeof(SSchema));
+  stbObj.pColumns = taosMemoryMalloc(stbObj.numOfColumns * sizeof(SSchema));
+  stbObj.pTags = taosMemoryMalloc(stbObj.numOfTags * sizeof(SSchema));
+  stbObj.pSmas = taosMemoryMalloc(stbObj.numOfSmas * sizeof(SSchema));
   if (stbObj.pColumns == NULL || stbObj.pTags == NULL || stbObj.pSmas == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -777,8 +777,8 @@ static int32_t mndFindSuperTableColumnIndex(const SStbObj *pStb, const char *col
 }
 
 static int32_t mndAllocStbSchemas(const SStbObj *pOld, SStbObj *pNew) {
-  pNew->pTags = calloc(pNew->numOfTags, sizeof(SSchema));
-  pNew->pColumns = calloc(pNew->numOfColumns, sizeof(SSchema));
+  pNew->pTags = taosMemoryCalloc(pNew->numOfTags, sizeof(SSchema));
+  pNew->pColumns = taosMemoryCalloc(pNew->numOfColumns, sizeof(SSchema));
   if (pNew->pTags == NULL || pNew->pColumns == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
@@ -1071,7 +1071,7 @@ static int32_t mndSetAlterStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     action.contLen = contLen;
     action.msgType = TDMT_VND_ALTER_STB;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
       return -1;
@@ -1140,8 +1140,8 @@ static int32_t mndAlterStb(SMnode *pMnode, SNodeMsg *pReq, const SMAltertbReq *p
 
 ALTER_STB_OVER:
   mndTransDrop(pTrans);
-  tfree(stbObj.pTags);
-  tfree(stbObj.pColumns);
+  taosMemoryFreeClear(stbObj.pTags);
+  taosMemoryFreeClear(stbObj.pColumns);
   return code;
 }
 
@@ -1251,7 +1251,7 @@ static int32_t mndSetDropStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
     action.msgType = TDMT_VND_DROP_STB;
     action.acceptableCode = TSDB_CODE_VND_TB_NOT_EXIST;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
-      free(pReq);
+      taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
       return -1;
@@ -1348,7 +1348,7 @@ static int32_t mndBuildStbSchemaImp(SDbObj *pDb, SStbObj *pStb, const char *tbNa
   taosRLockLatch(&pStb->lock);
 
   int32_t totalCols = pStb->numOfColumns + pStb->numOfTags;
-  pRsp->pSchemas = calloc(totalCols, sizeof(SSchema));
+  pRsp->pSchemas = taosMemoryCalloc(totalCols, sizeof(SSchema));
   if (pRsp->pSchemas == NULL) {
     taosRUnLockLatch(&pStb->lock);
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -1498,7 +1498,7 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableMetaVersion *pStbVersions, int
     return -1;
   }
 
-  void *pRsp = malloc(rspLen);
+  void *pRsp = taosMemoryMalloc(rspLen);
   if (pRsp == NULL) {
     tFreeSTableMetaBatchRsp(&batchMetaRsp);
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -1613,7 +1613,7 @@ static int32_t mndRetrieveStb(SNodeMsg *pReq, SShowObj *pShow, char *data, int32
   SDbObj* pDb = NULL;
   if (strlen(pShow->db) > 0) {
     pDb = mndAcquireDb(pMnode, pShow->db);
-    if (pDb == NULL) return 0;
+    if (pDb == NULL) return terrno;
   }
 
   while (numOfRows < rows) {

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

@@ -84,7 +84,7 @@ SSdbRaw *mndStreamActionEncode(SStreamObj *pStream) {
   SSdbRaw *pRaw = sdbAllocRaw(SDB_STREAM, MND_STREAM_VER_NUMBER, size);
   if (pRaw == NULL) goto STREAM_ENCODE_OVER;
 
-  buf = malloc(tlen);
+  buf = taosMemoryMalloc(tlen);
   if (buf == NULL) goto STREAM_ENCODE_OVER;
 
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, tlen, TD_ENCODER);
@@ -102,7 +102,7 @@ SSdbRaw *mndStreamActionEncode(SStreamObj *pStream) {
   terrno = TSDB_CODE_SUCCESS;
 
 STREAM_ENCODE_OVER:
-  tfree(buf);
+  taosMemoryFreeClear(buf);
   if (terrno != TSDB_CODE_SUCCESS) {
     mError("stream:%s, failed to encode to raw:%p since %s", pStream->name, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -135,7 +135,7 @@ SSdbRow *mndStreamActionDecode(SSdbRaw *pRaw) {
   int32_t tlen;
   int32_t dataPos = 0;
   SDB_GET_INT32(pRaw, dataPos, &tlen, STREAM_DECODE_OVER);
-  buf = malloc(tlen + 1);
+  buf = taosMemoryMalloc(tlen + 1);
   if (buf == NULL) goto STREAM_DECODE_OVER;
   SDB_GET_BINARY(pRaw, dataPos, buf, tlen, STREAM_DECODE_OVER);
 
@@ -148,10 +148,10 @@ SSdbRow *mndStreamActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_SUCCESS;
 
 STREAM_DECODE_OVER:
-  tfree(buf);
+  taosMemoryFreeClear(buf);
   if (terrno != TSDB_CODE_SUCCESS) {
     mError("stream:%s, failed to decode from raw:%p since %s", pStream->name, pRaw, terrstr());
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 

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

@@ -88,7 +88,7 @@ static int32_t mndProcessTelemTimer(SNodeMsg* pReq) {
   char* pCont = mndBuildTelemetryReport(pMnode);
   if (pCont != NULL) {
     taosSendHttpReport(TELEMETRY_SERVER, TELEMETRY_PORT, pCont, strlen(pCont), HTTP_FLAT);
-    free(pCont);
+    taosMemoryFree(pCont);
   }
   taosWUnLockLatch(&pMgmt->lock);
   return 0;

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

@@ -201,7 +201,7 @@ USER_DECODE_OVER:
     mError("user:%s, failed to decode from raw:%p since %s", pUser->user, pRaw, terrstr());
     taosHashCleanup(pUser->readDbs);
     taosHashCleanup(pUser->writeDbs);
-    tfree(pRow);
+    taosMemoryFreeClear(pRow);
     return NULL;
   }
 

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

@@ -29,7 +29,7 @@ class MndTestTrans : public ::testing::Test {
     char    file[PATH_MAX] = "/tmp/mnode_test_trans/mnode/data/sdb.data";
     TdFilePtr pFile = taosOpenFile(file, TD_FILE_READ);
     int32_t size = 3 * 1024 * 1024;
-    void*   buffer = malloc(size);
+    void*   buffer = taosMemoryMalloc(size);
     int32_t readLen = taosReadFile(pFile, buffer, size);
     if (readLen < 0 || readLen == size) {
       ASSERT(1);
@@ -43,7 +43,7 @@ class MndTestTrans : public ::testing::Test {
     if (writeLen < 0 || writeLen == readLen) {
       ASSERT(1);
     }
-    free(buffer);
+    taosMemoryFree(buffer);
     taosFsyncFile(pFile);
     taosCloseFile(&pFile);
     taosMsleep(1000);

source/dnode/mnode/sdb/src/sdbRow.c

@@ -17,7 +17,7 @@
 #include "sdbInt.h"
 
 SSdbRow *sdbAllocRow(int32_t objSize) {
-  SSdbRow *pRow = calloc(1, objSize + sizeof(SSdbRow));
+  SSdbRow *pRow = taosMemoryCalloc(1, objSize + sizeof(SSdbRow));
   if (pRow == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -46,5 +46,5 @@ void sdbFreeRow(SSdb *pSdb, SSdbRow *pRow) {
   sdbPrintOper(pSdb, pRow, "freeRow");
 
   mTrace("row:%p, is freed", pRow->pObj);
-  tfree(pRow);
+  taosMemoryFreeClear(pRow);
 }