Merge branch '3.0' of https://github.com/taosdata/TDengine into dev

example/src/tmq.c

@@ -80,8 +80,9 @@ int32_t create_topic() {
   }
   taos_free_result(pRes);
 
-  const char* sql = "select * from tu1";
-  pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql));
+  /*const char* sql = "select * from tu1";*/
+  /*pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql));*/
+  pRes = taos_query(pConn, "create topic test_stb_topic_1 as select * from tu1");
   if (taos_errno(pRes) != 0) {
     printf("failed to create topic test_stb_topic_1, reason:%s\n", taos_errstr(pRes));
     return -1;

include/client/taos.h

@@ -26,9 +26,11 @@ extern "C" {
 typedef void   TAOS;
 typedef void   TAOS_STMT;
 typedef void   TAOS_RES;
+typedef void **TAOS_ROW;
+#if 0
 typedef void   TAOS_STREAM;
+#endif
 typedef void   TAOS_SUB;
-typedef void **TAOS_ROW;
 
 // Data type definition
 #define TSDB_DATA_TYPE_NULL       0   // 1 bytes
@@ -122,8 +124,25 @@ typedef struct TAOS_MULTI_BIND {
   int       num;
 } TAOS_MULTI_BIND;
 
+typedef enum {
+  SET_CONF_RET_SUCC = 0,
+  SET_CONF_RET_ERR_PART = -1,
+  SET_CONF_RET_ERR_INNER = -2,
+  SET_CONF_RET_ERR_JSON_INVALID = -3,
+  SET_CONF_RET_ERR_JSON_PARSE = -4,
+  SET_CONF_RET_ERR_ONLY_ONCE = -5,
+  SET_CONF_RET_ERR_TOO_LONG = -6
+} SET_CONF_RET_CODE;
+
+#define RET_MSG_LENGTH 1024
+typedef struct setConfRet {
+  SET_CONF_RET_CODE retCode;
+  char   retMsg[RET_MSG_LENGTH];
+} setConfRet;
+
 DLL_EXPORT void  taos_cleanup(void);
 DLL_EXPORT int   taos_options(TSDB_OPTION option, const void *arg, ...);
+DLL_EXPORT setConfRet   taos_set_config(const char *config);
 DLL_EXPORT TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
 DLL_EXPORT TAOS *taos_connect_l(const char *ip, int ipLen, const char *user, int userLen, const char *pass, int passLen,
                                 const char *db, int dbLen, uint16_t port);
@@ -149,6 +168,7 @@ DLL_EXPORT int       taos_stmt_execute(TAOS_STMT *stmt);
 DLL_EXPORT TAOS_RES *taos_stmt_use_result(TAOS_STMT *stmt);
 DLL_EXPORT int       taos_stmt_close(TAOS_STMT *stmt);
 DLL_EXPORT char     *taos_stmt_errstr(TAOS_STMT *stmt);
+DLL_EXPORT int       taos_stmt_affected_rows(TAOS_STMT *stmt);
 
 DLL_EXPORT TAOS_RES *taos_query(TAOS *taos, const char *sql);
 DLL_EXPORT TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen);
@@ -165,10 +185,13 @@ DLL_EXPORT int         taos_select_db(TAOS *taos, const char *db);
 DLL_EXPORT int         taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
 DLL_EXPORT void        taos_stop_query(TAOS_RES *res);
 DLL_EXPORT bool        taos_is_null(TAOS_RES *res, int32_t row, int32_t col);
+DLL_EXPORT bool        taos_is_update_query(TAOS_RES *res);
 DLL_EXPORT int         taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows);
 DLL_EXPORT int         taos_validate_sql(TAOS *taos, const char *sql);
+DLL_EXPORT void taos_reset_current_db(TAOS *taos);
 
 DLL_EXPORT int *taos_fetch_lengths(TAOS_RES *res);
+DLL_EXPORT TAOS_ROW *taos_result_block(TAOS_RES *res);
 
 DLL_EXPORT const char *taos_get_server_info(TAOS *taos);
 DLL_EXPORT const char *taos_get_client_info();
@@ -179,15 +202,20 @@ DLL_EXPORT int         taos_errno(TAOS_RES *tres);
 DLL_EXPORT void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param);
 DLL_EXPORT void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param);
 
+// Shuduo: temporary enable for app build
+#if 1
 typedef void (*__taos_sub_fn_t)(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code);
 DLL_EXPORT TAOS_SUB *taos_subscribe(TAOS *taos, int restart, const char *topic, const char *sql, __taos_sub_fn_t fp,
                                     void *param, int interval);
 DLL_EXPORT TAOS_RES *taos_consume(TAOS_SUB *tsub);
 DLL_EXPORT void      taos_unsubscribe(TAOS_SUB *tsub, int keepProgress);
+#endif
 
+#if 0
 DLL_EXPORT TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sql, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row),
                                          int64_t stime, void *param, void (*callback)(void *));
 DLL_EXPORT void         taos_close_stream(TAOS_STREAM *tstr);
+#endif
 
 DLL_EXPORT int       taos_load_table_info(TAOS *taos, const char *tableNameList);
 DLL_EXPORT TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision);
@@ -215,8 +243,12 @@ DLL_EXPORT tmq_list_t *tmq_list_new();
 DLL_EXPORT int32_t     tmq_list_append(tmq_list_t *, const char *);
 DLL_EXPORT void        tmq_list_destroy(tmq_list_t *);
 
-DLL_EXPORT tmq_t      *tmq_consumer_new(void *conn, tmq_conf_t *conf, char *errstr, int32_t errstrLen);
-DLL_EXPORT tmq_t      *tmq_consumer_new1(tmq_conf_t *conf, char *errstr, int32_t errstrLen);
+// will be removed in 3.0
+DLL_EXPORT tmq_t *tmq_consumer_new(void *conn, tmq_conf_t *conf, char *errstr, int32_t errstrLen);
+
+// will replace last one
+DLL_EXPORT tmq_t *tmq_consumer_new1(tmq_conf_t *conf, char *errstr, int32_t errstrLen);
+
 DLL_EXPORT const char *tmq_err2str(tmq_resp_err_t);
 
 /* ------------------------TMQ CONSUMER INTERFACE------------------------ */
@@ -255,20 +287,26 @@ int32_t tmqGetSkipLogNum(tmq_message_t *tmq_message);
 
 /* -------------------------TMQ MSG HANDLE INTERFACE---------------------- */
 
-DLL_EXPORT TAOS_ROW tmq_get_row(tmq_message_t *message);
-DLL_EXPORT char    *tmq_get_topic_name(tmq_message_t *message);
-DLL_EXPORT void    *tmq_get_topic_schema(tmq_t *tmq, const char *topic);
-DLL_EXPORT void     tmq_message_destroy(tmq_message_t *tmq_message);
+DLL_EXPORT TAOS_ROW    tmq_get_row(tmq_message_t *message);
+DLL_EXPORT char       *tmq_get_topic_name(tmq_message_t *message);
+DLL_EXPORT int32_t     tmq_get_vgroup_id(tmq_message_t *message);
+DLL_EXPORT int64_t     tmq_get_request_offset(tmq_message_t *message);
+DLL_EXPORT int64_t     tmq_get_response_offset(tmq_message_t *message);
+DLL_EXPORT TAOS_FIELD *tmq_get_fields(tmq_t *tmq, const char *topic);
+DLL_EXPORT int32_t     tmq_field_count(tmq_t *tmq, const char *topic);
+DLL_EXPORT void        tmq_message_destroy(tmq_message_t *tmq_message);
 
 /* --------------------TMPORARY INTERFACE FOR TESTING--------------------- */
+#if 0
 DLL_EXPORT TAOS_RES *tmq_create_topic(TAOS *taos, const char *name, const char *sql, int sqlLen);
+#endif
 
 DLL_EXPORT TAOS_RES *tmq_create_stream(TAOS *taos, const char *streamName, const char *tbName, const char *sql);
 
-/* -------------------------------- OTHER -------------------------------- */
+/* ------------------------------ TMQ END -------------------------------- */
+#if 1 // Shuduo: temporary enable for app build
 typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code);
-
-DLL_EXPORT int taos_stmt_affected_rows(TAOS_STMT *stmt);
+#endif
 
 #ifdef __cplusplus
 }

include/common/tcommon.h

@@ -197,6 +197,11 @@ typedef struct SGroupbyExpr {
   bool    groupbyTag;  // group by tag or column
 } SGroupbyExpr;
 
+enum {
+  FUNC_PARAM_TYPE_VALUE = 0,
+  FUNC_PARAM_TYPE_COLUMN,
+};
+
 typedef struct SFunctParam {
   int32_t  type;
   SColumn* pCol;

include/common/tdatablock.h

@@ -133,7 +133,8 @@ static FORCE_INLINE int32_t colDataAppendInt32(SColumnInfoData* pColumnInfoData,
 }
 
 static FORCE_INLINE int32_t colDataAppendInt64(SColumnInfoData* pColumnInfoData, uint32_t currentRow, int64_t* v) {
-  ASSERT(pColumnInfoData->info.type == TSDB_DATA_TYPE_BIGINT || pColumnInfoData->info.type == TSDB_DATA_TYPE_UBIGINT);
+  int32_t type = pColumnInfoData->info.type;
+  ASSERT(type == TSDB_DATA_TYPE_BIGINT || type == TSDB_DATA_TYPE_UBIGINT || type == TSDB_DATA_TYPE_TIMESTAMP);
   char* p = pColumnInfoData->pData + pColumnInfoData->info.bytes * currentRow;
   *(int64_t*)p = *(int64_t*)v;
 }
@@ -175,17 +176,16 @@ size_t blockDataGetRowSize(SSDataBlock* pBlock);
 double blockDataGetSerialRowSize(const SSDataBlock* pBlock);
 size_t blockDataGetSerialMetaSize(const SSDataBlock* pBlock);
 
-SSchema* blockDataExtractSchema(const SSDataBlock* pBlock, int32_t* numOfCols);
-
 int32_t blockDataSort(SSDataBlock* pDataBlock, SArray* pOrderInfo);
 int32_t blockDataSort_rv(SSDataBlock* pDataBlock, SArray* pOrderInfo, bool nullFirst);
 
-int32_t      blockDataEnsureColumnCapacity(SColumnInfoData* pColumn, uint32_t numOfRows);
-int32_t      blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);
-void         blockDataCleanup(SSDataBlock* pDataBlock);
+int32_t blockDataEnsureColumnCapacity(SColumnInfoData* pColumn, uint32_t numOfRows);
+int32_t blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);
+void    blockDataCleanup(SSDataBlock* pDataBlock);
+size_t  blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize);
+void*   blockDataDestroy(SSDataBlock* pBlock);
+
 SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock);
-size_t       blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize);
-void*        blockDataDestroy(SSDataBlock* pBlock);
 
 void blockDebugShowData(const SArray* dataBlocks);
 

include/common/tglobal.h

@@ -51,7 +51,7 @@ extern int32_t tsCompatibleModel;
 extern bool    tsEnableSlaveQuery;
 extern bool    tsPrintAuth;
 extern int64_t tsTickPerDay[3];
-extern int32_t tsMultiProcess;
+extern bool    tsMultiProcess;
 
 // monitor
 extern bool     tsEnableMonitor;

include/common/tmsg.h

@@ -469,8 +469,7 @@ 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;
@@ -2017,7 +2016,6 @@ typedef struct {
   int8_t   slidingUnit;   // MACRO: TIME_UNIT_XXX
   int8_t   timezoneInt;   // sma data expired if timezone changes.
   char     indexName[TSDB_INDEX_NAME_LEN];
-  char     timezone[TD_TIMEZONE_LEN];
   int32_t  exprLen;
   int32_t  tagsFilterLen;
   int64_t  indexUid;
@@ -2055,32 +2053,6 @@ void*   tDeserializeSVCreateTSmaReq(void* buf, SVCreateTSmaReq* pReq);
 int32_t tSerializeSVDropTSmaReq(void** buf, SVDropTSmaReq* pReq);
 void*   tDeserializeSVDropTSmaReq(void* buf, SVDropTSmaReq* pReq);
 
-typedef struct {
-  col_id_t colId;
-  uint16_t blockSize;  // sma data block size
-  char     data[];
-} STSmaColData;
-
-typedef struct {
-  tb_uid_t tableUid;  // super/child/normal table uid
-  int32_t  dataLen;   // not including head
-  char     data[];
-} STSmaTbData;
-
-typedef struct {
-  int64_t indexUid;
-  TSKEY   skey;  // startKey of one interval/sliding window
-  int64_t interval;
-  int32_t dataLen;  // not including head
-  int8_t  intervalUnit;
-  char    data[];
-} STSmaDataWrapper;  // sma data for a interval/sliding window
-
-// interval/sliding => window
-
-// => window->table->colId
-// => 当一个window下所有的表均计算完成时，流计算告知tsdb清除window的过期标记
-
 // RSma: Rollup SMA
 typedef struct {
   int64_t  interval;
@@ -2215,23 +2187,6 @@ static FORCE_INLINE void* tDecodeTSmaWrapper(void* buf, STSmaWrapper* pSW) {
   return buf;
 }
 
-typedef struct {
-  int64_t uid;
-  int32_t numOfRows;
-  char*   colData;
-} SMqTbData;
-
-typedef struct {
-  char       topicName[TSDB_TOPIC_FNAME_LEN];
-  int64_t    committedOffset;
-  int64_t    reqOffset;
-  int64_t    rspOffset;
-  int32_t    skipLogNum;
-  int32_t    bodyLen;
-  int32_t    numOfTb;
-  SMqTbData* tbData;
-} SMqTopicData;
-
 typedef struct {
   int8_t  mqMsgType;
   int32_t code;
@@ -2259,8 +2214,11 @@ typedef struct {
 } SMqSubVgEp;
 
 typedef struct {
-  char    topic[TSDB_TOPIC_FNAME_LEN];
-  SArray* vgs;  // SArray<SMqSubVgEp>
+  char        topic[TSDB_TOPIC_FNAME_LEN];
+  int8_t      isSchemaAdaptive;
+  SArray*     vgs;  // SArray<SMqSubVgEp>
+  int32_t     numOfFields;
+  TAOS_FIELD* fields;
 } SMqSubTopicEp;
 
 typedef struct {
@@ -2281,32 +2239,6 @@ typedef struct {
   SArray*    topics;  // SArray<SMqSubTopicEp>
 } SMqCMGetSubEpRsp;
 
-typedef struct {
-  int32_t curBlock;
-  int32_t curRow;
-  void**  uData;
-} SMqRowIter;
-
-struct tmq_message_t {
-  SMqPollRsp msg;
-  void*      vg;
-  SMqRowIter iter;
-};
-
-#if 0
-struct tmq_message_t {
-  SMqRspHead head;
-  union {
-    SMqPollRsp       consumeRsp;
-    SMqCMGetSubEpRsp getEpRsp;
-  };
-  void*   extra;
-  int32_t curBlock;
-  int32_t curRow;
-  void**  uData;
-};
-#endif
-
 static FORCE_INLINE void tDeleteSMqSubTopicEp(SMqSubTopicEp* pSubTopicEp) { taosArrayDestroy(pSubTopicEp->vgs); }
 
 static FORCE_INLINE int32_t tEncodeSMqSubVgEp(void** buf, const SMqSubVgEp* pVgEp) {
@@ -2331,17 +2263,21 @@ static FORCE_INLINE void tDeleteSMqCMGetSubEpRsp(SMqCMGetSubEpRsp* pRsp) {
 static FORCE_INLINE int32_t tEncodeSMqSubTopicEp(void** buf, const SMqSubTopicEp* pTopicEp) {
   int32_t tlen = 0;
   tlen += taosEncodeString(buf, pTopicEp->topic);
+  tlen += taosEncodeFixedI8(buf, pTopicEp->isSchemaAdaptive);
   int32_t sz = taosArrayGetSize(pTopicEp->vgs);
   tlen += taosEncodeFixedI32(buf, sz);
   for (int32_t i = 0; i < sz; i++) {
     SMqSubVgEp* pVgEp = (SMqSubVgEp*)taosArrayGet(pTopicEp->vgs, i);
     tlen += tEncodeSMqSubVgEp(buf, pVgEp);
   }
+  tlen += taosEncodeFixedI32(buf, pTopicEp->numOfFields);
+  // tlen += taosEncodeBinary(buf, pTopicEp->fields, pTopicEp->numOfFields * sizeof(TAOS_FIELD));
   return tlen;
 }
 
 static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicEp) {
   buf = taosDecodeStringTo(buf, pTopicEp->topic);
+  buf = taosDecodeFixedI8(buf, &pTopicEp->isSchemaAdaptive);
   int32_t sz;
   buf = taosDecodeFixedI32(buf, &sz);
   pTopicEp->vgs = taosArrayInit(sz, sizeof(SMqSubVgEp));
@@ -2353,6 +2289,8 @@ static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicE
     buf = tDecodeSMqSubVgEp(buf, &vgEp);
     taosArrayPush(pTopicEp->vgs, &vgEp);
   }
+  buf = taosDecodeFixedI32(buf, &pTopicEp->numOfFields);
+  // buf = taosDecodeBinary(buf, (void**)&pTopicEp->fields, pTopicEp->numOfFields * sizeof(TAOS_FIELD));
   return buf;
 }
 

include/common/tmsgcb.h

@@ -56,13 +56,14 @@ typedef struct {
   ReleaseHandleFp         releaseHandleFp;
 } SMsgCb;
 
+void    tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb);
 int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq);
 int32_t tmsgGetQueueSize(const SMsgCb* pMsgCb, int32_t vgId, EQueueType qtype);
 int32_t tmsgSendReq(const SMsgCb* pMsgCb, const SEpSet* epSet, SRpcMsg* pReq);
 int32_t tmsgSendMnodeReq(const SMsgCb* pMsgCb, SRpcMsg* pReq);
-void    tmsgSendRsp(const SMsgCb* pMsgCb, const SRpcMsg* pRsp);
+void    tmsgSendRsp(const SRpcMsg* pRsp);
 void    tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg);
-void    tmsgReleaseHandle(const SMsgCb* pMsgCb, void* handle, int8_t type);
+void    tmsgReleaseHandle(void* handle, int8_t type);
 
 #ifdef __cplusplus
 }

include/common/trow.h

@@ -937,9 +937,8 @@ static FORCE_INLINE bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col
     STColumn *pCol = NULL;
     STSchema *pSchema = pIter->pSchema;
     while (pIter->colIdx <= pSchema->numOfCols) {
-      pCol = &pSchema->columns[pIter->colIdx];
+      pCol = &pSchema->columns[pIter->colIdx];  // 1st column of schema is primary TS key
       if (colId == pCol->colId) {
-        ++pIter->colIdx;
         break;
       } else if (colId < pCol->colId) {
         ++pIter->colIdx;
@@ -948,7 +947,8 @@ static FORCE_INLINE bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col
         return false;
       }
     }
-    return tdGetTpRowDataOfCol(pIter, pCol->type, pCol->offset - sizeof(TSKEY), pVal);
+    tdGetTpRowDataOfCol(pIter, pCol->type, pCol->offset - sizeof(TSKEY), pVal);
+    ++pIter->colIdx;
   } else if (TD_IS_KV_ROW(pIter->pRow)) {
     return tdGetKvRowValOfColEx(pIter, colId, colType, &pIter->kvIdx, pVal);
   } else {

include/common/ttokendef.h

@@ -138,55 +138,59 @@
 #define TK_INTERVAL                       120
 #define TK_TOPIC                          121
 #define TK_AS                             122
-#define TK_NK_BOOL                        123
-#define TK_NK_VARIABLE                    124
-#define TK_NK_UNDERLINE                   125
-#define TK_ROWTS                          126
-#define TK_TBNAME                         127
-#define TK_QSTARTTS                       128
-#define TK_QENDTS                         129
-#define TK_WSTARTTS                       130
-#define TK_WENDTS                         131
-#define TK_WDURATION                      132
-#define TK_BETWEEN                        133
-#define TK_IS                             134
-#define TK_NULL                           135
-#define TK_NK_LT                          136
-#define TK_NK_GT                          137
-#define TK_NK_LE                          138
-#define TK_NK_GE                          139
-#define TK_NK_NE                          140
-#define TK_MATCH                          141
-#define TK_NMATCH                         142
-#define TK_IN                             143
-#define TK_JOIN                           144
-#define TK_INNER                          145
-#define TK_SELECT                         146
-#define TK_DISTINCT                       147
-#define TK_WHERE                          148
-#define TK_PARTITION                      149
-#define TK_BY                             150
-#define TK_SESSION                        151
-#define TK_STATE_WINDOW                   152
-#define TK_SLIDING                        153
-#define TK_FILL                           154
-#define TK_VALUE                          155
-#define TK_NONE                           156
-#define TK_PREV                           157
-#define TK_LINEAR                         158
-#define TK_NEXT                           159
-#define TK_GROUP                          160
-#define TK_HAVING                         161
-#define TK_ORDER                          162
-#define TK_SLIMIT                         163
-#define TK_SOFFSET                        164
-#define TK_LIMIT                          165
-#define TK_OFFSET                         166
-#define TK_ASC                            167
-#define TK_DESC                           168
-#define TK_NULLS                          169
-#define TK_FIRST                          170
-#define TK_LAST                           171
+#define TK_EXPLAIN                        123
+#define TK_ANALYZE                        124
+#define TK_VERBOSE                        125
+#define TK_NK_BOOL                        126
+#define TK_RATIO                          127
+#define TK_NULL                           128
+#define TK_NK_VARIABLE                    129
+#define TK_NK_UNDERLINE                   130
+#define TK_ROWTS                          131
+#define TK_TBNAME                         132
+#define TK_QSTARTTS                       133
+#define TK_QENDTS                         134
+#define TK_WSTARTTS                       135
+#define TK_WENDTS                         136
+#define TK_WDURATION                      137
+#define TK_BETWEEN                        138
+#define TK_IS                             139
+#define TK_NK_LT                          140
+#define TK_NK_GT                          141
+#define TK_NK_LE                          142
+#define TK_NK_GE                          143
+#define TK_NK_NE                          144
+#define TK_MATCH                          145
+#define TK_NMATCH                         146
+#define TK_IN                             147
+#define TK_JOIN                           148
+#define TK_INNER                          149
+#define TK_SELECT                         150
+#define TK_DISTINCT                       151
+#define TK_WHERE                          152
+#define TK_PARTITION                      153
+#define TK_BY                             154
+#define TK_SESSION                        155
+#define TK_STATE_WINDOW                   156
+#define TK_SLIDING                        157
+#define TK_FILL                           158
+#define TK_VALUE                          159
+#define TK_NONE                           160
+#define TK_PREV                           161
+#define TK_LINEAR                         162
+#define TK_NEXT                           163
+#define TK_GROUP                          164
+#define TK_HAVING                         165
+#define TK_ORDER                          166
+#define TK_SLIMIT                         167
+#define TK_SOFFSET                        168
+#define TK_LIMIT                          169
+#define TK_OFFSET                         170
+#define TK_ASC                            171
+#define TK_DESC                           172
+#define TK_NULLS                          173
+#define TK_FIRST                          174
+#define TK_LAST                           175
 
 #define TK_NK_SPACE                       300
 #define TK_NK_COMMENT                     301

include/dnode/mgmt/dnode.h

@@ -46,11 +46,12 @@ typedef struct {
   char      localFqdn[TSDB_FQDN_LEN];
   char      firstEp[TSDB_EP_LEN];
   char      secondEp[TSDB_EP_LEN];
-  SDiskCfg *pDisks;
+  SDiskCfg *disks;
   int32_t   numOfDisks;
+  int8_t    ntype;
 } SDnodeOpt;
 
-typedef enum { DND_EVENT_START, DND_EVENT_STOP = 1, DND_EVENT_RELOAD } EDndEvent;
+typedef enum { DND_EVENT_START, DND_EVENT_STOP = 1, DND_EVENT_CHILD } EDndEvent;
 
 /**
  * @brief Initialize and start the dnode.

include/libs/executor/executor.h

@@ -20,8 +20,8 @@
 extern "C" {
 #endif
 
-#include "tcommon.h"
 #include "query.h"
+#include "tcommon.h"
 
 typedef void* qTaskInfo_t;
 typedef void* DataSinkHandle;
@@ -36,7 +36,12 @@ typedef struct SReadHandle {
 
 #define STREAM_DATA_TYPE_SUBMIT_BLOCK 0x1
 #define STREAM_DATA_TYPE_SSDATA_BLOCK 0x2
-  
+
+typedef enum {
+  OPTR_EXEC_MODEL_BATCH  = 0x1,
+  OPTR_EXEC_MODEL_STREAM = 0x2,
+} EOPTR_EXEC_MODEL;
+
 /**
  * Create the exec task for streaming mode
  * @param pMsg
@@ -62,7 +67,7 @@ int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type);
  * @param type
  * @return
  */
-int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, void** pBlocks, size_t numOfBlocks, int32_t type);
+int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type);
 
 /**
  * Update the table id list, add or remove.
@@ -84,7 +89,7 @@ int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, SArray* tableIdList, bool isA
  * @return
  */
 int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, struct SSubplan* pPlan,
-                        qTaskInfo_t* pTaskInfo, DataSinkHandle* handle);
+                        qTaskInfo_t* pTaskInfo, DataSinkHandle* handle, EOPTR_EXEC_MODEL model);
 
 /**
  * The main task execution function, including query on both table and multiple tables,
@@ -167,7 +172,6 @@ int32_t qUpdateQueriedTableIdList(qTaskInfo_t tinfo, int64_t uid, int32_t type);
  */
 void** qReleaseTask(void* pMgmt, void* pQInfo, bool freeHandle);
 
-
 void qProcessFetchRsp(void* parent, struct SRpcMsg* pMsg, struct SEpSet* pEpSet);
 
 #ifdef __cplusplus

include/libs/function/function.h

@@ -41,6 +41,7 @@ typedef void (*FExecFinalize)(struct SqlFunctionCtx *pCtx);
 typedef int32_t (*FScalarExecProcess)(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
 typedef struct SScalarFuncExecFuncs {
+  FExecGetEnv getEnv;
   FScalarExecProcess process;
 } SScalarFuncExecFuncs;
 
@@ -241,7 +242,6 @@ typedef struct tExprNode {
   };
 } tExprNode;
 
-void exprTreeToBinary(SBufferWriter* bw, tExprNode* pExprTree);
 void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *));
 
 typedef struct SAggFunctionInfo {
@@ -267,28 +267,6 @@ struct SScalarParam {
   int32_t            numOfRows;
 };
 
-typedef struct SMultiFunctionsDesc {
-  bool stableQuery;
-  bool groupbyColumn;
-  bool agg;
-  bool arithmeticOnAgg;
-  bool projectionQuery;
-  bool hasFilter;
-  bool onlyTagQuery;
-  bool orderProjectQuery;
-  bool globalMerge;
-  bool multigroupResult;
-  bool blockDistribution;
-  bool stateWindow;
-  bool timewindow;
-  bool sessionWindow;
-  bool topbotQuery;
-  bool interpQuery;
-  bool distinct;
-  bool join;
-  bool continueQuery;
-} SMultiFunctionsDesc;
-
 int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionId, int32_t param, SResultDataInfo* pInfo, int16_t extLength,
                           bool isSuperTable);
 
@@ -296,8 +274,6 @@ bool qIsValidUdf(SArray* pUdfInfo, const char* name, int32_t len, int32_t* funct
 
 tExprNode* exprTreeFromBinary(const void* data, size_t size);
 
-void extractFunctionDesc(SArray* pFunctionIdList, SMultiFunctionsDesc* pDesc);
-
 tExprNode* exprdup(tExprNode* pTree);
 
 void resetResultRowEntryResult(SqlFunctionCtx* pCtx, int32_t num);

include/libs/nodes/nodes.h

@@ -70,6 +70,7 @@ typedef enum ENodeType {
   QUERY_NODE_DATABASE_OPTIONS,
   QUERY_NODE_TABLE_OPTIONS,
   QUERY_NODE_INDEX_OPTIONS,
+  QUERY_NODE_EXPLAIN_OPTIONS,
 
   // Statement nodes are used in parser and planner module.
   QUERY_NODE_SET_OPERATOR,
@@ -99,6 +100,7 @@ typedef enum ENodeType {
   QUERY_NODE_CREATE_TOPIC_STMT,
   QUERY_NODE_DROP_TOPIC_STMT,
   QUERY_NODE_ALTER_LOCAL_STMT,
+  QUERY_NODE_EXPLAIN_STMT,
   QUERY_NODE_SHOW_DATABASES_STMT,
   QUERY_NODE_SHOW_TABLES_STMT,
   QUERY_NODE_SHOW_STABLES_STMT,
@@ -121,6 +123,7 @@ typedef enum ENodeType {
   QUERY_NODE_LOGIC_PLAN_EXCHANGE,
   QUERY_NODE_LOGIC_PLAN_WINDOW,
   QUERY_NODE_LOGIC_PLAN_SORT,
+  QUERY_NODE_LOGIC_PLAN_PARTITION,
   QUERY_NODE_LOGIC_SUBPLAN,
   QUERY_NODE_LOGIC_PLAN,
 

include/libs/nodes/plannodes.h

@@ -49,6 +49,7 @@ typedef struct SScanLogicNode {
   STimeWindow scanRange;
   SName tableName;
   bool showRewrite;
+  double ratio;
 } SScanLogicNode;
 
 typedef struct SJoinLogicNode {
@@ -66,7 +67,11 @@ typedef struct SAggLogicNode {
 typedef struct SProjectLogicNode {
   SLogicNode node;
   SNodeList* pProjections;
-  char stmtName[TSDB_TABLE_NAME_LEN]; 
+  char stmtName[TSDB_TABLE_NAME_LEN];
+  int64_t limit;
+  int64_t offset;
+  int64_t slimit;
+  int64_t soffset;
 } SProjectLogicNode;
 
 typedef struct SVnodeModifLogicNode {
@@ -106,6 +111,11 @@ typedef struct SSortLogicNode {
   SNodeList* pSortKeys;
 } SSortLogicNode;
 
+typedef struct SPartitionLogicNode {
+  SLogicNode node;
+  SNodeList* pPartitionKeys;
+} SPartitionLogicNode;
+
 typedef enum ESubplanType {
   SUBPLAN_TYPE_MERGE = 1,
   SUBPLAN_TYPE_PARTIAL,
@@ -150,7 +160,8 @@ typedef struct SDataBlockDescNode {
   ENodeType type;
   int16_t dataBlockId;
   SNodeList* pSlots;
-  int32_t resultRowSize;
+  int32_t totalRowSize;
+  int32_t outputRowSize;
   int16_t precision;
 } SDataBlockDescNode;
 
@@ -187,7 +198,7 @@ typedef struct STableScanPhysiNode {
   SScanPhysiNode scan;
   uint8_t scanFlag;         // denotes reversed scan of data or not
   STimeWindow scanRange;
-  SNode* pScanConditions;
+  double ratio;
 } STableScanPhysiNode;
 
 typedef STableScanPhysiNode STableSeqScanPhysiNode;
@@ -195,6 +206,10 @@ typedef STableScanPhysiNode STableSeqScanPhysiNode;
 typedef struct SProjectPhysiNode {
   SPhysiNode node;
   SNodeList* pProjections;
+  int64_t limit;
+  int64_t offset;
+  int64_t slimit;
+  int64_t soffset;
 } SProjectPhysiNode;
 
 typedef struct SJoinPhysiNode {
@@ -238,6 +253,7 @@ typedef struct SIntervalPhysiNode {
   int64_t    sliding;
   int8_t     intervalUnit;
   int8_t     slidingUnit;
+  uint8_t precision;
   SFillNode* pFill;
 } SIntervalPhysiNode;
 
@@ -283,11 +299,23 @@ typedef struct SSubplan {
   SDataSinkNode* pDataSink;    // data of the subplan flow into the datasink
 } SSubplan;
 
+typedef enum EExplainMode {
+  EXPLAIN_MODE_DISABLE = 1,
+  EXPLAIN_MODE_STATIC,
+  EXPLAIN_MODE_ANALYZE
+} EExplainMode;
+
+typedef struct SExplainInfo {
+  EExplainMode mode;
+  bool verbose;
+} SExplainInfo;
+
 typedef struct SQueryPlan {
   ENodeType type;
   uint64_t queryId;
   int32_t numOfSubplans;
   SNodeList* pSubplans; // Element is SNodeListNode. The execution level of subplan, starting from 0.
+  SExplainInfo explainInfo;
 } SQueryPlan;
 
 #ifdef __cplusplus

include/libs/nodes/querynodes.h

@@ -131,6 +131,7 @@ typedef struct SRealTableNode {
   struct STableMeta* pMeta;
   SVgroupsInfo* pVgroupList;
   char useDbName[TSDB_DB_NAME_LEN];
+  double ratio;
 } SRealTableNode;
 
 typedef struct STempTableNode {
@@ -180,8 +181,8 @@ typedef struct SOrderByExprNode {
 
 typedef struct SLimitNode {
   ENodeType type; // QUERY_NODE_LIMIT
-  uint64_t limit;
-  uint64_t offset;
+  int64_t limit;
+  int64_t offset;
 } SLimitNode;
 
 typedef struct SStateWindowNode {
@@ -282,6 +283,19 @@ typedef struct SVnodeModifOpStmt {
   const char* sql;                 // current sql statement position
 } SVnodeModifOpStmt;
 
+typedef struct SExplainOptions {
+  ENodeType type;
+  bool verbose;
+  double ratio;
+} SExplainOptions;
+
+typedef struct SExplainStmt {
+  ENodeType type;
+  bool analyze;
+  SExplainOptions* pOptions;
+  SNode* pQuery;
+} SExplainStmt;
+
 void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext);
 void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewriter rewriter, void* pContext);
 

include/libs/scalar/scalar.h

@@ -58,6 +58,14 @@ int32_t ceilFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
 int32_t floorFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 int32_t roundFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
 
+bool getTimePseudoFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
+
+int32_t winStartTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t winEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t winDurFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t qStartTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+int32_t qEndTsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
+
 #ifdef __cplusplus
 }
 #endif

include/os/os.h

@@ -42,6 +42,9 @@ extern "C" {
 #include <sys/types.h>
 #include <termios.h>
 #include <sys/statvfs.h>
+#include <sys/prctl.h>
+#include <sys/shm.h>
+#include <sys/wait.h>
 
 #if defined(DARWIN)
 #else
@@ -70,7 +73,6 @@ extern "C" {
 #include <wchar.h>
 #include <wctype.h>
 
-
 #include "osAtomic.h"
 #include "osDef.h"
 #include "osDir.h"
@@ -80,10 +82,12 @@ extern "C" {
 #include "osLz4.h"
 #include "osMath.h"
 #include "osMemory.h"
+#include "osProc.h"
 #include "osRand.h"
 #include "osThread.h"
 #include "osSemaphore.h"
 #include "osSignal.h"
+#include "osShm.h"
 #include "osSleep.h"
 #include "osSocket.h"
 #include "osString.h"

include/os/osProc.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_OS_PROC_H_
+#define _TD_OS_PROC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// start a copy of itself
+int32_t taosNewProc(const char *args);
+
+// the length of the new name must be less than the original name to take effect
+void taosSetProcName(char **argv, const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_OS_PROC_H_*/

include/os/osShm.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_OS_SHM_H_
+#define _TD_OS_SHM_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  int32_t id;
+  int32_t size;
+  void*   ptr;
+} SShm;
+
+int32_t taosCreateShm(SShm *pShm, int32_t shmsize) ;
+void    taosDropShm(SShm *pShm);
+int32_t taosAttachShm(SShm *pShm);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_OS_SHM_H_*/

include/os/osSignal.h

@@ -49,6 +49,8 @@ void taosSetSignal(int32_t signum, FSignalHandler sigfp);
 void taosIgnSignal(int32_t signum);
 void taosDflSignal(int32_t signum);
 
+void taosKillChildOnSelfStopped();
+
 #ifdef __cplusplus
 }
 #endif

include/os/osThread.h

@@ -32,6 +32,9 @@ typedef pthread_once_t TdThreadOnce;
 typedef pthread_rwlockattr_t TdThreadRwlockAttr;
 typedef pthread_cond_t TdThreadCond;
 typedef pthread_condattr_t TdThreadCondAttr;
+typedef pthread_key_t TdThreadKey;
+typedef pthread_barrier_t TdThreadBarrier;
+typedef pthread_barrierattr_t TdThreadBarrierAttr;
 
 #define taosThreadCleanupPush pthread_cleanup_push
 #define taosThreadCleanupPop pthread_cleanup_pop
@@ -39,78 +42,190 @@ typedef pthread_condattr_t TdThreadCondAttr;
 // 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 section.
 #ifndef ALLOW_FORBID_FUNC
-    #define pthread_t PTHREAD_T_TYPE_TAOS_FORBID
-    #define pthread_spinlock_t PTHREAD_SPINLOCK_T_TYPE_TAOS_FORBID
-    #define pthread_mutex_t PTHREAD_MUTEX_T_TYPE_TAOS_FORBID
-    #define pthread_mutexattr_t PTHREAD_MUTEXATTR_T_TYPE_TAOS_FORBID
-    #define pthread_rwlock_t PTHREAD_RWLOCK_T_TYPE_TAOS_FORBID
-    #define pthread_attr_t PTHREAD_ATTR_T_TYPE_TAOS_FORBID
-    #define pthread_once_t PTHREAD_ONCE_T_TYPE_TAOS_FORBID
-    #define pthread_rwlockattr_t PTHREAD_RWLOCKATTR_T_TYPE_TAOS_FORBID
-    #define pthread_cond_t PTHREAD_COND_T_TYPE_TAOS_FORBID
-    #define pthread_condattr_t PTHREAD_CONDATTR_T_TYPE_TAOS_FORBID
-    #define pthread_spin_init PTHREAD_SPIN_INIT_FUNC_TAOS_FORBID
-    #define pthread_mutex_init PTHREAD_MUTEX_INIT_FUNC_TAOS_FORBID
-    #define pthread_spin_destroy PTHREAD_SPIN_DESTROY_FUNC_TAOS_FORBID
-    #define pthread_mutex_destroy PTHREAD_MUTEX_DESTROY_FUNC_TAOS_FORBID
-    #define pthread_spin_lock PTHREAD_SPIN_LOCK_FUNC_TAOS_FORBID
-    #define pthread_mutex_lock PTHREAD_MUTEX_LOCK_FUNC_TAOS_FORBID
-    #define pthread_spin_unlock PTHREAD_SPIN_UNLOCK_FUNC_TAOS_FORBID
-    #define pthread_mutex_unlock PTHREAD_MUTEX_UNLOCK_FUNC_TAOS_FORBID
-    #define pthread_rwlock_rdlock PTHREAD_RWLOCK_RDLOCK_FUNC_TAOS_FORBID
-    #define pthread_rwlock_wrlock PTHREAD_RWLOCK_WRLOCK_FUNC_TAOS_FORBID
-    #define pthread_rwlock_unlock PTHREAD_RWLOCK_UNLOCK_FUNC_TAOS_FORBID
-    #define pthread_testcancel PTHREAD_TESTCANCEL_FUNC_TAOS_FORBID
-    #define pthread_attr_init PTHREAD_ATTR_INIT_FUNC_TAOS_FORBID
-    #define pthread_create PTHREAD_CREATE_FUNC_TAOS_FORBID
-    #define pthread_once PTHREAD_ONCE_FUNC_TAOS_FORBID
-    #define pthread_attr_setdetachstate PTHREAD_ATTR_SETDETACHSTATE_FUNC_TAOS_FORBID
-    #define pthread_attr_destroy PTHREAD_ATTR_DESTROY_FUNC_TAOS_FORBID
-    #define pthread_join PTHREAD_JOIN_FUNC_TAOS_FORBID
-    #define pthread_rwlock_init PTHREAD_RWLOCK_INIT_FUNC_TAOS_FORBID
-    #define pthread_rwlock_destroy PTHREAD_RWLOCK_DESTROY_FUNC_TAOS_FORBID
-    #define pthread_cond_signal PTHREAD_COND_SIGNAL_FUNC_TAOS_FORBID
-    #define pthread_cond_init PTHREAD_COND_INIT_FUNC_TAOS_FORBID
-    #define pthread_cond_broadcast PTHREAD_COND_BROADCAST_FUNC_TAOS_FORBID
-    #define pthread_cond_destroy PTHREAD_COND_DESTROY_FUNC_TAOS_FORBID
-    #define pthread_cond_wait PTHREAD_COND_WAIT_FUNC_TAOS_FORBID
-    #define pthread_self PTHREAD_SELF_FUNC_TAOS_FORBID
-    #define pthread_equal PTHREAD_EQUAL_FUNC_TAOS_FORBID
-    #define pthread_sigmask PTHREAD_SIGMASK_FUNC_TAOS_FORBID
-    #define pthread_cancel PTHREAD_CANCEL_FUNC_TAOS_FORBID
-    #define pthread_kill PTHREAD_KILL_FUNC_TAOS_FORBID
+    // #define pthread_t PTHREAD_T_TYPE_TAOS_FORBID
+    // #define pthread_spinlock_t PTHREAD_SPINLOCK_T_TYPE_TAOS_FORBID
+    // #define pthread_mutex_t PTHREAD_MUTEX_T_TYPE_TAOS_FORBID
+    // #define pthread_mutexattr_t PTHREAD_MUTEXATTR_T_TYPE_TAOS_FORBID
+    // #define pthread_rwlock_t PTHREAD_RWLOCK_T_TYPE_TAOS_FORBID
+    // #define pthread_attr_t PTHREAD_ATTR_T_TYPE_TAOS_FORBID
+    // #define pthread_once_t PTHREAD_ONCE_T_TYPE_TAOS_FORBID
+    // #define pthread_rwlockattr_t PTHREAD_RWLOCKATTR_T_TYPE_TAOS_FORBID
+    // #define pthread_cond_t PTHREAD_COND_T_TYPE_TAOS_FORBID
+    // #define pthread_condattr_t PTHREAD_CONDATTR_T_TYPE_TAOS_FORBID
+    // #define pthread_key_t PTHREAD_KEY_T_TYPE_TAOS_FORBID
+    // #define pthread_barrier_t PTHREAD_BARRIER_T_TYPE_TAOS_FORBID
+    // #define pthread_barrierattr_t PTHREAD_BARRIERATTR_T_TYPE_TAOS_FORBID
+    // #define pthread_create PTHREAD_CREATE_FUNC_TAOS_FORBID
+    // #define pthread_attr_destroy PTHREAD_ATTR_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_attr_getdetachstate PTHREAD_ATTR_GETDETACHSTATE_FUNC_TAOS_FORBID
+    // #define pthread_attr_getinheritsched PTHREAD_ATTR_GETINHERITSCHED_FUNC_TAOS_FORBID
+    // #define pthread_attr_getschedparam PTHREAD_ATTR_GETSCHEDPARAM_FUNC_TAOS_FORBID
+    // #define pthread_attr_getschedpolicy PTHREAD_ATTR_GETSCHEDPOLICY_FUNC_TAOS_FORBID
+    // #define pthread_attr_getscope PTHREAD_ATTR_GETSCOPE_FUNC_TAOS_FORBID
+    // #define pthread_attr_getstacksize PTHREAD_ATTR_GETSTACKSIZE_FUNC_TAOS_FORBID
+    // #define pthread_attr_init PTHREAD_ATTR_INIT_FUNC_TAOS_FORBID
+    // #define pthread_attr_setdetachstate PTHREAD_ATTR_SETDETACHSTATE_FUNC_TAOS_FORBID
+    // #define pthread_attr_setinheritsched PTHREAD_ATTR_SETINHERITSCHED_FUNC_TAOS_FORBID
+    // #define pthread_attr_setschedparam PTHREAD_ATTR_SETSCHEDPARAM_FUNC_TAOS_FORBID
+    // #define pthread_attr_setschedpolicy PTHREAD_ATTR_SETSCHEDPOLICY_FUNC_TAOS_FORBID
+    // #define pthread_attr_setscope PTHREAD_ATTR_SETSCOPE_FUNC_TAOS_FORBID
+    // #define pthread_attr_setstacksize PTHREAD_ATTR_SETSTACKSIZE_FUNC_TAOS_FORBID
+    // #define pthread_barrier_destroy PTHREAD_BARRIER_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_barrier_init PTHREAD_BARRIER_INIT_FUNC_TAOS_FORBID
+    // #define pthread_barrier_wait PTHREAD_BARRIER_WAIT_FUNC_TAOS_FORBID
+    // #define pthread_barrierattr_destroy PTHREAD_BARRIERATTR_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_barrierattr_getpshared PTHREAD_BARRIERATTR_GETPSHARED_FUNC_TAOS_FORBID
+    // #define pthread_barrierattr_init PTHREAD_BARRIERATTR_INIT_FUNC_TAOS_FORBID
+    // #define pthread_barrierattr_setpshared PTHREAD_BARRIERATTR_SETPSHARED_FUNC_TAOS_FORBID
+    // #define pthread_cancel PTHREAD_CANCEL_FUNC_TAOS_FORBID
+    // #define pthread_cond_destroy PTHREAD_COND_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_cond_init PTHREAD_COND_INIT_FUNC_TAOS_FORBID
+    // #define pthread_cond_signal PTHREAD_COND_SIGNAL_FUNC_TAOS_FORBID
+    // #define pthread_cond_broadcast PTHREAD_COND_BROADCAST_FUNC_TAOS_FORBID
+    // #define pthread_cond_wait PTHREAD_COND_WAIT_FUNC_TAOS_FORBID
+    // #define pthread_cond_timedwait PTHREAD_COND_TIMEDWAIT_FUNC_TAOS_FORBID
+    // #define pthread_condattr_destroy PTHREAD_CONDATTR_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_condattr_getpshared PTHREAD_CONDATTR_GETPSHARED_FUNC_TAOS_FORBID
+    // #define pthread_condattr_init PTHREAD_CONDATTR_INIT_FUNC_TAOS_FORBID
+    // #define pthread_condattr_setpshared PTHREAD_CONDATTR_SETPSHARED_FUNC_TAOS_FORBID
+    // #define pthread_detach PTHREAD_DETACH_FUNC_TAOS_FORBID
+    // #define pthread_equal PTHREAD_EQUAL_FUNC_TAOS_FORBID
+    // #define pthread_exit PTHREAD_EXIT_FUNC_TAOS_FORBID
+    // #define pthread_getschedparam PTHREAD_GETSCHEDPARAM_FUNC_TAOS_FORBID
+    // #define pthread_getspecific PTHREAD_GETSPECIFIC_FUNC_TAOS_FORBID
+    // #define pthread_join PTHREAD_JOIN_FUNC_TAOS_FORBID
+    // #define pthread_key_create PTHREAD_KEY_CREATE_FUNC_TAOS_FORBID
+    // #define pthread_key_delete PTHREAD_KEY_DELETE_FUNC_TAOS_FORBID
+    // #define pthread_kill PTHREAD_KILL_FUNC_TAOS_FORBID
+    // #define pthread_mutex_consistent PTHREAD_MUTEX_CONSISTENT_FUNC_TAOS_FORBID
+    // #define pthread_mutex_destroy PTHREAD_MUTEX_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_mutex_init PTHREAD_MUTEX_INIT_FUNC_TAOS_FORBID
+    // #define pthread_mutex_lock PTHREAD_MUTEX_LOCK_FUNC_TAOS_FORBID
+    // #define pthread_mutex_timedlock PTHREAD_MUTEX_TIMEDLOCK_FUNC_TAOS_FORBID
+    // #define pthread_mutex_trylock PTHREAD_MUTEX_TRYLOCK_FUNC_TAOS_FORBID
+    // #define pthread_mutex_unlock PTHREAD_MUTEX_UNLOCK_FUNC_TAOS_FORBID
+    // #define pthread_mutexattr_destroy PTHREAD_MUTEXATTR_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_mutexattr_getpshared PTHREAD_MUTEXATTR_GETPSHARED_FUNC_TAOS_FORBID
+    // #define pthread_mutexattr_getrobust PTHREAD_MUTEXATTR_GETROBUST_FUNC_TAOS_FORBID
+    // #define pthread_mutexattr_gettype PTHREAD_MUTEXATTR_GETTYPE_FUNC_TAOS_FORBID
+    // #define pthread_mutexattr_init PTHREAD_MUTEXATTR_INIT_FUNC_TAOS_FORBID
+    // #define pthread_mutexattr_setpshared PTHREAD_MUTEXATTR_SETPSHARED_FUNC_TAOS_FORBID
+    // #define pthread_mutexattr_setrobust PTHREAD_MUTEXATTR_SETROBUST_FUNC_TAOS_FORBID
+    // #define pthread_mutexattr_settype PTHREAD_MUTEXATTR_SETTYPE_FUNC_TAOS_FORBID
+    // #define pthread_once PTHREAD_ONCE_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_destroy PTHREAD_RWLOCK_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_init PTHREAD_RWLOCK_INIT_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_rdlock PTHREAD_RWLOCK_RDLOCK_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_timedrdlock PTHREAD_RWLOCK_TIMEDRDLOCK_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_timedwrlock PTHREAD_RWLOCK_TIMEDWRLOCK_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_tryrdlock PTHREAD_RWLOCK_TRYRDLOCK_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_trywrlock PTHREAD_RWLOCK_TRYWRLOCK_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_unlock PTHREAD_RWLOCK_UNLOCK_FUNC_TAOS_FORBID
+    // #define pthread_rwlock_wrlock PTHREAD_RWLOCK_WRLOCK_FUNC_TAOS_FORBID
+    // #define pthread_rwlockattr_destroy PTHREAD_RWLOCKATTR_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_rwlockattr_getpshared PTHREAD_RWLOCKATTR_GETPSHARED_FUNC_TAOS_FORBID
+    // #define pthread_rwlockattr_init PTHREAD_RWLOCKATTR_INIT_FUNC_TAOS_FORBID
+    // #define pthread_rwlockattr_setpshared PTHREAD_RWLOCKATTR_SETPSHARED_FUNC_TAOS_FORBID
+    // #define pthread_self PTHREAD_SELF_FUNC_TAOS_FORBID
+    // #define pthread_setcancelstate PTHREAD_SETCANCELSTATE_FUNC_TAOS_FORBID
+    // #define pthread_setcanceltype PTHREAD_SETCANCELTYPE_FUNC_TAOS_FORBID
+    // #define pthread_setschedparam PTHREAD_SETSCHEDPARAM_FUNC_TAOS_FORBID
+    // #define pthread_setspecific PTHREAD_SETSPECIFIC_FUNC_TAOS_FORBID
+    // #define pthread_spin_destroy PTHREAD_SPIN_DESTROY_FUNC_TAOS_FORBID
+    // #define pthread_spin_init PTHREAD_SPIN_INIT_FUNC_TAOS_FORBID
+    // #define pthread_spin_lock PTHREAD_SPIN_LOCK_FUNC_TAOS_FORBID
+    // #define pthread_spin_trylock PTHREAD_SPIN_TRYLOCK_FUNC_TAOS_FORBID
+    // #define pthread_spin_unlock PTHREAD_SPIN_UNLOCK_FUNC_TAOS_FORBID
+    // #define pthread_testcancel PTHREAD_TESTCANCEL_FUNC_TAOS_FORBID
+    // #define pthread_sigmask PTHREAD_SIGMASK_FUNC_TAOS_FORBID
+    // #define sigwait SIGWAIT_FUNC_TAOS_FORBID
 #endif
 
-int32_t taosThreadSpinInit(TdThreadSpinlock *lock, int pshared);
-int32_t taosThreadMutexInit(TdThreadMutex *mutex, const TdThreadMutexAttr *attr);
-int32_t taosThreadSpinDestroy(TdThreadSpinlock *lock);
+int32_t taosThreadCreate(TdThread * tid, const TdThreadAttr * attr, void *(*start)(void *), void *arg);
+int32_t taosThreadAttrDestroy(TdThreadAttr * attr);
+int32_t taosThreadAttrGetDetachState(const TdThreadAttr * attr, int32_t *detachstate);
+int32_t taosThreadAttrGetInheritSched(const TdThreadAttr * attr, int32_t *inheritsched);
+int32_t taosThreadAttrGetSchedParam(const TdThreadAttr * attr, struct sched_param *param);
+int32_t taosThreadAttrGetSchedPolicy(const TdThreadAttr * attr, int32_t *policy);
+int32_t taosThreadAttrGetScope(const TdThreadAttr * attr, int32_t *contentionscope);
+int32_t taosThreadAttrGetStackSize(const TdThreadAttr * attr, size_t * stacksize);
+int32_t taosThreadAttrInit(TdThreadAttr * attr);
+int32_t taosThreadAttrSetDetachState(TdThreadAttr * attr, int32_t detachstate);
+int32_t taosThreadAttrSetInheritSched(TdThreadAttr * attr, int32_t inheritsched);
+int32_t taosThreadAttrSetSchedParam(TdThreadAttr * attr, const struct sched_param *param);
+int32_t taosThreadAttrSetSchedPolicy(TdThreadAttr * attr, int32_t policy);
+int32_t taosThreadAttrSetScope(TdThreadAttr * attr, int32_t contentionscope);
+int32_t taosThreadAttrSetStackSize(TdThreadAttr * attr, size_t stacksize);
+int32_t taosThreadBarrierDestroy(TdThreadBarrier * barrier);
+int32_t taosThreadBarrierInit(TdThreadBarrier * barrier, const TdThreadBarrierAttr * attr, uint32_t count);
+int32_t taosThreadBarrierWait(TdThreadBarrier * barrier);
+int32_t taosThreadBarrierAttrDestroy(TdThreadBarrierAttr * attr);
+int32_t taosThreadBarrierAttrGetPshared(const TdThreadBarrierAttr * attr, int32_t *pshared);
+int32_t taosThreadBarrierAttrInit(TdThreadBarrierAttr * attr);
+int32_t taosThreadBarrierAttrSetPshared(TdThreadBarrierAttr * attr, int32_t pshared);
+int32_t taosThreadCancel(TdThread thread);
+int32_t taosThreadCondDestroy(TdThreadCond * cond);
+int32_t taosThreadCondInit(TdThreadCond * cond, const TdThreadCondAttr * attr);
+int32_t taosThreadCondSignal(TdThreadCond * cond);
+int32_t taosThreadCondBroadcast(TdThreadCond * cond);
+int32_t taosThreadCondWait(TdThreadCond * cond, TdThreadMutex * mutex);
+int32_t taosThreadCondTimedWait(TdThreadCond * cond, TdThreadMutex * mutex, const struct timespec *abstime);
+int32_t taosThreadCondAttrDestroy(TdThreadCondAttr * attr);
+int32_t taosThreadCondAttrGetPshared(const TdThreadCondAttr * attr, int32_t *pshared);
+int32_t taosThreadCondAttrInit(TdThreadCondAttr * attr);
+int32_t taosThreadCondAttrSetPshared(TdThreadCondAttr * attr, int32_t pshared);
+int32_t taosThreadDetach(TdThread thread);
+int32_t taosThreadEqual(TdThread t1, TdThread t2);
+void taosThreadExit(void *valuePtr);
+int32_t taosThreadGetSchedParam(TdThread thread, int32_t *policy, struct sched_param *param);
+void *taosThreadGetSpecific(TdThreadKey key);
+int32_t taosThreadJoin(TdThread thread, void **valuePtr);
+int32_t taosThreadKeyCreate(TdThreadKey * key, void(*destructor)(void *));
+int32_t taosThreadKeyDelete(TdThreadKey key);
+int32_t taosThreadKill(TdThread thread, int32_t sig);
+int32_t taosThreadMutexConsistent(TdThreadMutex* mutex);
 int32_t taosThreadMutexDestroy(TdThreadMutex * mutex);
-int32_t taosThreadSpinLock(TdThreadSpinlock *lock);
-int32_t taosThreadMutexLock(TdThreadMutex *mutex);
-int32_t taosThreadRwlockRdlock(TdThreadRwlock *rwlock);
-int32_t taosThreadSpinUnlock(TdThreadSpinlock *lock);
-int32_t taosThreadMutexUnlock(TdThreadMutex *mutex);
-int32_t taosThreadRwlockWrlock(TdThreadRwlock *rwlock);
-int32_t taosThreadRwlockUnlock(TdThreadRwlock *rwlock);
-void taosThreadTestCancel(void);
-int32_t taosThreadAttrInit(TdThreadAttr *attr);
-int32_t taosThreadCreate(TdThread *tid, const TdThreadAttr *attr, void*(*start)(void*), void *arg);
-int32_t taosThreadOnce(TdThreadOnce *onceControl, void(*initRoutine)(void));
-int32_t taosThreadAttrSetDetachState(TdThreadAttr *attr, int32_t detachState);
-int32_t taosThreadAttrDestroy(TdThreadAttr *attr);
-int32_t taosThreadJoin(TdThread thread, void **pValue);
-int32_t taosThreadRwlockInit(TdThreadRwlock *rwlock, const TdThreadRwlockAttr *attr);
-int32_t taosThreadRwlockDestroy(TdThreadRwlock *rwlock);
-int32_t taosThreadCondSignal(TdThreadCond *cond);
-int32_t taosThreadCondInit(TdThreadCond *cond, const TdThreadCondAttr *attr);
-int32_t taosThreadCondBroadcast(TdThreadCond *cond);
-int32_t taosThreadCondDestroy(TdThreadCond *cond);
-int32_t taosThreadCondWait(TdThreadCond *cond, TdThreadMutex *mutex);
+int32_t taosThreadMutexInit(TdThreadMutex * mutex, const TdThreadMutexAttr * attr);
+int32_t taosThreadMutexLock(TdThreadMutex * mutex);
+int32_t taosThreadMutexTimedLock(TdThreadMutex * mutex, const struct timespec *abstime);
+int32_t taosThreadMutexTryLock(TdThreadMutex * mutex);
+int32_t taosThreadMutexUnlock(TdThreadMutex * mutex);
+int32_t taosThreadMutexAttrDestroy(TdThreadMutexAttr * attr);
+int32_t taosThreadMutexAttrGetPshared(const TdThreadMutexAttr * attr, int32_t *pshared);
+int32_t taosThreadMutexAttrGetRobust(const TdThreadMutexAttr * attr, int32_t * robust);
+int32_t taosThreadMutexAttrGetType(const TdThreadMutexAttr * attr, int32_t *kind);
+int32_t taosThreadMutexAttrInit(TdThreadMutexAttr * attr);
+int32_t taosThreadMutexAttrSetPshared(TdThreadMutexAttr * attr, int32_t pshared);
+int32_t taosThreadMutexAttrSetRobust(TdThreadMutexAttr * attr, int32_t robust);
+int32_t taosThreadMutexAttrSetType(TdThreadMutexAttr * attr, int32_t kind);
+int32_t taosThreadOnce(TdThreadOnce * onceControl, void(*initRoutine)(void));
+int32_t taosThreadRwlockDestroy(TdThreadRwlock * rwlock);
+int32_t taosThreadRwlockInit(TdThreadRwlock * rwlock, const TdThreadRwlockAttr * attr);
+int32_t taosThreadRwlockRdlock(TdThreadRwlock * rwlock);
+int32_t taosThreadRwlockTimedRdlock(TdThreadRwlock * rwlock, const struct timespec *abstime);
+int32_t taosThreadRwlockTimedWrlock(TdThreadRwlock * rwlock, const struct timespec *abstime);
+int32_t taosThreadRwlockTryRdlock(TdThreadRwlock * rwlock);
+int32_t taosThreadRwlockTryWrlock(TdThreadRwlock * rwlock);
+int32_t taosThreadRwlockUnlock(TdThreadRwlock * rwlock);
+int32_t taosThreadRwlockWrlock(TdThreadRwlock * rwlock);
+int32_t taosThreadRwlockAttrDestroy(TdThreadRwlockAttr * attr);
+int32_t taosThreadRwlockAttrGetPshared(const TdThreadRwlockAttr * attr, int32_t *pshared);
+int32_t taosThreadRwlockAttrInit(TdThreadRwlockAttr * attr);
+int32_t taosThreadRwlockAttrSetPshared(TdThreadRwlockAttr * attr, int32_t pshared);
 TdThread taosThreadSelf(void);
-int32_t taosThreadEqual(TdThread t1, TdThread t2);
-int32_t taosThreadSigmask(int how, sigset_t const *set, sigset_t *oset);
-int32_t taosThreadCancel(TdThread thread);
-int32_t taosThreadKill(TdThread thread, int sig);
+int32_t taosThreadSetCancelState(int32_t state, int32_t *oldstate);
+int32_t taosThreadSetCancelType(int32_t type, int32_t *oldtype);
+int32_t taosThreadSetSchedParam(TdThread thread, int32_t policy, const struct sched_param *param);
+int32_t taosThreadSetSpecific(TdThreadKey key, const void *value);
+int32_t taosThreadSpinDestroy(TdThreadSpinlock * lock);
+int32_t taosThreadSpinInit(TdThreadSpinlock * lock, int32_t pshared);
+int32_t taosThreadSpinLock(TdThreadSpinlock * lock);
+int32_t taosThreadSpinTrylock(TdThreadSpinlock * lock);
+int32_t taosThreadSpinUnlock(TdThreadSpinlock * lock);
+void taosThreadTestCancel(void);
+int32_t taosThreadSigMask(int32_t how, sigset_t const *set, sigset_t * oset);
+int32_t taosThreadSigWait(const sigset_t * set, int32_t *sig);
+
 #ifdef __cplusplus
 }
 #endif

include/os/osTime.h

@@ -20,6 +20,8 @@
 extern "C" {
 #endif
 
+#include <time.h>
+
 // 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 section.
 #ifndef ALLOW_FORBID_FUNC

include/util/taoserror.h

@@ -16,7 +16,7 @@
 #ifndef _TD_UTIL_TAOS_ERROR_H_
 #define _TD_UTIL_TAOS_ERROR_H_
 
-#include "os.h"
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -78,6 +78,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_CFG_NOT_FOUND                 TAOS_DEF_ERROR_CODE(0, 0x010C)
 #define TSDB_CODE_INVALID_CFG                   TAOS_DEF_ERROR_CODE(0, 0x010D)
 #define TSDB_CODE_OUT_OF_SHM_MEM                TAOS_DEF_ERROR_CODE(0, 0x010E)
+#define TSDB_CODE_INVALID_SHM_ID                TAOS_DEF_ERROR_CODE(0, 0x010F)
 #define TSDB_CODE_REF_NO_MEMORY                 TAOS_DEF_ERROR_CODE(0, 0x0110)
 #define TSDB_CODE_REF_FULL                      TAOS_DEF_ERROR_CODE(0, 0x0111)
 #define TSDB_CODE_REF_ID_REMOVED                TAOS_DEF_ERROR_CODE(0, 0x0112)

include/util/tdef.h

@@ -381,6 +381,14 @@ typedef enum ELogicConditionType {
 #define TSDB_MAX_DB_DELAY     10
 #define TSDB_DEFAULT_DB_DELAY 2
 
+#define TSDB_DEFAULT_EXPLAIN_VERBOSE false
+
+#define TSDB_MIN_EXPLAIN_RATIO       0
+#define TSDB_MAX_EXPLAIN_RATIO       1
+#define TSDB_DEFAULT_EXPLAIN_RATIO   0.001
+
+#define TSDB_EXPLAIN_RESULT_ROW_SIZE 1024
+
 #define TSDB_MAX_JOIN_TABLE_NUM 10
 #define TSDB_MAX_UNION_CLAUSE   5
 

include/util/tprocess.h

@@ -22,7 +22,7 @@
 extern "C" {
 #endif
 
-typedef enum { PROC_REQ, PROC_RSP, PROC_REGISTER } ProcFuncType;
+typedef enum { PROC_REQ, PROC_RSP, PROC_REG, PROC_RELEASE } ProcFuncType;
 
 typedef struct SProcQueue SProcQueue;
 typedef struct SProcObj   SProcObj;
@@ -32,29 +32,25 @@ typedef void *(*ProcConsumeFp)(void *pParent, void *pHead, int16_t headLen, void
                                ProcFuncType ftype);
 
 typedef struct {
-  int32_t       childQueueSize;
   ProcConsumeFp childConsumeFp;
   ProcMallocFp  childMallocHeadFp;
   ProcFreeFp    childFreeHeadFp;
   ProcMallocFp  childMallocBodyFp;
   ProcFreeFp    childFreeBodyFp;
-  int32_t       parentQueueSize;
   ProcConsumeFp parentConsumeFp;
-  ProcMallocFp  parentdMallocHeadFp;
+  ProcMallocFp  parentMallocHeadFp;
   ProcFreeFp    parentFreeHeadFp;
   ProcMallocFp  parentMallocBodyFp;
   ProcFreeFp    parentFreeBodyFp;
-  bool          testFlag;
+  SShm          shm;
   void         *pParent;
   const char   *name;
+  bool          isChild;
 } SProcCfg;
 
 SProcObj *taosProcInit(const SProcCfg *pCfg);
 void      taosProcCleanup(SProcObj *pProc);
 int32_t   taosProcRun(SProcObj *pProc);
-void      taosProcStop(SProcObj *pProc);
-bool      taosProcIsChild(SProcObj *pProc);
-int32_t   taosProcChildId(SProcObj *pProc);
 int32_t   taosProcPutToChildQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,
                               ProcFuncType ftype);
 int32_t   taosProcPutToParentQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen,

source/client/consumer/consumer.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 "consumer.h"

source/client/src/clientEnv.c

@@ -200,6 +200,9 @@ static void doDestroyRequest(void *p) {
     taosArrayDestroy(pRequest->body.showInfo.pArray);
   }
 
+  taosArrayDestroy(pRequest->tableList);
+  taosArrayDestroy(pRequest->dbList);
+
   deregisterRequest(pRequest);
   taosMemoryFreeClear(pRequest);
 }

source/client/src/clientMain.c

-#include "os.h"
-#include "tref.h"
-#include "trpc.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 "catalog.h"
 #include "clientInt.h"
 #include "clientLog.h"
+#include "os.h"
 #include "query.h"
-#include "tmsg.h"
 #include "tglobal.h"
-#include "catalog.h"
+#include "tmsg.h"
+#include "tref.h"
+#include "trpc.h"
 #include "version.h"
 
 #define TSC_VAR_NOT_RELEASE 1
@@ -24,7 +39,7 @@ int taos_options(TSDB_OPTION option, const void *arg, ...) {
     }
   }
 
-  int ret = taos_options_imp(option, (const char*)arg);
+  int ret = taos_options_imp(option, (const char *)arg);
   atomic_store_32(&lock, 0);
   return ret;
 }
@@ -56,6 +71,12 @@ void taos_cleanup(void) {
   tscInfo("all local resources released");
 }
 
+setConfRet   taos_set_config(const char *config) {
+  // TODO
+  setConfRet ret = {SET_CONF_RET_SUCC, {0}};
+  return ret;
+}
+
 TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
   tscDebug("try to connect to %s:%u, user:%s db:%s", ip, port, user, db);
   if (user == NULL) {
@@ -69,13 +90,13 @@ TAOS *taos_connect(const char *ip, const char *user, const char *pass, const cha
   return taos_connect_internal(ip, user, pass, NULL, db, port);
 }
 
-void taos_close(TAOS* taos) {
+void taos_close(TAOS *taos) {
   if (taos == NULL) {
     return;
   }
 
   STscObj *pTscObj = (STscObj *)taos;
-  tscDebug("0x%"PRIx64" try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs);
+  tscDebug("0x%" PRIx64 " try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs);
 
   /*taosRemoveRef(clientConnRefPool, pTscObj->id);*/
 }
@@ -85,48 +106,46 @@ int taos_errno(TAOS_RES *tres) {
     return terrno;
   }
 
-  return ((SRequestObj*) tres)->code;
+  return ((SRequestObj *)tres)->code;
 }
 
 const char *taos_errstr(TAOS_RES *res) {
-  SRequestObj *pRequest = (SRequestObj *) res;
+  SRequestObj *pRequest = (SRequestObj *)res;
 
   if (pRequest == NULL) {
-    return (const char*) tstrerror(terrno);
+    return (const char *)tstrerror(terrno);
   }
 
   if (strlen(pRequest->msgBuf) > 0 || pRequest->code == TSDB_CODE_RPC_FQDN_ERROR) {
     return pRequest->msgBuf;
   } else {
-    return (const char*)tstrerror(pRequest->code);
+    return (const char *)tstrerror(pRequest->code);
   }
 }
 
 void taos_free_result(TAOS_RES *res) {
-  SRequestObj* pRequest = (SRequestObj*) res;
+  SRequestObj *pRequest = (SRequestObj *)res;
   destroyRequest(pRequest);
 }
 
-int  taos_field_count(TAOS_RES *res) {
+int taos_field_count(TAOS_RES *res) {
   if (res == NULL) {
     return 0;
   }
 
-  SRequestObj* pRequest = (SRequestObj*) res;
-  SReqResultInfo* pResInfo = &pRequest->body.resInfo;
+  SRequestObj    *pRequest = (SRequestObj *)res;
+  SReqResultInfo *pResInfo = &pRequest->body.resInfo;
   return pResInfo->numOfCols;
 }
 
-int  taos_num_fields(TAOS_RES *res) {
-  return taos_field_count(res);
-}
+int taos_num_fields(TAOS_RES *res) { return taos_field_count(res); }
 
 TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
   if (taos_num_fields(res) == 0) {
     return NULL;
   }
 
-  SReqResultInfo* pResInfo = &(((SRequestObj*) res)->body.resInfo);
+  SReqResultInfo *pResInfo = &(((SRequestObj *)res)->body.resInfo);
   return pResInfo->fields;
 }
 
@@ -135,7 +154,7 @@ TAOS_RES *taos_query(TAOS *taos, const char *sql) {
     return NULL;
   }
 
-  return taos_query_l(taos, sql, (int32_t) strlen(sql));
+  return taos_query_l(taos, sql, (int32_t)strlen(sql));
 }
 
 TAOS_ROW taos_fetch_row(TAOS_RES *res) {
@@ -143,18 +162,16 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
     return NULL;
   }
 
-  SRequestObj *pRequest = (SRequestObj *) res;
-  if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
-      pRequest->type == TSDB_SQL_INSERT ||
-      pRequest->code != TSDB_CODE_SUCCESS ||
-      taos_num_fields(res) == 0) {
+  SRequestObj *pRequest = (SRequestObj *)res;
+  if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pRequest->type == TSDB_SQL_INSERT ||
+      pRequest->code != TSDB_CODE_SUCCESS || taos_num_fields(res) == 0) {
     return NULL;
   }
 
   return doFetchRow(pRequest, true);
 }
 
-int  taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
+int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
   int32_t len = 0;
   for (int i = 0; i < num_fields; ++i) {
     if (i > 0) {
@@ -213,7 +230,7 @@ int  taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
 
       case TSDB_DATA_TYPE_BINARY:
       case TSDB_DATA_TYPE_NCHAR: {
-        int32_t charLen = varDataLen((char*)row[i] - VARSTR_HEADER_SIZE);
+        int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE);
         if (fields[i].type == TSDB_DATA_TYPE_BINARY) {
           assert(charLen <= fields[i].bytes && charLen >= 0);
         } else {
@@ -238,31 +255,49 @@ int  taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
   return len;
 }
 
-int* taos_fetch_lengths(TAOS_RES *res) {
+int *taos_fetch_lengths(TAOS_RES *res) {
   if (res == NULL) {
     return NULL;
   }
 
-  return ((SRequestObj*) res)->body.resInfo.length;
+  return ((SRequestObj *)res)->body.resInfo.length;
+}
+
+TAOS_ROW *taos_result_block(TAOS_RES *res) {
+  // TODO
+  return NULL;
 }
 
 // todo intergrate with tDataTypes
 const char *taos_data_type(int type) {
   switch (type) {
-    case TSDB_DATA_TYPE_NULL:            return "TSDB_DATA_TYPE_NULL";
-    case TSDB_DATA_TYPE_BOOL:            return "TSDB_DATA_TYPE_BOOL";
-    case TSDB_DATA_TYPE_TINYINT:         return "TSDB_DATA_TYPE_TINYINT";
-    case TSDB_DATA_TYPE_SMALLINT:        return "TSDB_DATA_TYPE_SMALLINT";
-    case TSDB_DATA_TYPE_INT:             return "TSDB_DATA_TYPE_INT";
-    case TSDB_DATA_TYPE_BIGINT:          return "TSDB_DATA_TYPE_BIGINT";
-    case TSDB_DATA_TYPE_FLOAT:           return "TSDB_DATA_TYPE_FLOAT";
-    case TSDB_DATA_TYPE_DOUBLE:          return "TSDB_DATA_TYPE_DOUBLE";
-    case TSDB_DATA_TYPE_VARCHAR:         return "TSDB_DATA_TYPE_VARCHAR";
-//    case TSDB_DATA_TYPE_BINARY:          return "TSDB_DATA_TYPE_VARCHAR";
-    case TSDB_DATA_TYPE_TIMESTAMP:       return "TSDB_DATA_TYPE_TIMESTAMP";
-    case TSDB_DATA_TYPE_NCHAR:           return "TSDB_DATA_TYPE_NCHAR";
-    case TSDB_DATA_TYPE_JSON:            return "TSDB_DATA_TYPE_JSON";
-    default: return "UNKNOWN";
+    case TSDB_DATA_TYPE_NULL:
+      return "TSDB_DATA_TYPE_NULL";
+    case TSDB_DATA_TYPE_BOOL:
+      return "TSDB_DATA_TYPE_BOOL";
+    case TSDB_DATA_TYPE_TINYINT:
+      return "TSDB_DATA_TYPE_TINYINT";
+    case TSDB_DATA_TYPE_SMALLINT:
+      return "TSDB_DATA_TYPE_SMALLINT";
+    case TSDB_DATA_TYPE_INT:
+      return "TSDB_DATA_TYPE_INT";
+    case TSDB_DATA_TYPE_BIGINT:
+      return "TSDB_DATA_TYPE_BIGINT";
+    case TSDB_DATA_TYPE_FLOAT:
+      return "TSDB_DATA_TYPE_FLOAT";
+    case TSDB_DATA_TYPE_DOUBLE:
+      return "TSDB_DATA_TYPE_DOUBLE";
+    case TSDB_DATA_TYPE_VARCHAR:
+      return "TSDB_DATA_TYPE_VARCHAR";
+      //    case TSDB_DATA_TYPE_BINARY:          return "TSDB_DATA_TYPE_VARCHAR";
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      return "TSDB_DATA_TYPE_TIMESTAMP";
+    case TSDB_DATA_TYPE_NCHAR:
+      return "TSDB_DATA_TYPE_NCHAR";
+    case TSDB_DATA_TYPE_JSON:
+      return "TSDB_DATA_TYPE_JSON";
+    default:
+      return "UNKNOWN";
   }
 }
 
@@ -273,8 +308,8 @@ int taos_affected_rows(TAOS_RES *res) {
     return 0;
   }
 
-  SRequestObj* pRequest = (SRequestObj*) res;
-  SReqResultInfo* pResInfo = &pRequest->body.resInfo;
+  SRequestObj    *pRequest = (SRequestObj *)res;
+  SReqResultInfo *pResInfo = &pRequest->body.resInfo;
   return pResInfo->numOfRows;
 }
 
@@ -295,8 +330,8 @@ int taos_select_db(TAOS *taos, const char *db) {
   char sql[256] = {0};
   snprintf(sql, tListLen(sql), "use %s", db);
 
-  TAOS_RES* pRequest = taos_query(taos, sql);
-  int32_t code = taos_errno(pRequest);
+  TAOS_RES *pRequest = taos_query(taos, sql);
+  int32_t   code = taos_errno(pRequest);
 
   taos_free_result(pRequest);
   return code;
@@ -307,53 +342,59 @@ void taos_stop_query(TAOS_RES *res) {
     return;
   }
 
-  SRequestObj* pRequest = (SRequestObj*) res;
-  int32_t numOfFields = taos_num_fields(pRequest);
+  SRequestObj *pRequest = (SRequestObj *)res;
+  int32_t      numOfFields = taos_num_fields(pRequest);
 
   // It is not a query, no need to stop.
   if (numOfFields == 0) {
     return;
   }
 
-//  scheduleCancelJob(pRequest->body.pQueryJob);
+  //  scheduleCancelJob(pRequest->body.pQueryJob);
 }
 
 bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
-  SRequestObj* pRequestObj = res;
-  SReqResultInfo* pResultInfo = &pRequestObj->body.resInfo;
+  SRequestObj    *pRequestObj = res;
+  SReqResultInfo *pResultInfo = &pRequestObj->body.resInfo;
   if (col >= pResultInfo->numOfCols || col < 0 || row >= pResultInfo->numOfRows || row < 0) {
     return true;
   }
 
-  SResultColumn* pCol = &pRequestObj->body.resInfo.pCol[col];
+  SResultColumn *pCol = &pRequestObj->body.resInfo.pCol[col];
   return colDataIsNull_f(pCol->nullbitmap, row);
 }
 
-int  taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
+bool taos_is_update_query(TAOS_RES *res) {
+  // TODO
+  return true;
+}
+
+int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
   if (res == NULL) {
     return 0;
   }
 
-  SRequestObj *pRequest = (SRequestObj *) res;
-  if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
-      pRequest->type == TSDB_SQL_INSERT ||
-      pRequest->code != TSDB_CODE_SUCCESS ||
-      taos_num_fields(res) == 0) {
+  SRequestObj *pRequest = (SRequestObj *)res;
+  if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pRequest->type == TSDB_SQL_INSERT ||
+      pRequest->code != TSDB_CODE_SUCCESS || taos_num_fields(res) == 0) {
     return 0;
   }
 
   doFetchRow(pRequest, false);
 
   // TODO refactor
-  SReqResultInfo* pResultInfo = &pRequest->body.resInfo;
+  SReqResultInfo *pResultInfo = &pRequest->body.resInfo;
   pResultInfo->current = pResultInfo->numOfRows;
   *rows = pResultInfo->row;
 
   return pResultInfo->numOfRows;
 }
 
-int  taos_validate_sql(TAOS *taos, const char *sql) {
-  return true;
+int taos_validate_sql(TAOS *taos, const char *sql) { return true; }
+
+void taos_reset_current_db(TAOS *taos) {
+  // TODO
+  return;
 }
 
 const char *taos_get_server_info(TAOS *taos) {
@@ -361,7 +402,7 @@ const char *taos_get_server_info(TAOS *taos) {
     return NULL;
   }
 
-  STscObj* pTscObj = (STscObj*) taos;
+  STscObj *pTscObj = (STscObj *)taos;
   return pTscObj->ver;
 }
 
@@ -387,52 +428,67 @@ void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress) {
     // TODO
 }
 
-TAOS_STMT* taos_stmt_init(TAOS* taos) {
-    // TODO
-    return NULL;
+int taos_load_table_info(TAOS *taos, const char *tableNameList) {
+  // TODO
+  return -1;
 }
 
-int taos_stmt_close(TAOS_STMT* stmt) {
-    // TODO
-    return -1;
+TAOS_STMT *taos_stmt_init(TAOS *taos) {
+  // TODO
+  return NULL;
 }
 
-int taos_stmt_execute(TAOS_STMT* stmt) {
-    // TODO
-    return -1;
+int taos_stmt_close(TAOS_STMT *stmt) {
+  // TODO
+  return -1;
+}
+
+int taos_stmt_execute(TAOS_STMT *stmt) {
+  // TODO
+  return -1;
 }
 
 char *taos_stmt_errstr(TAOS_STMT *stmt) {
-    // TODO
-    return NULL;
+  // TODO
+  return NULL;
 }
 
-int taos_stmt_affected_rows(TAOS_STMT* stmt) {
-    // TODO
-    return -1;
+int taos_stmt_affected_rows(TAOS_STMT *stmt) {
+  // TODO
+  return -1;
 }
 
-TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int protocol, int precision) {
-    // TODO
-    return NULL;
+TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision) {
+  // TODO
+  return NULL;
 }
 
-int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
-    // TODO
-    return -1;
+int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_BIND *bind) {
+  // TODO
+  return -1;
 }
 
-int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
-    // TODO
-    return -1;
+int taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length) {
+  // TODO
+  return -1;
+}
+
+int taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_BIND *tags) {
+  // TODO
+  return -1;
+}
+
+int taos_stmt_set_tbname(TAOS_STMT *stmt, const char *name) {
+  // TODO
+  return -1;
 }
 
-int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags) {
+int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
     // TODO
     return -1;
 }
 
-int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
+int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
     // TODO
     return -1;
 }
@@ -442,6 +498,11 @@ int taos_stmt_add_batch(TAOS_STMT* stmt) {
     return -1;
 }
 
+TAOS_RES *taos_stmt_use_result(TAOS_STMT *stmt) {
+    // TODO
+    return NULL;
+}
+
 int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
     // TODO
     return -1;

source/client/src/tmq.c

@@ -26,6 +26,18 @@
 #include "tqueue.h"
 #include "tref.h"
 
+typedef struct {
+  int32_t curBlock;
+  int32_t curRow;
+  void**  uData;
+} SMqRowIter;
+
+struct tmq_message_t {
+  SMqPollRsp msg;
+  void*      vg;
+  SMqRowIter iter;
+};
+
 struct tmq_list_t {
   SArray container;
 };
@@ -99,13 +111,14 @@ typedef struct {
 
 typedef struct {
   // subscribe info
-  int32_t        sqlLen;
-  char*          sql;
-  char*          topicName;
-  int64_t        topicId;
-  int32_t        nextVgIdx;
-  SArray*        vgs;  // SArray<SMqClientVg>
-  SSchemaWrapper schema;
+  int32_t     sqlLen;
+  char*       sql;
+  char*       topicName;
+  int64_t     topicId;
+  SArray*     vgs;  // SArray<SMqClientVg>
+  int8_t      isSchemaAdaptive;
+  int32_t     numOfFields;
+  TAOS_FIELD* fields;
 } SMqClientTopic;
 
 typedef struct {
@@ -130,11 +143,11 @@ typedef struct {
 } SMqPollCbParam;
 
 typedef struct {
-  tmq_t* tmq;
-  /*SMqClientVg* pVg;*/
+  tmq_t*         tmq;
   int32_t        async;
   tsem_t         rspSem;
   tmq_resp_err_t rspErr;
+  /*SMqClientVg* pVg;*/
 } SMqCommitCbParam;
 
 tmq_conf_t* tmq_conf_new() {
@@ -228,6 +241,10 @@ void tmq_list_destroy(tmq_list_t* list) {
   taosArrayDestroyEx(container, (void (*)(void*))taosMemoryFree);
 }
 
+static int32_t tmqMakeTopicVgKey(char* dst, const char* topicName, int32_t vg) {
+  return sprintf(dst, "%s:%d", topicName, vg);
+}
+
 void tmqClearUnhandleMsg(tmq_t* tmq) {
   tmq_message_t* msg = NULL;
   while (1) {
@@ -471,7 +488,12 @@ tmq_resp_err_t tmq_subscribe(tmq_t* tmq, tmq_list_t* topic_list) {
     tNameExtractFullName(&name, topicFname);
     tscDebug("subscribe topic: %s", topicFname);
     SMqClientTopic topic = {
-        .nextVgIdx = 0, .sql = NULL, .sqlLen = 0, .topicId = 0, .topicName = topicFname, .vgs = NULL};
+        .sql = NULL,
+        .sqlLen = 0,
+        .topicId = 0,
+        .topicName = topicFname,
+        .vgs = NULL,
+    };
     topic.vgs = taosArrayInit(0, sizeof(SMqClientVg));
     taosArrayPush(tmq->clientTopics, &topic);
     taosArrayPush(req.topicNames, &topicFname);
@@ -615,6 +637,7 @@ _return:
   return pRequest;
 }
 
+#if 0
 TAOS_RES* tmq_create_topic(TAOS* taos, const char* topicName, const char* sql, int sqlLen) {
   STscObj*     pTscObj = (STscObj*)taos;
   SRequestObj* pRequest = NULL;
@@ -700,6 +723,7 @@ _return:
 
   return pRequest;
 }
+#endif
 
 static char* formatTimestamp(char* buf, int64_t val, int precision) {
   time_t  tt;
@@ -807,7 +831,7 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
   SMqClientVg*    pVg = pParam->pVg;
   tmq_t*          tmq = pParam->tmq;
   if (code != 0) {
-    printf("msg discard, code:%x\n", code);
+    tscWarn("msg discard, code:%x", code);
     goto WRITE_QUEUE_FAIL;
   }
 
@@ -815,12 +839,12 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
   int32_t tmqEpoch = atomic_load_32(&tmq->epoch);
   if (msgEpoch < tmqEpoch) {
     tsem_post(&tmq->rspSem);
-    printf("discard rsp epoch %d, current epoch %d\n", msgEpoch, tmqEpoch);
+    tscWarn("discard rsp epoch %d, current epoch %d", msgEpoch, tmqEpoch);
     return 0;
   }
 
   if (msgEpoch != tmqEpoch) {
-    printf("mismatch rsp epoch %d, current epoch %d\n", msgEpoch, tmqEpoch);
+    tscWarn("mismatch rsp epoch %d, current epoch %d", msgEpoch, tmqEpoch);
   } else {
     atomic_sub_fetch_32(&tmq->waitingRequest, 1);
   }
@@ -879,19 +903,54 @@ WRITE_QUEUE_FAIL:
 bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqCMGetSubEpRsp* pRsp) {
   /*printf("call update ep %d\n", epoch);*/
   bool    set = false;
-  int32_t sz = taosArrayGetSize(pRsp->topics);
-  SArray* newTopics = taosArrayInit(sz, sizeof(SMqClientTopic));
-  for (int32_t i = 0; i < sz; i++) {
+  int32_t topicNumGet = taosArrayGetSize(pRsp->topics);
+  char    vgKey[TSDB_TOPIC_FNAME_LEN + 22];
+  SArray* newTopics = taosArrayInit(topicNumGet, sizeof(SMqClientTopic));
+  if (newTopics == NULL) {
+    return false;
+  }
+  SHashObj* pHash = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK);
+  if (pHash == NULL) {
+    taosArrayDestroy(newTopics);
+    return false;
+  }
+
+  // find topic, build hash
+  for (int32_t i = 0; i < topicNumGet; i++) {
     SMqClientTopic topic = {0};
     SMqSubTopicEp* pTopicEp = taosArrayGet(pRsp->topics, i);
+    taosHashClear(pHash);
     topic.topicName = strdup(pTopicEp->topic);
-    int32_t vgSz = taosArrayGetSize(pTopicEp->vgs);
-    topic.vgs = taosArrayInit(vgSz, sizeof(SMqClientVg));
-    for (int32_t j = 0; j < vgSz; j++) {
+
+    int32_t topicNumCur = taosArrayGetSize(tmq->clientTopics);
+    for (int32_t j = 0; j < topicNumCur; j++) {
+      // find old topic
+      SMqClientTopic* pTopicCur = taosArrayGet(tmq->clientTopics, j);
+      if (pTopicCur->vgs && strcmp(pTopicCur->topicName, pTopicEp->topic) == 0) {
+        int32_t vgNumCur = taosArrayGetSize(pTopicCur->vgs);
+        if (vgNumCur == 0) break;
+        for (int32_t k = 0; k < vgNumCur; k++) {
+          SMqClientVg* pVgCur = taosArrayGet(pTopicCur->vgs, k);
+          sprintf(vgKey, "%s:%d", topic.topicName, pVgCur->vgId);
+          taosHashPut(pHash, vgKey, strlen(vgKey), &pVgCur->currentOffset, sizeof(int64_t));
+        }
+        break;
+      }
+    }
+
+    int32_t vgNumGet = taosArrayGetSize(pTopicEp->vgs);
+    topic.vgs = taosArrayInit(vgNumGet, sizeof(SMqClientVg));
+    for (int32_t j = 0; j < vgNumGet; j++) {
       SMqSubVgEp* pVgEp = taosArrayGet(pTopicEp->vgs, j);
+      sprintf(vgKey, "%s:%d", topic.topicName, pVgEp->vgId);
+      int64_t* pOffset = taosHashGet(pHash, vgKey, strlen(vgKey));
+      int64_t  offset = pVgEp->offset;
+      if (pOffset != NULL) {
+        offset = *pOffset;
+      }
       SMqClientVg clientVg = {
           .pollCnt = 0,
-          .currentOffset = pVgEp->offset,
+          .currentOffset = offset,
           .vgId = pVgEp->vgId,
           .epSet = pVgEp->epSet,
           .vgStatus = TMQ_VG_STATUS__IDLE,
@@ -902,6 +961,7 @@ bool tmqUpdateEp(tmq_t* tmq, int32_t epoch, SMqCMGetSubEpRsp* pRsp) {
     taosArrayPush(newTopics, &topic);
   }
   if (tmq->clientTopics) taosArrayDestroy(tmq->clientTopics);
+  taosHashCleanup(pHash);
   tmq->clientTopics = newTopics;
   atomic_store_32(&tmq->epoch, epoch);
   return set;
@@ -911,7 +971,7 @@ int32_t tmqAskEpCb(void* param, const SDataBuf* pMsg, int32_t code) {
   SMqAskEpCbParam* pParam = (SMqAskEpCbParam*)param;
   tmq_t*           tmq = pParam->tmq;
   if (code != 0) {
-    printf("get topic endpoint error, not ready, wait:%d\n", pParam->sync);
+    tscError("get topic endpoint error, not ready, wait:%d\n", pParam->sync);
     goto END;
   }
 
@@ -1282,6 +1342,7 @@ tmq_message_t* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
 
   while (1) {
     /*printf("cycle\n");*/
+    tmqAskEp(tmq, false);
     tmqPollImpl(tmq, blocking_time);
 
     tsem_wait(&tmq->rspSem);

source/client/test/tmqTest.cpp

@@ -35,7 +35,7 @@ int main(int argc, char** argv) {
 
 TEST(testCase, driverInit_Test) {
   // taosInitGlobalCfg();
-//  taos_init();
+  //  taos_init();
 }
 
 TEST(testCase, create_topic_ctb_Test) {
@@ -55,8 +55,9 @@ TEST(testCase, create_topic_ctb_Test) {
 
   taos_free_result(pRes);
 
-  char* sql = "select * from tu";
-  pRes = tmq_create_topic(pConn, "test_ctb_topic_1", sql, strlen(sql));
+  // char* sql = "select * from tu";
+  // pRes = tmq_create_topic(pConn, "test_ctb_topic_1", sql, strlen(sql));
+  pRes = taos_query(pConn, "create test_ctb_topic_1 as select * from tu");
   taos_free_result(pRes);
   taos_close(pConn);
 }
@@ -69,7 +70,7 @@ TEST(testCase, create_topic_stb_Test) {
   if (taos_errno(pRes) != 0) {
     printf("error in use db, reason:%s\n", taos_errstr(pRes));
   }
-  //taos_free_result(pRes);
+  // taos_free_result(pRes);
 
   TAOS_FIELD* pFields = taos_fetch_fields(pRes);
   ASSERT_TRUE(pFields == nullptr);
@@ -79,8 +80,9 @@ TEST(testCase, create_topic_stb_Test) {
 
   taos_free_result(pRes);
 
-  char* sql = "select * from st1";
-  pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql));
+  // char* sql = "select * from st1";
+  // pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql));
+  pRes = taos_query(pConn, "create test_ctb_topic_1 as select * from st1");
   taos_free_result(pRes);
   taos_close(pConn);
 }

source/common/src/tdatablock.c

@@ -331,7 +331,6 @@ int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock) {
     return 0;
   }
 
-  ASSERT(pColInfoData->nullbitmap == NULL);
   pDataBlock->info.window.skey = *(TSKEY*)colDataGetData(pColInfoData, 0);
   pDataBlock->info.window.ekey = *(TSKEY*)colDataGetData(pColInfoData, (pDataBlock->info.rows - 1));
   return 0;
@@ -609,22 +608,6 @@ size_t blockDataGetSerialMetaSize(const SSDataBlock* pBlock) {
   return sizeof(int32_t) + pBlock->info.numOfCols * sizeof(int32_t);
 }
 
-SSchema* blockDataExtractSchema(const SSDataBlock* pBlock, int32_t* numOfCols) {
-  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;
-    pSchema[i].type = pColInfoData->info.type;
-    pSchema[i].colId = pColInfoData->info.colId;
-  }
-
-  if (numOfCols != NULL) {
-    *numOfCols = pBlock->info.numOfCols;
-  }
-
-  return pSchema;
-}
-
 double blockDataGetSerialRowSize(const SSDataBlock* pBlock) {
   ASSERT(pBlock != NULL);
   double rowSize = 0;

source/common/src/tglobal.c

@@ -45,7 +45,7 @@ float   tsRatioOfQueryCores = 1.0f;
 int32_t tsMaxBinaryDisplayWidth = 30;
 bool    tsEnableSlaveQuery = 1;
 bool    tsPrintAuth = 0;
-int32_t tsMultiProcess = 0;
+bool    tsMultiProcess = 0;
 
 // monitor
 bool     tsEnableMonitor = 1;
@@ -347,7 +347,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddBool(pCfg, "printAuth", tsPrintAuth, 0) != 0) return -1;
   if (cfgAddBool(pCfg, "slaveQuery", tsEnableSlaveQuery, 0) != 0) return -1;
   if (cfgAddBool(pCfg, "deadLockKillQuery", tsDeadLockKillQuery, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "multiProcess", tsMultiProcess, 0, 2, 0) != 0) return -1;
+  if (cfgAddBool(pCfg, "multiProcess", tsMultiProcess, 0) != 0) return -1;
 
   if (cfgAddBool(pCfg, "monitor", tsEnableMonitor, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "monitorInterval", tsMonitorInterval, 1, 360000, 0) != 0) return -1;
@@ -466,7 +466,7 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsPrintAuth = cfgGetItem(pCfg, "printAuth")->bval;
   tsEnableSlaveQuery = cfgGetItem(pCfg, "slaveQuery")->bval;
   tsDeadLockKillQuery = cfgGetItem(pCfg, "deadLockKillQuery")->bval;
-  tsMultiProcess = cfgGetItem(pCfg, "multiProcess")->i32;
+  tsMultiProcess = cfgGetItem(pCfg, "multiProcess")->bval;
 
   tsEnableMonitor = cfgGetItem(pCfg, "monitor")->bval;
   tsMonitorInterval = cfgGetItem(pCfg, "monitorInterval")->i32;

source/common/src/tmsgcb.c

@@ -16,6 +16,10 @@
 #define _DEFAULT_SOURCE
 #include "tmsgcb.h"
 
+static SMsgCb tsDefaultMsgCb;
+
+void tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb) { tsDefaultMsgCb = *pMsgCb; }
+
 int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq) {
   return (*pMsgCb->queueFps[qtype])(pMsgCb->pWrapper, pReq);
 }
@@ -32,12 +36,12 @@ int32_t tmsgSendMnodeReq(const SMsgCb* pMsgCb, SRpcMsg* pReq) {
   return (*pMsgCb->sendMnodeReqFp)(pMsgCb->pWrapper, pReq);
 }
 
-void tmsgSendRsp(const SMsgCb* pMsgCb, const SRpcMsg* pRsp) { return (*pMsgCb->sendRspFp)(pMsgCb->pWrapper, pRsp); }
+void tmsgSendRsp(const SRpcMsg* pRsp) { return (*tsDefaultMsgCb.sendRspFp)(tsDefaultMsgCb.pWrapper, pRsp); }
 
 void tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg) {
   (*pMsgCb->registerBrokenLinkArgFp)(pMsgCb->pWrapper, pMsg);
 }
 
-void tmsgReleaseHandle(const SMsgCb* pMsgCb, void* handle, int8_t type) {
-  (*pMsgCb->releaseHandleFp)(pMsgCb->pWrapper, handle, type);
+void tmsgReleaseHandle(void* handle, int8_t type) {
+  (*tsDefaultMsgCb.releaseHandleFp)(tsDefaultMsgCb.pWrapper, handle, type);
 }
\ No newline at end of file

source/dnode/mgmt/CMakeLists.txt

-aux_source_directory(src DNODE_SRC)
-aux_source_directory(dnode/src DNODE_SRC)
-aux_source_directory(qnode/src DNODE_SRC)
-aux_source_directory(bnode/src DNODE_SRC)
-aux_source_directory(snode/src DNODE_SRC)
-aux_source_directory(vnode/src DNODE_SRC)
-aux_source_directory(mnode/src DNODE_SRC)
-aux_source_directory(container/src DNODE_SRC)
-
+aux_source_directory(dm/src DNODE_SRC)
+aux_source_directory(qm/src DNODE_SRC)
+aux_source_directory(bm/src DNODE_SRC)
+aux_source_directory(sm/src DNODE_SRC)
+aux_source_directory(vm/src DNODE_SRC)
+aux_source_directory(mm/src DNODE_SRC)
+aux_source_directory(main/src DNODE_SRC)
 add_library(dnode STATIC ${DNODE_SRC})
 target_link_libraries(
     dnode cjson mnode vnode qnode snode bnode wal sync taos tfs monitor
@@ -14,16 +12,22 @@ target_link_libraries(
 target_include_directories(
     dnode
     PUBLIC "${CMAKE_SOURCE_DIR}/include/dnode/mgmt"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/dnode/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/qnode/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/bnode/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/snode/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/vnode/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/mnode/inc"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/container/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/dm/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/qm/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/bm/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/sm/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/vm/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/mm/inc"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/main/inc"
 )
 
-add_subdirectory(main)
+aux_source_directory(main/exe EXEC_SRC)
+add_executable(taosd ${EXEC_SRC})
+target_include_directories(
+    taosd
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/main/inc"
+)
+target_link_libraries(taosd dnode)
 
 if(${BUILD_TEST})
     add_subdirectory(test)

source/dnode/mgmt/container/src/dndFile.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/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "dndInt.h"
-
-#define MAXLEN 1024
-
-int32_t dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed) {
-  int32_t       code = TSDB_CODE_NODE_PARSE_FILE_ERROR;
-  int32_t       len = 0;
-  const int32_t maxLen = MAXLEN;
-  char          content[MAXLEN + 1] = {0};
-  cJSON        *root = NULL;
-  char          file[PATH_MAX];
-  TdFilePtr     pFile = NULL;
-
-  snprintf(file, sizeof(file), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
-  pFile = taosOpenFile(file, TD_FILE_READ);
-  if (pFile == NULL) {
-    dDebug("file %s not exist", file);
-    code = 0;
-    goto _OVER;
-  }
-
-  len = (int32_t)taosReadFile(pFile, content, maxLen);
-  if (len <= 0) {
-    dError("failed to read %s since content is null", file);
-    goto _OVER;
-  }
-
-  content[len] = 0;
-  root = cJSON_Parse(content);
-  if (root == NULL) {
-    dError("failed to read %s since invalid json format", file);
-    goto _OVER;
-  }
-
-  cJSON *deployed = cJSON_GetObjectItem(root, "deployed");
-  if (!deployed || deployed->type != cJSON_Number) {
-    dError("failed to read %s since deployed not found", file);
-    goto _OVER;
-  }
-  *pDeployed = deployed->valueint != 0;
-
-  code = 0;
-  dDebug("succcessed to read file %s, deployed:%d", file, *pDeployed);
-
-_OVER:
-  if (root != NULL) cJSON_Delete(root);
-  if (pFile != NULL) taosCloseFile(&pFile);
-
-  terrno = code;
-  return code;
-}
-
-int32_t dndWriteFile(SMgmtWrapper *pWrapper, bool deployed) {
-  char file[PATH_MAX] = {0};
-  snprintf(file, sizeof(file), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
-
-  TdFilePtr pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
-  if (pFile == NULL) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to write %s since %s", file, terrstr());
-    return -1;
-  }
-
-  int32_t       len = 0;
-  const int32_t maxLen = MAXLEN;
-  char          content[MAXLEN + 1] = {0};
-
-  len += snprintf(content + len, maxLen - len, "{\n");
-  len += snprintf(content + len, maxLen - len, "  \"deployed\": %d\n", deployed);
-  len += snprintf(content + len, maxLen - len, "}\n");
-
-  taosWriteFile(pFile, content, len);
-  taosFsyncFile(pFile);
-  taosCloseFile(&pFile);
-
-  char realfile[PATH_MAX] = {0};
-  snprintf(realfile, sizeof(realfile), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
-
-  if (taosRenameFile(file, realfile) != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to rename %s since %s", file, terrstr());
-    return -1;
-  }
-
-  dInfo("successed to write %s, deployed:%d", realfile, deployed);
-  return 0;
-}

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

@@ -130,7 +130,7 @@ int32_t dmReadFile(SDnodeMgmt *pMgmt) {
   }
 
   code = 0;
-  dInfo("succcessed to read file %s", file);
+  dDebug("succcessed to read file %s", file);
   dmPrintDnodes(pMgmt);
 
 PRASE_DNODE_OVER:

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

@@ -112,6 +112,16 @@ int32_t dmInit(SMgmtWrapper *pWrapper) {
     return -1;
   }
 
+  if (dndInitServer(pDnode) != 0) {
+    dError("failed to init trans server since %s", terrstr());
+    return -1;
+  }
+
+  if (dndInitClient(pDnode) != 0) {
+    dError("failed to init trans client since %s", terrstr());
+    return -1;
+  }
+
   pWrapper->pMgmt = pMgmt;
   dInfo("dnode-mgmt is initialized");
   return 0;
@@ -122,6 +132,7 @@ void dmCleanup(SMgmtWrapper *pWrapper) {
   if (pMgmt == NULL) return;
 
   dInfo("dnode-mgmt start to clean up");
+  SDnode *pDnode = pMgmt->pDnode;
   dmStopWorker(pMgmt);
 
   taosWLockLatch(&pMgmt->latch);
@@ -140,6 +151,9 @@ void dmCleanup(SMgmtWrapper *pWrapper) {
 
   taosMemoryFree(pMgmt);
   pWrapper->pMgmt = NULL;
+  dndCleanupServer(pDnode);
+  dndCleanupClient(pDnode);
+
   dInfo("dnode-mgmt is cleaned up");
 }
 

source/dnode/mgmt/main/CMakeLists.txt

-aux_source_directory(src EXEC_SRC)
-add_executable(taosd ${EXEC_SRC})
-
-target_include_directories(
-    taosd
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-
-target_link_libraries(taosd dnode)

source/dnode/mgmt/main/src/dndMain.c → source/dnode/mgmt/main/exe/dndMain.c

@@ -14,19 +14,22 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dndMain.h"
+#include "dnd.h"
+#include "tconfig.h"
 
 static struct {
-  bool    dumpConfig;
-  bool    generateGrant;
-  bool    printAuth;
-  bool    printVersion;
-  char    envFile[PATH_MAX];
-  char    apolloUrl[PATH_MAX];
-  SDnode *pDnode;
+  bool      dumpConfig;
+  bool      generateGrant;
+  bool      printAuth;
+  bool      printVersion;
+  char      envFile[PATH_MAX];
+  char      apolloUrl[PATH_MAX];
+  SArray   *pArgs;  // SConfigPair
+  SDnode   *pDnode;
+  ENodeType ntype;
 } global = {0};
 
-static void dndSigintHandle(int signum, void *info, void *ctx) {
+static void dndStopDnode(int signum, void *info, void *ctx) {
   dInfo("signal:%d is received", signum);
   SDnode *pDnode = atomic_val_compare_exchange_ptr(&global.pDnode, 0, global.pDnode);
   if (pDnode != NULL) {
@@ -34,15 +37,30 @@ static void dndSigintHandle(int signum, void *info, void *ctx) {
   }
 }
 
+static void dndHandleChild(int signum, void *info, void *ctx) {
+  dInfo("signal:%d is received", signum);
+  dndHandleEvent(global.pDnode, DND_EVENT_CHILD);
+}
+
 static void dndSetSignalHandle() {
-  taosSetSignal(SIGTERM, dndSigintHandle);
-  taosSetSignal(SIGHUP, dndSigintHandle);
-  taosSetSignal(SIGINT, dndSigintHandle);
-  taosSetSignal(SIGABRT, dndSigintHandle);
-  taosSetSignal(SIGBREAK, dndSigintHandle);
+  taosSetSignal(SIGTERM, dndStopDnode);
+  taosSetSignal(SIGHUP, dndStopDnode);
+  taosSetSignal(SIGINT, dndStopDnode);
+  taosSetSignal(SIGABRT, dndStopDnode);
+  taosSetSignal(SIGBREAK, dndStopDnode);
+
+  if (!tsMultiProcess) {
+    // Set the single process signal
+  } else if (global.ntype == DNODE) {
+    // When the child process exits, the parent process receives a signal
+    taosSetSignal(SIGCHLD, dndHandleChild);
+  } else {
+    // When the parent process exits, the child process will receive the SIGKILL signal
+    taosKillChildOnSelfStopped();
+  }
 }
 
-static int32_t dndParseOption(int32_t argc, char const *argv[]) {
+static int32_t dndParseArgs(int32_t argc, char const *argv[]) {
   for (int32_t i = 1; i < argc; ++i) {
     if (strcmp(argv[i], "-c") == 0) {
       if (i < argc - 1) {
@@ -55,10 +73,20 @@ static int32_t dndParseOption(int32_t argc, char const *argv[]) {
         printf("'-c' requires a parameter, default is %s\n", configDir);
         return -1;
       }
-    } else if (strcmp(argv[i], "-C") == 0) {
-      global.dumpConfig = true;
+    } else if (strcmp(argv[i], "-a") == 0) {
+      tstrncpy(global.apolloUrl, argv[++i], PATH_MAX);
+    } else if (strcmp(argv[i], "-e") == 0) {
+      tstrncpy(global.envFile, argv[++i], PATH_MAX);
     } else if (strcmp(argv[i], "-k") == 0) {
       global.generateGrant = true;
+    } else if (strcmp(argv[i], "-n") == 0) {
+      global.ntype = atoi(argv[++i]);
+      if (global.ntype <= DNODE || global.ntype > NODE_MAX) {
+        printf("'-n' range is [1-5], default is 0\n");
+        return -1;
+      }
+    } else if (strcmp(argv[i], "-C") == 0) {
+      global.dumpConfig = true;
     } else if (strcmp(argv[i], "-V") == 0) {
       global.printVersion = true;
     } else {
@@ -68,15 +96,65 @@ static int32_t dndParseOption(int32_t argc, char const *argv[]) {
   return 0;
 }
 
+static void dndGenerateGrant() {
+  // grantParseParameter();
+  printf("this feature is not implemented yet\n");
+}
+
+static void dndPrintVersion() {
+#ifdef TD_ENTERPRISE
+  char *releaseName = "enterprise";
+#else
+  char *releaseName = "community";
+#endif
+  printf("%s version: %s compatible_version: %s\n", releaseName, version, compatible_version);
+  printf("gitinfo: %s\n", gitinfo);
+  printf("buildInfo: %s\n", buildinfo);
+}
+
+static void dndDumpCfg() {
+  SConfig *pCfg = taosGetCfg();
+  cfgDumpCfg(pCfg, 0, 1);
+}
+
+static SDnodeOpt dndGetOpt() {
+  SConfig  *pCfg = taosGetCfg();
+  SDnodeOpt option = {0};
+
+  option.numOfSupportVnodes = cfgGetItem(pCfg, "supportVnodes")->i32;
+  tstrncpy(option.dataDir, tsDataDir, sizeof(option.dataDir));
+  tstrncpy(option.firstEp, tsFirst, sizeof(option.firstEp));
+  tstrncpy(option.secondEp, tsSecond, sizeof(option.firstEp));
+  option.serverPort = tsServerPort;
+  tstrncpy(option.localFqdn, tsLocalFqdn, sizeof(option.localFqdn));
+  snprintf(option.localEp, sizeof(option.localEp), "%s:%u", option.localFqdn, option.serverPort);
+  option.disks = tsDiskCfg;
+  option.numOfDisks = tsDiskCfgNum;
+  option.ntype = global.ntype;
+  return option;
+}
+
+static int32_t dndInitLog() {
+  char logName[12] = {0};
+  snprintf(logName, sizeof(logName), "%slog", dndNodeLogStr(global.ntype));
+  return taosCreateLog(logName, 1, configDir, global.envFile, global.apolloUrl, global.pArgs, 0);
+}
+
+static void dndSetProcName(char **argv) {
+  if (global.ntype != DNODE) {
+    const char *name = dndNodeProcStr(global.ntype);
+    taosSetProcName(argv, name);
+  }
+}
+
 static int32_t dndRunDnode() {
   if (dndInit() != 0) {
-    dInfo("failed to initialize dnode environment since %s", terrstr());
+    dError("failed to initialize environment since %s", terrstr());
     return -1;
   }
 
   SDnodeOpt option = dndGetOpt();
-
-  SDnode *pDnode = dndCreate(&option);
+  SDnode   *pDnode = dndCreate(&option);
   if (pDnode == NULL) {
     dError("failed to to create dnode object since %s", terrstr());
     return -1;
@@ -85,9 +163,9 @@ static int32_t dndRunDnode() {
     dndSetSignalHandle();
   }
 
-  dInfo("start the TDengine service");
+  dInfo("start the service");
   int32_t code = dndRun(pDnode);
-  dInfo("start shutting down the TDengine service");
+  dInfo("start shutting down the service");
 
   global.pDnode = NULL;
   dndClose(pDnode);
@@ -99,11 +177,12 @@ static int32_t dndRunDnode() {
 
 int main(int argc, char const *argv[]) {
   if (!taosCheckSystemIsSmallEnd()) {
-    dError("failed to start TDengine since on non-small-end machines");
+    printf("failed to start since on non-small-end machines\n");
     return -1;
   }
 
-  if (dndParseOption(argc, argv) != 0) {
+  if (dndParseArgs(argc, argv) != 0) {
+    printf("failed to start since parse args error\n");
     return -1;
   }
 
@@ -117,13 +196,13 @@ int main(int argc, char const *argv[]) {
     return 0;
   }
 
-  if (taosCreateLog("taosdlog", 1, configDir, global.envFile, global.apolloUrl, NULL, 0) != 0) {
-    dError("failed to start TDengine since read log config error");
+  if (dndInitLog() != 0) {
+    printf("failed to start since init log error\n");
     return -1;
   }
 
-  if (taosInitCfg(configDir, global.envFile, global.apolloUrl, NULL, 0) != 0) {
-    dError("failed to start TDengine since read config error");
+  if (taosInitCfg(configDir, global.envFile, global.apolloUrl, global.pArgs, 0) != 0) {
+    dError("failed to start since read config error");
     return -1;
   }
 
@@ -134,5 +213,6 @@ int main(int argc, char const *argv[]) {
     return 0;
   }
 
+  dndSetProcName((char **)argv);
   return dndRunDnode();
 }

source/dnode/mgmt/container/inc/dnd.h → source/dnode/mgmt/main/inc/dnd.h

@@ -33,6 +33,7 @@
 #include "tthread.h"
 #include "ttime.h"
 #include "tworker.h"
+#include "tmsgcb.h"
 
 #include "dnode.h"
 #include "monitor.h"
@@ -94,12 +95,14 @@ typedef struct SMgmtWrapper {
   bool        deployed;
   bool        required;
   EProcType   procType;
+  int32_t     procId;
   SProcObj   *pProc;
+  SShm        shm;
   void       *pMgmt;
   SDnode     *pDnode;
-  NodeMsgFp   msgFps[TDMT_MAX];
-  int32_t     msgVgIds[TDMT_MAX];  // Handle the case where the same message type is distributed to qnode or vnode
   SMgmtFp     fp;
+  int8_t      msgVgIds[TDMT_MAX];  // Handle the case where the same message type is distributed to qnode or vnode
+  NodeMsgFp   msgFps[TDMT_MAX];
 } SMgmtWrapper;
 
 typedef struct {
@@ -118,30 +121,38 @@ typedef struct SDnode {
   char        *firstEp;
   char        *secondEp;
   char        *dataDir;
-  SDiskCfg    *pDisks;
+  SDiskCfg    *disks;
   int32_t      numOfDisks;
   uint16_t     serverPort;
   bool         dropped;
+  ENodeType    ntype;
   EDndStatus   status;
   EDndEvent    event;
   SStartupReq  startup;
-  TdFilePtr    pLockFile;
+  TdFilePtr    lockfile;
   STransMgmt   trans;
   SMgmtWrapper wrappers[NODE_MAX];
 } SDnode;
 
-EDndStatus dndGetStatus(SDnode *pDnode);
-void       dndSetStatus(SDnode *pDnode, EDndStatus stat);
-void       dndSetMsgHandle(SMgmtWrapper *pWrapper, int32_t msgType, NodeMsgFp nodeMsgFp, int32_t vgId);
-void       dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);
-void       dndSendMonitorReport(SDnode *pDnode);
-
+const char *dndNodeLogStr(ENodeType ntype);
+const char *dndNodeProcStr(ENodeType ntype);
+EDndStatus  dndGetStatus(SDnode *pDnode);
+void        dndSetStatus(SDnode *pDnode, EDndStatus stat);
+void        dndSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp nodeMsgFp, int8_t vgId);
+void        dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);
+void        dndSendMonitorReport(SDnode *pDnode);
+
+int32_t dndInitServer(SDnode *pDnode);
+void    dndCleanupServer(SDnode *pDnode);
+int32_t dndInitClient(SDnode *pDnode);
+void    dndCleanupClient(SDnode *pDnode);
+int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg);
 int32_t dndSendReqToMnode(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
 int32_t dndSendReqToDnode(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pMsg);
 void    dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp);
 void    dndRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
+SMsgCb  dndCreateMsgcb(SMgmtWrapper *pWrapper);
 
-int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg);
 int32_t dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed);
 int32_t dndWriteFile(SMgmtWrapper *pWrapper, bool deployed);
 

source/dnode/mgmt/container/inc/dndInt.h → source/dnode/mgmt/main/inc/dndInt.h

@@ -34,7 +34,6 @@ int32_t     dndInit();
 void        dndCleanup();
 const char *dndStatStr(EDndStatus stat);
 void        dndGetStartup(SDnode *pDnode, SStartupReq *pStartup);
-TdFilePtr   dndCheckRunning(const char *dataDir);
 void        dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pMsg);
 
 // dndMsg.c
@@ -51,13 +50,14 @@ void    dndClose(SDnode *pDnode);
 void    dndHandleEvent(SDnode *pDnode, EDndEvent event);
 
 // dndTransport.c
-int32_t dndInitServer(SDnode *pDnode);
-void    dndCleanupServer(SDnode *pDnode);
-int32_t dndInitClient(SDnode *pDnode);
-void    dndCleanupClient(SDnode *pDnode);
 int32_t dndInitMsgHandle(SDnode *pDnode);
 void    dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp);
 
+// dndFile.c
+TdFilePtr dndCheckRunning(const char *dataDir);
+int32_t   dndReadShmFile(SDnode *pDnode);
+int32_t   dndWriteShmFile(SDnode *pDnode);
+
 #ifdef __cplusplus
 }
 #endif

source/dnode/mgmt/main/inc/dndMain.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_DND_MAIN_H_
-#define _TD_DND_MAIN_H_
-
-#include "dnode.h"
-
-#include "taoserror.h"
-#include "tconfig.h"
-#include "tglobal.h"
-#include "tlog.h"
-#include "version.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define dFatal(...) { if (dDebugFlag & DEBUG_FATAL) { taosPrintLog("DND FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }}
-#define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("DND ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }}
-#define dWarn(...)  { if (dDebugFlag & DEBUG_WARN)  { taosPrintLog("DND WARN ", DEBUG_WARN, 255, __VA_ARGS__); }}
-#define dInfo(...)  { if (dDebugFlag & DEBUG_INFO)  { taosPrintLog("DND ", DEBUG_INFO, 255, __VA_ARGS__); }}
-#define dDebug(...) { if (dDebugFlag & DEBUG_DEBUG) { taosPrintLog("DND ", DEBUG_DEBUG, dDebugFlag, __VA_ARGS__); }}
-#define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", DEBUG_TRACE, dDebugFlag, __VA_ARGS__); }}
-
-void      dndDumpCfg();
-void      dndPrintVersion();
-void      dndGenerateGrant();
-SDnodeOpt dndGetOpt();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_DND_MAIN_H_*/

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

@@ -16,15 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "dndInt.h"
 
-static void dndResetLog(SMgmtWrapper *pMgmt) {
-  char logname[24] = {0};
-  snprintf(logname, sizeof(logname), "%slog", pMgmt->name);
-
-  dInfo("node:%s, reset log to %s in child process", pMgmt->name, logname);
-  taosCloseLog();
-  taosInitLog(logname, 1);
-}
-
 static bool dndRequireNode(SMgmtWrapper *pWrapper) {
   bool required = false;
   int32_t code =(*pWrapper->fp.requiredFp)(pWrapper, &required);
@@ -37,14 +28,18 @@ static bool dndRequireNode(SMgmtWrapper *pWrapper) {
 }
 
 int32_t dndOpenNode(SMgmtWrapper *pWrapper) {
-  int32_t code = (*pWrapper->fp.openFp)(pWrapper);
-  if (code != 0) {
+  if (taosMkDir(pWrapper->path) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("node:%s, failed to create dir:%s since %s", pWrapper->name, pWrapper->path, terrstr());
+    return -1;
+  }
+
+  if ((*pWrapper->fp.openFp)(pWrapper) != 0) {
     dError("node:%s, failed to open since %s", pWrapper->name, terrstr());
     return -1;
-  } else {
-    dDebug("node:%s, has been opened", pWrapper->name);
   }
 
+  dDebug("node:%s, has been opened", pWrapper->name);
   pWrapper->deployed = true;
   return 0;
 }
@@ -71,21 +66,13 @@ void dndCloseNode(SMgmtWrapper *pWrapper) {
 }
 
 static int32_t dndRunInSingleProcess(SDnode *pDnode) {
-  dInfo("dnode run in single process mode");
+  dInfo("dnode start to run in single process");
 
-  for (ENodeType n = 0; n < NODE_MAX; ++n) {
+  for (ENodeType n = DNODE; n < NODE_MAX; ++n) {
     SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
     pWrapper->required = dndRequireNode(pWrapper);
     if (!pWrapper->required) continue;
 
-    if (taosMkDir(pWrapper->path) != 0) {
-      terrno = TAOS_SYSTEM_ERROR(errno);
-      dError("failed to create dir:%s since %s", pWrapper->path, terrstr());
-      return -1;
-    }
-
-    dInfo("node:%s, will start in single process", pWrapper->name);
-    pWrapper->procType = PROC_SINGLE;
     if (dndOpenNode(pWrapper) != 0) {
       dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
       return -1;
@@ -104,24 +91,15 @@ static int32_t dndRunInSingleProcess(SDnode *pDnode) {
     }
   }
 
+  dInfo("dnode running in single process");
   return 0;
 }
 
-static void dndClearNodesExecpt(SDnode *pDnode, ENodeType except) {
-  // dndCleanupServer(pDnode);
-  for (ENodeType n = 0; n < NODE_MAX; ++n) {
-    if (except == n) continue;
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    pWrapper->required = false;
-  }
-}
-
 static void dndConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
                                  ProcFuncType ftype) {
   SRpcMsg *pRpc = &pMsg->rpcMsg;
   pRpc->pCont = pCont;
-  dTrace("msg:%p, get from child queue, type:%s handle:%p app:%p", pMsg, TMSG_INFO(pRpc->msgType), pRpc->handle,
-         pRpc->ahandle);
+  dTrace("msg:%p, get from child queue, handle:%p app:%p", pMsg, pRpc->handle, pRpc->ahandle);
 
   NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)];
   int32_t   code = (*msgFp)(pWrapper, pMsg);
@@ -142,13 +120,19 @@ static void dndConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t
 static void dndConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen,
                                   ProcFuncType ftype) {
   pMsg->pCont = pCont;
-  dTrace("msg:%p, get from parent queue, type:%s handle:%p app:%p", pMsg, TMSG_INFO(pMsg->msgType), pMsg->handle,
-         pMsg->ahandle);
+  dTrace("msg:%p, get from parent queue, handle:%p app:%p", pMsg, pMsg->handle, pMsg->ahandle);
 
   switch (ftype) {
-    case PROC_REGISTER:
+    case PROC_REG:
       rpcRegisterBrokenLinkArg(pMsg);
       break;
+    case PROC_RELEASE:
+      rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code);
+      rpcFreeCont(pCont);
+      break;
+    case PROC_REQ:
+      // todo send to dnode
+      dndSendReqToMnode(pWrapper, pMsg);
     default:
       dndSendRpcRsp(pWrapper, pMsg);
       break;
@@ -156,68 +140,73 @@ static void dndConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t
   taosMemoryFree(pMsg);
 }
 
-static int32_t dndRunInMultiProcess(SDnode *pDnode) {
-  dInfo("dnode run in multi process mode");
+static int32_t dndRunInParentProcess(SDnode *pDnode) {
+  dInfo("dnode start to run in parent process");
+  SMgmtWrapper *pDWrapper = &pDnode->wrappers[DNODE];
+  if (dndOpenNode(pDWrapper) != 0) {
+    dError("node:%s, failed to start since %s", pDWrapper->name, terrstr());
+    return -1;
+  }
 
-  for (ENodeType n = 0; n < NODE_MAX; ++n) {
+  for (ENodeType n = DNODE + 1; n < NODE_MAX; ++n) {
     SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
     pWrapper->required = dndRequireNode(pWrapper);
     if (!pWrapper->required) continue;
 
-    if (taosMkDir(pWrapper->path) != 0) {
-      terrno = TAOS_SYSTEM_ERROR(errno);
-      dError("failed to create dir:%s since %s", pWrapper->path, terrstr());
+    int64_t shmsize = 1024 * 1024 * 2;  // size will be a configuration item
+    if (taosCreateShm(&pWrapper->shm, shmsize) != 0) {
+      terrno = TAOS_SYSTEM_ERROR(terrno);
+      dError("node:%s, failed to create shm size:%" PRId64 " since %s", pWrapper->name, shmsize, terrstr());
       return -1;
     }
 
-    if (n == DNODE) {
-      dInfo("node:%s, will start in parent process", pWrapper->name);
-      pWrapper->procType = PROC_SINGLE;
-      if (dndOpenNode(pWrapper) != 0) {
-        dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
-        return -1;
-      }
-      continue;
-    }
-
-    SProcCfg  cfg = {.childQueueSize = 1024 * 1024 * 2,  // size will be a configuration item
-                     .childConsumeFp = (ProcConsumeFp)dndConsumeChildQueue,
-                     .childMallocHeadFp = (ProcMallocFp)taosAllocateQitem,
-                     .childFreeHeadFp = (ProcFreeFp)taosFreeQitem,
-                     .childMallocBodyFp = (ProcMallocFp)rpcMallocCont,
-                     .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
-                     .parentQueueSize = 1024 * 1024 * 2,  // size will be a configuration item
-                     .parentConsumeFp = (ProcConsumeFp)dndConsumeParentQueue,
-                     .parentdMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
-                     .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
-                     .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
-                     .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
-                     .pParent = pWrapper,
-                     .name = pWrapper->name};
-    SProcObj *pProc = taosProcInit(&cfg);
-    if (pProc == NULL) {
-      dError("node:%s, failed to fork since %s", pWrapper->name, terrstr());
+    SProcCfg cfg = {.childConsumeFp = (ProcConsumeFp)dndConsumeChildQueue,
+                    .childMallocHeadFp = (ProcMallocFp)taosAllocateQitem,
+                    .childFreeHeadFp = (ProcFreeFp)taosFreeQitem,
+                    .childMallocBodyFp = (ProcMallocFp)rpcMallocCont,
+                    .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
+                    .parentConsumeFp = (ProcConsumeFp)dndConsumeParentQueue,
+                    .parentMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
+                    .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
+                    .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
+                    .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
+                    .shm = pWrapper->shm,
+                    .pParent = pWrapper,
+                    .isChild = false,
+                    .name = pWrapper->name};
+
+    pWrapper->procType = PROC_PARENT;
+    pWrapper->pProc = taosProcInit(&cfg);
+    if (pWrapper->pProc == NULL) {
+      dError("node:%s, failed to create proc since %s", pWrapper->name, terrstr());
       return -1;
     }
+  }
 
-    pWrapper->pProc = pProc;
-
-    if (taosProcIsChild(pProc)) {
-      dInfo("node:%s, will start in child process", pWrapper->name);
-      pWrapper->procType = PROC_CHILD;
-      dndResetLog(pWrapper);
+  if (dndWriteShmFile(pDnode) != 0) {
+    dError("failed to write runtime file since %s", terrstr());
+    return -1;
+  }
 
-      dInfo("node:%s, clean up resources inherited from parent", pWrapper->name);
-      dndClearNodesExecpt(pDnode, n);
+  for (ENodeType n = DNODE + 1; n < NODE_MAX; ++n) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
+    if (!pWrapper->required) continue;
 
-      dInfo("node:%s, will be initialized in child process", pWrapper->name);
-      dndOpenNode(pWrapper);
+    if (pDnode->ntype == NODE_MAX) {
+      dInfo("node:%s, should be started manually", pWrapper->name);
     } else {
-      dInfo("node:%s, will not start in parent process, child pid:%d", pWrapper->name, taosProcChildId(pProc));
-      pWrapper->procType = PROC_PARENT;
+      char    args[PATH_MAX];
+      int32_t pid = taosNewProc(args);
+      if (pid <= 0) {
+        terrno = TAOS_SYSTEM_ERROR(errno);
+        dError("node:%s, failed to exec in new process since %s", pWrapper->name, terrstr());
+        return -1;
+      }
+      pWrapper->procId = pid;
+      dInfo("node:%s, run in new process, pid:%d", pWrapper->name, pid);
     }
 
-    if (taosProcRun(pProc) != 0) {
+    if (taosProcRun(pWrapper->pProc) != 0) {
       dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
       return -1;
     }
@@ -225,35 +214,85 @@ static int32_t dndRunInMultiProcess(SDnode *pDnode) {
 
   dndSetStatus(pDnode, DND_STAT_RUNNING);
 
-  for (ENodeType n = 0; n < NODE_MAX; ++n) {
-    SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
-    if (!pWrapper->required) continue;
-    if (pWrapper->fp.startFp == NULL) continue;
-    if (pWrapper->procType == PROC_PARENT && n != DNODE) continue;
-    if (pWrapper->procType == PROC_CHILD && n == DNODE) continue;
+  if ((*pDWrapper->fp.startFp)(pDWrapper) != 0) {
+    dError("node:%s, failed to start since %s", pDWrapper->name, terrstr());
+    return -1;
+  }
+
+  dInfo("dnode running in parent process");
+  return 0;
+}
+
+static int32_t dndRunInChildProcess(SDnode *pDnode) {
+  dInfo("dnode start to run in child process");
+  SMgmtWrapper *pWrapper = &pDnode->wrappers[pDnode->ntype];
+
+  SMsgCb msgCb = dndCreateMsgcb(pWrapper);
+  tmsgSetDefaultMsgCb(&msgCb);
+  pWrapper->procType = PROC_CHILD;
+
+  if (dndOpenNode(pWrapper) != 0) {
+    dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+
+  SProcCfg cfg = {.childConsumeFp = (ProcConsumeFp)dndConsumeChildQueue,
+                  .childMallocHeadFp = (ProcMallocFp)taosAllocateQitem,
+                  .childFreeHeadFp = (ProcFreeFp)taosFreeQitem,
+                  .childMallocBodyFp = (ProcMallocFp)rpcMallocCont,
+                  .childFreeBodyFp = (ProcFreeFp)rpcFreeCont,
+                  .parentConsumeFp = (ProcConsumeFp)dndConsumeParentQueue,
+                  .parentMallocHeadFp = (ProcMallocFp)taosMemoryMalloc,
+                  .parentFreeHeadFp = (ProcFreeFp)taosMemoryFree,
+                  .parentMallocBodyFp = (ProcMallocFp)rpcMallocCont,
+                  .parentFreeBodyFp = (ProcFreeFp)rpcFreeCont,
+                  .shm = pWrapper->shm,
+                  .pParent = pWrapper,
+                  .isChild = true,
+                  .name = pWrapper->name};
+
+  pWrapper->pProc = taosProcInit(&cfg);
+  if (pWrapper->pProc == NULL) {
+    dError("node:%s, failed to create proc since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+
+  if (pWrapper->fp.startFp != NULL) {
     if ((*pWrapper->fp.startFp)(pWrapper) != 0) {
       dError("node:%s, failed to start since %s", pWrapper->name, terrstr());
       return -1;
     }
   }
 
+  if (taosProcRun(pWrapper->pProc) != 0) {
+    dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr());
+    return -1;
+  }
+
+  dInfo("dnode running in child process");
   return 0;
 }
 
-int32_t dndRun(SDnode *pDnode) {
-  if (tsMultiProcess == 0) {
+int32_t dndRun(SDnode * pDnode) {
+  if (!tsMultiProcess) {
     if (dndRunInSingleProcess(pDnode) != 0) {
-      dError("failed to run dnode in single process mode since %s", terrstr());
+      dError("failed to run dnode since %s", terrstr());
+      return -1;
+    }
+  } else if (pDnode->ntype == DNODE || pDnode->ntype == NODE_MAX) {
+    if (dndRunInParentProcess(pDnode) != 0) {
+      dError("failed to run dnode in parent process since %s", terrstr());
       return -1;
     }
   } else {
-    if (dndRunInMultiProcess(pDnode) != 0) {
-      dError("failed to run dnode in multi process mode since %s", terrstr());
+    if (dndRunInChildProcess(pDnode) != 0) {
+      dError("failed to run dnode in child process since %s", terrstr());
       return -1;
     }
   }
 
   dndReportStartup(pDnode, "TDengine", "initialized successfully");
+  dInfo("TDengine initialized successfully");
 
   while (1) {
     if (pDnode->event == DND_EVENT_STOP) {

source/dnode/mgmt/main/src/dndFile.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/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "dndInt.h"
+
+#define MAXLEN 1024
+
+int32_t dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed) {
+  int32_t   code = TSDB_CODE_NODE_PARSE_FILE_ERROR;
+  int64_t   len = 0;
+  char      content[MAXLEN + 1] = {0};
+  cJSON    *root = NULL;
+  char      file[PATH_MAX];
+  TdFilePtr pFile = NULL;
+
+  snprintf(file, sizeof(file), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
+  pFile = taosOpenFile(file, TD_FILE_READ);
+  if (pFile == NULL) {
+    dDebug("file %s not exist", file);
+    code = 0;
+    goto _OVER;
+  }
+
+  len = taosReadFile(pFile, content, MAXLEN);
+  if (len <= 0) {
+    dError("failed to read %s since content is null", file);
+    goto _OVER;
+  }
+
+  root = cJSON_Parse(content);
+  if (root == NULL) {
+    dError("failed to read %s since invalid json format", file);
+    goto _OVER;
+  }
+
+  cJSON *deployed = cJSON_GetObjectItem(root, "deployed");
+  if (!deployed || deployed->type != cJSON_Number) {
+    dError("failed to read %s since deployed not found", file);
+    goto _OVER;
+  }
+  *pDeployed = deployed->valueint != 0;
+
+  dDebug("succcessed to read file %s, deployed:%d", file, *pDeployed);
+  code = 0;
+
+_OVER:
+  if (root != NULL) cJSON_Delete(root);
+  if (pFile != NULL) taosCloseFile(&pFile);
+
+  terrno = code;
+  return code;
+}
+
+int32_t dndWriteFile(SMgmtWrapper *pWrapper, bool deployed) {
+  int32_t   code = -1;
+  int32_t   len = 0;
+  char      content[MAXLEN + 1] = {0};
+  char      file[PATH_MAX] = {0};
+  char      realfile[PATH_MAX] = {0};
+  TdFilePtr pFile = NULL;
+
+  snprintf(file, sizeof(file), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
+  snprintf(realfile, sizeof(realfile), "%s%s%s.json", pWrapper->path, TD_DIRSEP, pWrapper->name);
+
+  pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to write %s since %s", file, terrstr());
+    goto _OVER;
+  }
+
+  len += snprintf(content + len, MAXLEN - len, "{\n");
+  len += snprintf(content + len, MAXLEN - len, "  \"deployed\": %d\n", deployed);
+  len += snprintf(content + len, MAXLEN - len, "}\n");
+
+  if (taosWriteFile(pFile, content, len) != len) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to write file:%s since %s", file, terrstr());
+    goto _OVER;
+  }
+
+  if (taosFsyncFile(pFile) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to fsync file:%s since %s", file, terrstr());
+    goto _OVER;
+  }
+
+  taosCloseFile(&pFile);
+
+  if (taosRenameFile(file, realfile) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to rename %s since %s", file, terrstr());
+    return -1;
+  }
+
+  dInfo("successed to write %s, deployed:%d", realfile, deployed);
+  code = 0;
+
+_OVER:
+  if (pFile != NULL) {
+    taosCloseFile(&pFile);
+  }
+
+  return code;
+}
+
+TdFilePtr dndCheckRunning(const char *dataDir) {
+  char filepath[PATH_MAX] = {0};
+  snprintf(filepath, sizeof(filepath), "%s%s.running", dataDir, TD_DIRSEP);
+
+  TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to lock file:%s since %s", filepath, terrstr());
+    return NULL;
+  }
+
+  int32_t ret = taosLockFile(pFile);
+  if (ret != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to lock file:%s since %s", filepath, terrstr());
+    taosCloseFile(&pFile);
+    return NULL;
+  }
+
+  dDebug("file:%s is locked", filepath);
+  return pFile;
+}
+
+int32_t dndReadShmFile(SDnode *pDnode) {
+  int32_t   code = -1;
+  char      itemName[24] = {0};
+  char      content[MAXLEN + 1] = {0};
+  char      file[PATH_MAX] = {0};
+  cJSON    *root = NULL;
+  TdFilePtr pFile = NULL;
+
+  snprintf(file, sizeof(file), "%s%s.shmfile", pDnode->dataDir, TD_DIRSEP);
+  pFile = taosOpenFile(file, TD_FILE_READ);
+  if (pFile == NULL) {
+    dDebug("file %s not exist", file);
+    code = 0;
+    goto _OVER;
+  }
+
+  if (taosReadFile(pFile, content, MAXLEN) > 0) {
+    root = cJSON_Parse(content);
+    if (root == NULL) {
+      terrno = TSDB_CODE_NODE_PARSE_FILE_ERROR;
+      dError("failed to read %s since invalid json format", file);
+      goto _OVER;
+    }
+
+    for (ENodeType ntype = DNODE + 1; ntype < NODE_MAX; ++ntype) {
+      snprintf(itemName, sizeof(itemName), "%s_shmid", dndNodeProcStr(ntype));
+      cJSON *shmid = cJSON_GetObjectItem(root, itemName);
+      if (shmid && shmid->type == cJSON_Number) {
+        pDnode->wrappers[ntype].shm.id = shmid->valueint;
+      }
+
+      snprintf(itemName, sizeof(itemName), "%s_shmsize", dndNodeProcStr(ntype));
+      cJSON *shmsize = cJSON_GetObjectItem(root, itemName);
+      if (shmsize && shmsize->type == cJSON_Number) {
+        pDnode->wrappers[ntype].shm.size = shmsize->valueint;
+      }
+    }
+  }
+
+  if (!tsMultiProcess || pDnode->ntype == DNODE || pDnode->ntype == DNODE) {
+    for (ENodeType ntype = DNODE; ntype < NODE_MAX; ++ntype) {
+      SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+      if (pWrapper->shm.id >= 0) {
+        dDebug("shmid:%d, is closed, size:%d", pWrapper->shm.id, pWrapper->shm.size);
+        taosDropShm(&pWrapper->shm);
+      }
+    }
+  } else {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[pDnode->ntype];
+    if (taosAttachShm(&pWrapper->shm) != 0) {
+      terrno = TAOS_SYSTEM_ERROR(errno);
+      dError("shmid:%d, failed to attach shm since %s", pWrapper->shm.id, terrstr());
+      goto _OVER;
+    }
+    dDebug("shmid:%d, is attached, size:%d", pWrapper->shm.id, pWrapper->shm.size);
+  }
+
+  dDebug("successed to open %s", file);
+  code = 0;
+
+_OVER:
+  if (root != NULL) cJSON_Delete(root);
+  if (pFile != NULL) taosCloseFile(&pFile);
+
+  return code;
+}
+
+int32_t dndWriteShmFile(SDnode *pDnode) {
+  int32_t   code = -1;
+  int32_t   len = 0;
+  char      content[MAXLEN + 1] = {0};
+  char      file[PATH_MAX] = {0};
+  char      realfile[PATH_MAX] = {0};
+  TdFilePtr pFile = NULL;
+
+  snprintf(file, sizeof(file), "%s%s.shmfile.bak", pDnode->dataDir, TD_DIRSEP);
+  snprintf(realfile, sizeof(realfile), "%s%s.shmfile", pDnode->dataDir, TD_DIRSEP);
+
+  pFile = taosOpenFile(file, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
+  if (pFile == NULL) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to open file:%s since %s", file, terrstr());
+    goto _OVER;
+  }
+
+  len += snprintf(content + len, MAXLEN - len, "{\n");
+  for (ENodeType ntype = DNODE + 1; ntype < NODE_MAX; ++ntype) {
+    SMgmtWrapper *pWrapper = &pDnode->wrappers[ntype];
+    len += snprintf(content + len, MAXLEN - len, "  \"%s_shmid\":%d,\n", dndNodeProcStr(ntype), pWrapper->shm.id);
+    if (ntype == NODE_MAX - 1) {
+      len += snprintf(content + len, MAXLEN - len, "  \"%s_shmsize\":%d\n", dndNodeProcStr(ntype), pWrapper->shm.size);
+    } else {
+      len += snprintf(content + len, MAXLEN - len, "  \"%s_shmsize\":%d,\n", dndNodeProcStr(ntype), pWrapper->shm.size);
+    }
+  }
+  len += snprintf(content + len, MAXLEN - len, "}\n");
+
+  if (taosWriteFile(pFile, content, len) != len) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to write file:%s since %s", file, terrstr());
+    goto _OVER;
+  }
+
+  if (taosFsyncFile(pFile) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to fsync file:%s since %s", file, terrstr());
+    goto _OVER;
+  }
+
+  taosCloseFile(&pFile);
+
+  if (taosRenameFile(file, realfile) != 0) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    dError("failed to rename %s to %s since %s", file, realfile, terrstr());
+    return -1;
+  }
+
+  dInfo("successed to write %s", realfile);
+  code = 0;
+
+_OVER:
+  if (pFile != NULL) {
+    taosCloseFile(&pFile);
+  }
+
+  return code;
+}

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

@@ -20,7 +20,7 @@
 static int8_t once = DND_ENV_INIT;
 
 int32_t dndInit() {
-  dInfo("start to init dnode env");
+  dDebug("start to init dnode env");
   if (atomic_val_compare_exchange_8(&once, DND_ENV_INIT, DND_ENV_READY) != DND_ENV_INIT) {
     terrno = TSDB_CODE_REPEAT_INIT;
     dError("failed to init dnode env since %s", terrstr());
@@ -31,12 +31,6 @@ int32_t dndInit() {
   taosBlockSIGPIPE();
   taosResolveCRC();
 
-  if (rpcInit() != 0) {
-    dError("failed to init rpc since %s", terrstr());
-    dndCleanup();
-    return -1;
-  }
-
   SMonCfg monCfg = {0};
   monCfg.maxLogs = tsMonitorMaxLogs;
   monCfg.port = tsMonitorPort;
@@ -44,7 +38,6 @@ int32_t dndInit() {
   monCfg.comp = tsMonitorComp;
   if (monInit(&monCfg) != 0) {
     dError("failed to init monitor since %s", terrstr());
-    dndCleanup();
     return -1;
   }
 
@@ -53,20 +46,19 @@ int32_t dndInit() {
 }
 
 void dndCleanup() {
-  dInfo("start to cleanup dnode env");
+  dDebug("start to cleanup dnode env");
   if (atomic_val_compare_exchange_8(&once, DND_ENV_READY, DND_ENV_CLEANUP) != DND_ENV_READY) {
     dError("dnode env is already cleaned up");
     return;
   }
 
   monCleanup();
-  rpcCleanup();
   walCleanUp();
   taosStopCacheRefreshWorker();
   dInfo("dnode env is cleaned up");
 }
 
-void dndSetMsgHandle(SMgmtWrapper *pWrapper, int32_t msgType, NodeMsgFp nodeMsgFp, int32_t vgId) {
+void dndSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp nodeMsgFp, int8_t vgId) {
   pWrapper->msgFps[TMSG_INDEX(msgType)] = nodeMsgFp;
   pWrapper->msgVgIds[TMSG_INDEX(msgType)] = vgId;
 }
@@ -80,19 +72,6 @@ void dndSetStatus(SDnode *pDnode, EDndStatus status) {
   }
 }
 
-const char *dndStatStr(EDndStatus status) {
-  switch (status) {
-    case DND_STAT_INIT:
-      return "init";
-    case DND_STAT_RUNNING:
-      return "running";
-    case DND_STAT_STOPPED:
-      return "stopped";
-    default:
-      return "unknown";
-  }
-}
-
 void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
   SStartupReq *pStartup = &pDnode->startup;
   tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
@@ -105,29 +84,6 @@ void dndGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
   pStartup->finished = (dndGetStatus(pDnode) == DND_STAT_RUNNING);
 }
 
-TdFilePtr dndCheckRunning(const char *dataDir) {
-  char filepath[PATH_MAX] = {0};
-  snprintf(filepath, sizeof(filepath), "%s/.running", dataDir);
-
-  TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_CTEATE | TD_FILE_WRITE | TD_FILE_TRUNC);
-  if (pFile == NULL) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to lock file:%s since %s", filepath, terrstr());
-    return NULL;
-  }
-
-  int32_t ret = taosLockFile(pFile);
-  if (ret != 0) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    dError("failed to lock file:%s since %s", filepath, terrstr());
-    taosCloseFile(&pFile);
-    return NULL;
-  }
-
-  dDebug("file:%s is locked", filepath);
-  return pFile;
-}
-
 void dndProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
   dDebug("startup req is received");
   SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));

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

@@ -16,7 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "dndInt.h"
 
-static int32_t dndInitMemory(SDnode *pDnode, const SDnodeOpt *pOption) {
+static int32_t dndInitVars(SDnode *pDnode, const SDnodeOpt *pOption) {
   pDnode->numOfSupportVnodes = pOption->numOfSupportVnodes;
   pDnode->serverPort = pOption->serverPort;
   pDnode->dataDir = strdup(pOption->dataDir);
@@ -24,8 +24,9 @@ static int32_t dndInitMemory(SDnode *pDnode, const SDnodeOpt *pOption) {
   pDnode->localFqdn = strdup(pOption->localFqdn);
   pDnode->firstEp = strdup(pOption->firstEp);
   pDnode->secondEp = strdup(pOption->secondEp);
-  pDnode->pDisks = pOption->pDisks;
+  pDnode->disks = pOption->disks;
   pDnode->numOfDisks = pOption->numOfDisks;
+  pDnode->ntype = pOption->ntype;
   pDnode->rebootTime = taosGetTimestampMs();
 
   if (pDnode->dataDir == NULL || pDnode->localEp == NULL || pDnode->localFqdn == NULL || pDnode->firstEp == NULL ||
@@ -33,18 +34,26 @@ static int32_t dndInitMemory(SDnode *pDnode, const SDnodeOpt *pOption) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
+
+  if (!tsMultiProcess || pDnode->ntype == DNODE || pDnode->ntype == NODE_MAX) {
+    pDnode->lockfile = dndCheckRunning(pDnode->dataDir);
+    if (pDnode->lockfile == NULL) {
+      return -1;
+    }
+  }
+
   return 0;
 }
 
-static void dndClearMemory(SDnode *pDnode) {
+static void dndClearVars(SDnode *pDnode) {
   for (ENodeType n = 0; n < NODE_MAX; ++n) {
     SMgmtWrapper *pMgmt = &pDnode->wrappers[n];
     taosMemoryFreeClear(pMgmt->path);
   }
-  if (pDnode->pLockFile != NULL) {
-    taosUnLockFile(pDnode->pLockFile);
-    taosCloseFile(&pDnode->pLockFile);
-    pDnode->pLockFile = NULL;
+  if (pDnode->lockfile != NULL) {
+    taosUnLockFile(pDnode->lockfile);
+    taosCloseFile(&pDnode->lockfile);
+    pDnode->lockfile = NULL;
   }
   taosMemoryFreeClear(pDnode->localEp);
   taosMemoryFreeClear(pDnode->localFqdn);
@@ -56,7 +65,7 @@ static void dndClearMemory(SDnode *pDnode) {
 }
 
 SDnode *dndCreate(const SDnodeOpt *pOption) {
-  dInfo("start to create dnode object");
+  dDebug("start to create dnode object");
   int32_t code = -1;
   char    path[PATH_MAX] = {0};
   SDnode *pDnode = NULL;
@@ -67,26 +76,12 @@ SDnode *dndCreate(const SDnodeOpt *pOption) {
     goto _OVER;
   }
 
-  if (dndInitMemory(pDnode, pOption) != 0) {
+  if (dndInitVars(pDnode, pOption) != 0) {
+    dError("failed to init variables since %s", terrstr());
     goto _OVER;
   }
 
   dndSetStatus(pDnode, DND_STAT_INIT);
-  pDnode->pLockFile = dndCheckRunning(pDnode->dataDir);
-  if (pDnode->pLockFile == NULL) {
-    goto _OVER;
-  }
-
-  if (dndInitServer(pDnode) != 0) {
-    dError("failed to init trans server since %s", terrstr());
-    goto _OVER;
-  }
-
-  if (dndInitClient(pDnode) != 0) {
-    dError("failed to init trans client since %s", terrstr());
-    goto _OVER;
-  }
-
   dmGetMgmtFp(&pDnode->wrappers[DNODE]);
   mmGetMgmtFp(&pDnode->wrappers[MNODE]);
   vmGetMgmtFp(&pDnode->wrappers[VNODES]);
@@ -94,14 +89,11 @@ SDnode *dndCreate(const SDnodeOpt *pOption) {
   smGetMgmtFp(&pDnode->wrappers[SNODE]);
   bmGetMgmtFp(&pDnode->wrappers[BNODE]);
 
-  if (dndInitMsgHandle(pDnode) != 0) {
-    goto _OVER;
-  }
-
   for (ENodeType n = 0; n < NODE_MAX; ++n) {
     SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
     snprintf(path, sizeof(path), "%s%s%s", pDnode->dataDir, TD_DIRSEP, pWrapper->name);
     pWrapper->path = strdup(path);
+    pWrapper->shm.id = -1;
     pWrapper->pDnode = pDnode;
     if (pWrapper->path == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -112,15 +104,27 @@ SDnode *dndCreate(const SDnodeOpt *pOption) {
     taosInitRWLatch(&pWrapper->latch);
   }
 
+  if (dndInitMsgHandle(pDnode) != 0) {
+    dError("failed to msg handles since %s", terrstr());
+    goto _OVER;
+  }
+
+  if (dndReadShmFile(pDnode) != 0) {
+    dError("failed to read shm file since %s", terrstr());
+    goto _OVER;
+  }
+
+  SMsgCb msgCb = dndCreateMsgcb(&pDnode->wrappers[0]);
+  tmsgSetDefaultMsgCb(&msgCb);
+
+  dInfo("dnode object is created, data:%p", pDnode);
   code = 0;
 
 _OVER:
   if (code != 0 && pDnode) {
-    dndClearMemory(pDnode);
+    dndClearVars(pDnode);
     pDnode = NULL;
     dError("failed to create dnode object since %s", terrstr());
-  } else {
-    dInfo("dnode object is created, data:%p", pDnode);
   }
 
   return pDnode;
@@ -137,15 +141,12 @@ void dndClose(SDnode *pDnode) {
   dInfo("start to close dnode, data:%p", pDnode);
   dndSetStatus(pDnode, DND_STAT_STOPPED);
 
-  dndCleanupServer(pDnode);
-  dndCleanupClient(pDnode);
-
   for (ENodeType n = 0; n < NODE_MAX; ++n) {
     SMgmtWrapper *pWrapper = &pDnode->wrappers[n];
     dndCloseNode(pWrapper);
   }
 
-  dndClearMemory(pDnode);
+  dndClearVars(pDnode);
   dInfo("dnode object is closed, data:%p", pDnode);
 }
 

source/dnode/mgmt/main/src/dndStr.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/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "dndInt.h"
+
+const char *dndStatStr(EDndStatus status) {
+  switch (status) {
+    case DND_STAT_INIT:
+      return "init";
+    case DND_STAT_RUNNING:
+      return "running";
+    case DND_STAT_STOPPED:
+      return "stopped";
+    default:
+      return "unknown";
+  }
+}
+
+const char *dndNodeLogStr(ENodeType ntype) {
+  switch (ntype) {
+    case VNODES:
+      return "vnode";
+    case QNODE:
+      return "qnode";
+    case SNODE:
+      return "snode";
+    case MNODE:
+      return "mnode";
+    case BNODE:
+      return "bnode";
+    default:
+      return "taosd";
+  }
+}
+
+const char *dndNodeProcStr(ENodeType ntype) {
+  switch (ntype) {
+    case VNODES:
+      return "taosv";
+    case QNODE:
+      return "taosq";
+    case SNODE:
+      return "taoss";
+    case MNODE:
+      return "taosm";
+    case BNODE:
+      return "taosb";
+    default:
+      return "taosd";
+  }
+}

source/dnode/mgmt/container/src/dndTransport.c → source/dnode/mgmt/main/src/dndTransport.c

@@ -320,8 +320,7 @@ static int32_t dndSendRpcReq(STransMgmt *pMgmt, const SEpSet *pEpSet, SRpcMsg *p
 }
 
 int32_t dndSendReqToDnode(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq) {
-  if (pWrapper->procType == PROC_CHILD) {
-  } else {
+  if (pWrapper->procType != PROC_CHILD) {
     SDnode *pDnode = pWrapper->pDnode;
     if (dndGetStatus(pDnode) != DND_STAT_RUNNING) {
       terrno = TSDB_CODE_DND_OFFLINE;
@@ -329,23 +328,24 @@ int32_t dndSendReqToDnode(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg
       return -1;
     }
     return dndSendRpcReq(&pDnode->trans, pEpSet, pReq);
+  } else {
+    while (taosProcPutToParentQ(pWrapper->pProc, pReq, sizeof(SRpcMsg), pReq->pCont, pReq->contLen, PROC_REQ) != 0) {
+      taosMsleep(1);
+    }
   }
 }
 
 int32_t dndSendReqToMnode(SMgmtWrapper *pWrapper, SRpcMsg *pReq) {
-  if (pWrapper->procType == PROC_CHILD) {
-  } else {
-    SDnode     *pDnode = pWrapper->pDnode;
-    STransMgmt *pTrans = &pDnode->trans;
-    SEpSet      epSet = {0};
+  SDnode     *pDnode = pWrapper->pDnode;
+  STransMgmt *pTrans = &pDnode->trans;
+  SEpSet      epSet = {0};
 
-    SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, DNODE);
-    if (pWrapper != NULL) {
-      dmGetMnodeEpSet(pWrapper->pMgmt, &epSet);
-      dndReleaseWrapper(pWrapper);
-    }
-    return dndSendRpcReq(pTrans, &epSet, pReq);
+  SMgmtWrapper *pWrapper2 = dndAcquireWrapper(pDnode, DNODE);
+  if (pWrapper2 != NULL) {
+    dmGetMnodeEpSet(pWrapper2->pMgmt, &epSet);
+    dndReleaseWrapper(pWrapper2);
   }
+  return dndSendRpcReq(pTrans, &epSet, pReq);
 }
 
 void dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
@@ -363,29 +363,44 @@ void dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
 }
 
 void dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) {
-  if (pWrapper->procType == PROC_CHILD) {
-    int32_t code = -1;
-    do {
-      code = taosProcPutToParentQ(pWrapper->pProc, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, PROC_RSP);
-      if (code != 0) {
-        taosMsleep(10);
-      }
-    } while (code != 0);
-  } else {
+  if (pWrapper->procType != PROC_CHILD) {
     dndSendRpcRsp(pWrapper, pRsp);
+  } else {
+    while (taosProcPutToParentQ(pWrapper->pProc, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, PROC_RSP) != 0) {
+      taosMsleep(1);
+    }
   }
 }
 
 void dndRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) {
-  if (pWrapper->procType == PROC_CHILD) {
-    int32_t code = -1;
-    do {
-      code = taosProcPutToParentQ(pWrapper->pProc, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, PROC_REGISTER);
-      if (code != 0) {
-        taosMsleep(10);
-      }
-    } while (code != 0);
-  } else {
+  if (pWrapper->procType != PROC_CHILD) {
     rpcRegisterBrokenLinkArg(pMsg);
+  } else {
+    while (taosProcPutToParentQ(pWrapper->pProc, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, PROC_REG) != 0) {
+      taosMsleep(1);
+    }
   }
+}
+
+static void dndReleaseHandle(SMgmtWrapper *pWrapper, void *handle, int8_t type) {
+  if (pWrapper->procType != PROC_CHILD) {
+    rpcReleaseHandle(handle, type);
+  } else {
+    SRpcMsg msg = {.handle = handle, .code = type};
+    while (taosProcPutToParentQ(pWrapper->pProc, &msg, sizeof(SRpcMsg), NULL, 0, PROC_RELEASE) != 0) {
+      taosMsleep(1);
+    }
+  }
+}
+
+SMsgCb dndCreateMsgcb(SMgmtWrapper *pWrapper) {
+  SMsgCb msgCb = {
+      .pWrapper = pWrapper,
+      .registerBrokenLinkArgFp = dndRegisterBrokenLinkArg,
+      .releaseHandleFp = dndReleaseHandle,
+      .sendMnodeReqFp = dndSendReqToMnode,
+      .sendReqFp = dndSendReqToDnode,
+      .sendRspFp = dndSendRsp,
+  };
+  return msgCb;
 }
\ No newline at end of file

source/dnode/mgmt/main/src/dndUtil.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/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "dndMain.h"
-
-void dndGenerateGrant() {
-#if 0
-  grantParseParameter();
-#endif
-}
-
-void dndPrintVersion() {
-#ifdef TD_ENTERPRISE
-  char *releaseName = "enterprise";
-#else
-  char *releaseName = "community";
-#endif
-  printf("%s version: %s compatible_version: %s\n", releaseName, version, compatible_version);
-  printf("gitinfo: %s\n", gitinfo);
-  printf("builuInfo: %s\n", buildinfo);
-}
-
-void dndDumpCfg() {
-  SConfig *pCfg = taosGetCfg();
-  cfgDumpCfg(pCfg, 0, 1);
-}
-
-SDnodeOpt dndGetOpt() {
-  SConfig  *pCfg = taosGetCfg();
-  SDnodeOpt option = {0};
-
-  option.numOfSupportVnodes = cfgGetItem(pCfg, "supportVnodes")->i32;
-  tstrncpy(option.dataDir, tsDataDir, sizeof(option.dataDir));
-  tstrncpy(option.firstEp, tsFirst, sizeof(option.firstEp));
-  tstrncpy(option.secondEp, tsSecond, sizeof(option.firstEp));
-  option.serverPort = tsServerPort;
-  tstrncpy(option.localFqdn, tsLocalFqdn, sizeof(option.localFqdn));
-  snprintf(option.localEp, sizeof(option.localEp), "%s:%u", option.localFqdn, option.serverPort);
-  option.pDisks = tsDiskCfg;
-  option.numOfDisks = tsDiskCfgNum;
-  return option;
-}

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

@@ -285,7 +285,7 @@ static int32_t vmInit(SMgmtWrapper *pWrapper) {
   tstrncpy(dCfg.dir, pDnode->dataDir, TSDB_FILENAME_LEN);
   dCfg.level = 0;
   dCfg.primary = 1;
-  SDiskCfg *pDisks = pDnode->pDisks;
+  SDiskCfg *pDisks = pDnode->disks;
   int32_t   numOfDisks = pDnode->numOfDisks;
   if (numOfDisks <= 0 || pDisks == NULL) {
     pDisks = &dCfg;

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

@@ -76,7 +76,7 @@ static void vmProcessFetchQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
   SVnodeObj *pVnode = pInfo->ahandle;
 
   dTrace("msg:%p, will be processed in vnode-fetch queue", pMsg);
-  int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, &pMsg->rpcMsg);
+  int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, &pMsg->rpcMsg, pInfo);
   if (code != 0) {
     vmSendRsp(pVnode->pWrapper, pMsg, code);
     dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
@@ -168,7 +168,7 @@ static void vmProcessMergeQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numO
     taosGetQitem(qall, (void **)&pMsg);
 
     dTrace("msg:%p, will be processed in vnode-merge queue", pMsg);
-    int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, &pMsg->rpcMsg);
+    int32_t code = vnodeProcessFetchMsg(pVnode->pImpl, &pMsg->rpcMsg, pInfo);
     if (code != 0) {
       vmSendRsp(pVnode->pWrapper, pMsg, code);
       dTrace("msg:%p, is freed, result:0x%04x:%s", pMsg, code & 0XFFFF, tstrerror(code));
@@ -414,8 +414,7 @@ int32_t vmStartWorker(SVnodesMgmt *pMgmt) {
   pWPool->max = maxMergeThreads;
   if (tWWorkerInit(pWPool) != 0) return -1;
 
-  SSingleWorkerCfg cfg = {
-      .min = 1, .max = 1, .name = "vnode-mgmt", .fp = (FItem)vmProcessMgmtQueue, .param = pMgmt};
+  SSingleWorkerCfg cfg = {.min = 1, .max = 1, .name = "vnode-mgmt", .fp = (FItem)vmProcessMgmtQueue, .param = pMgmt};
   if (tSingleWorkerInit(&pMgmt->mgmtWorker, &cfg) != 0) {
     dError("failed to start vnode-mgmt worker since %s", terrstr());
     return -1;

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

@@ -62,8 +62,6 @@ static int32_t mndPersistMqSetConnReq(SMnode *pMnode, STrans *pTrans, const SMqT
 
 static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp);
 
-static int32_t mndInitUnassignedVg(SMnode *pMnode, const SMqTopicObj *pTopic, SMqSubscribeObj *pSub);
-
 int32_t mndInitSubscribe(SMnode *pMnode) {
   SSdbTable table = {.sdbType = SDB_SUBSCRIBE,
                      .keyType = SDB_KEY_BINARY,
@@ -98,14 +96,6 @@ static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj
     return NULL;
   }
 
-#if 0
-  if (mndInitUnassignedVg(pMnode, pTopic, pSub) < 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tDeleteSMqSubscribeObj(pSub);
-    taosMemoryFree(pSub);
-    return NULL;
-  }
-#endif
   // TODO: disable alter subscribed table
   return pSub;
 }
@@ -210,45 +200,6 @@ static int32_t mndPersistCancelConnReq(SMnode *pMnode, STrans *pTrans, const SMq
   return 0;
 }
 
-#if 0
-static int32_t mndProcessResetOffsetReq(SNodeMsg *pMsg) {
-  SMnode             *pMnode = pMsg->pNode;
-  uint8_t            *str = pMsg->rpcMsg.pCont;
-  SMqCMResetOffsetReq req;
-
-  SCoder decoder;
-  tCoderInit(&decoder, TD_LITTLE_ENDIAN, str, pMsg->rpcMsg.contLen, TD_DECODER);
-  tDecodeSMqCMResetOffsetReq(&decoder, &req);
-
-  SHashObj *pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
-  if (pHash == NULL) {
-    return -1;
-  }
-
-  for (int32_t i = 0; i < req.num; i++) {
-    SMqOffset    *pOffset = &req.offsets[i];
-    SMqVgOffsets *pVgOffset = taosHashGet(pHash, &pOffset->vgId, sizeof(int32_t));
-    if (pVgOffset == NULL) {
-      pVgOffset = taosMemoryMalloc(sizeof(SMqVgOffsets));
-      if (pVgOffset == NULL) {
-        return -1;
-      }
-      pVgOffset->offsets = taosArrayInit(0, sizeof(void *));
-      taosArrayPush(pVgOffset->offsets, &pOffset);
-    }
-    taosHashPut(pHash, &pOffset->vgId, sizeof(int32_t), &pVgOffset, sizeof(void *));
-  }
-
-  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pMsg->rpcMsg);
-  if (pTrans == NULL) {
-    mError("mq-reset-offset: failed since %s", terrstr());
-    return -1;
-  }
-
-  return 0;
-}
-#endif
-
 static int32_t mndProcessGetSubEpReq(SNodeMsg *pMsg) {
   SMnode           *pMnode = pMsg->pNode;
   SMqCMGetSubEpReq *pReq = (SMqCMGetSubEpReq *)pMsg->rpcMsg.pCont;
@@ -574,251 +525,6 @@ static int32_t mndProcessDoRebalanceMsg(SNodeMsg *pMsg) {
   return 0;
 }
 
-#if 0
-      for (int32_t j = 0; j < consumerNum; j++) {
-        bool            changed = false;
-        bool            unfished = false;
-
-        bool            canUseLeft = imbalanceSolved < imbalanceVg;
-        bool            mustUseLeft = canUseLeft && (imbalanceVg - imbalanceSolved >= consumerNum - j);
-        ASSERT(imbalanceVg - imbalanceSolved <= consumerNum - j);
-
-        int32_t maxVg = vgEachConsumer + canUseLeft;
-        int32_t minVg = vgEachConsumer + mustUseLeft;
-
-        SMqSubConsumer *pSubConsumer = taosArrayGet(pSub->consumers, j);
-        int32_t         vgThisConsumerBeforeRb = taosArrayGetSize(pSubConsumer->vgInfo);
-        int32_t         vgThisConsumerAfterRb;
-        if (vgThisConsumerBeforeRb > maxVg) {
-          vgThisConsumerAfterRb = maxVg; 
-          imbalanceSolved++;
-          changed = true;
-        } else if (vgThisConsumerBeforeRb < minVg) {
-          vgThisConsumerAfterRb = minVg;
-          if (mustUseLeft) imbalanceSolved++;
-          changed = true;
-        } else {
-          vgThisConsumerAfterRb = vgThisConsumerBeforeRb;
-        }
-
-        if (vgThisConsumerBeforeRb > vgThisConsumerAfterRb) {
-          while (taosArrayGetSize(pSubConsumer->vgInfo) > vgThisConsumerAfterRb) {
-            // put into unassigned
-            SMqConsumerEp *pConsumerEp = taosArrayPop(pSubConsumer->vgInfo);
-            ASSERT(pConsumerEp != NULL);
-            ASSERT(pConsumerEp->consumerId == pSubConsumer->consumerId);
-            taosArrayPush(unassignedVgStash, pConsumerEp);
-          }
-
-        } else if (vgThisConsumerBeforeRb < vgThisConsumerAfterRb) {
-          // assign from unassigned
-          while (taosArrayGetSize(pSubConsumer->vgInfo) < vgThisConsumerAfterRb) {
-            // if no unassgined, save j
-            if (taosArrayGetSize(unassignedVgStash) == 0) {
-              taosArrayPush(unassignedConsumerIdx, &j);
-              unfished = true;
-              break;
-            }
-            // assign vg to consumer
-            SMqConsumerEp *pConsumerEp = taosArrayPop(unassignedVgStash);
-            ASSERT(pConsumerEp != NULL);
-            pConsumerEp->oldConsumerId = pConsumerEp->consumerId;
-            pConsumerEp->consumerId = pSubConsumer->consumerId;
-            taosArrayPush(pSubConsumer->vgInfo, pConsumerEp);
-            // build msg and persist into trans
-          }
-        }
-
-        if (changed && !unfished) {
-          SMqConsumerObj *pRebConsumer = mndAcquireConsumer(pMnode, pSubConsumer->consumerId);
-          pRebConsumer->epoch++;
-          if (vgThisConsumerAfterRb != 0) {
-            atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__ACTIVE);
-          } else {
-            atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__IDLE);
-          }
-          SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pRebConsumer);
-          sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY);
-          mndTransAppendRedolog(pTrans, pConsumerRaw);
-          mndReleaseConsumer(pMnode, pRebConsumer);
-          // TODO: save history
-        }
-      }
-
-      for (int32_t j = 0; j < taosArrayGetSize(unassignedConsumerIdx); j++) {
-        bool            canUseLeft = imbalanceSolved < imbalanceVg;
-        int32_t         consumerIdx = *(int32_t *)taosArrayGet(unassignedConsumerIdx, j);
-        SMqSubConsumer *pSubConsumer = taosArrayGet(pSub->consumers, consumerIdx);
-        if (canUseLeft) imbalanceSolved++;
-        // must use
-        int32_t vgThisConsumerAfterRb = taosArrayGetSize(pSubConsumer->vgInfo) + canUseLeft;
-        while (taosArrayGetSize(pSubConsumer->vgInfo) < vgEachConsumer + canUseLeft) {
-          // assign vg to consumer
-          SMqConsumerEp *pConsumerEp = taosArrayPop(unassignedVgStash);
-          ASSERT(pConsumerEp != NULL);
-          pConsumerEp->oldConsumerId = pConsumerEp->consumerId;
-          pConsumerEp->consumerId = pSubConsumer->consumerId;
-          taosArrayPush(pSubConsumer->vgInfo, pConsumerEp);
-          // build msg and persist into trans
-        }
-        SMqConsumerObj *pRebConsumer = mndAcquireConsumer(pMnode, pSubConsumer->consumerId);
-        pRebConsumer->epoch++;
-        atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__ACTIVE);
-        SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pRebConsumer);
-        sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY);
-        mndTransAppendRedolog(pTrans, pConsumerRaw);
-        mndReleaseConsumer(pMnode, pRebConsumer);
-        // TODO: save history
-      }
-#endif
-
-#if 0
-    //update consumer status for the subscribption
-    for (int32_t i = 0; i < taosArrayGetSize(pSub->assigned); i++) {
-      SMqConsumerEp *pCEp = taosArrayGet(pSub->assigned, i);
-      int64_t        consumerId = pCEp->consumerId;
-      if (pCEp->status != -1) {
-        int32_t consumerHbStatus = atomic_fetch_add_32(&pCEp->consumerHbStatus, 1);
-        if (consumerHbStatus < MND_SUBSCRIBE_REBALANCE_CNT) {
-          continue;
-        }
-        // put consumer into lostConsumer
-        SMqConsumerEp* lostConsumer = taosArrayPush(pSub->lostConsumer, pCEp);
-        lostConsumer->qmsg = NULL;
-        // put vg into unassigned
-        taosArrayPush(pSub->unassignedVg, pCEp);
-        // remove from assigned
-        // TODO: swap with last one, reduce size and reset i
-        taosArrayRemove(pSub->assigned, i);
-        // remove from available consumer
-        for (int32_t j = 0; j < taosArrayGetSize(pSub->availConsumer); j++) {
-          if (*(int64_t *)taosArrayGet(pSub->availConsumer, i) == pCEp->consumerId) {
-            taosArrayRemove(pSub->availConsumer, j);
-            break;
-          }
-          // TODO: acquire consumer, set status to unavail
-        }
-#if 0
-        SMqConsumerObj* pConsumer = mndAcquireConsumer(pMnode, consumerId);
-        pConsumer->epoch++;
-        printf("current epoch %ld size %ld", pConsumer->epoch, pConsumer->topics->size);
-        SSdbRaw* pRaw = mndConsumerActionEncode(pConsumer);
-        sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-        sdbWriteNotFree(pMnode->pSdb, pRaw);
-        mndReleaseConsumer(pMnode, pConsumer);
-#endif
-      }
-    }
-    // no available consumer, skip rebalance
-    if (taosArrayGetSize(pSub->availConsumer) == 0) {
-      continue;
-    }
-    taosArrayGet(pSub->availConsumer, 0);
-    // rebalance condition1 : have unassigned vg
-    // assign vg to a consumer, trying to find the least assigned one
-    if ((sz = taosArrayGetSize(pSub->unassignedVg)) > 0) {
-      char *topic = NULL;
-      char *cgroup = NULL;
-      mndSplitSubscribeKey(pSub->key, &topic, &cgroup);
-
-      SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic);
-      STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, &pMsg->rpcMsg);
-      for (int32_t i = 0; i < sz; i++) {
-        int64_t        consumerId = *(int64_t *)taosArrayGet(pSub->availConsumer, pSub->nextConsumerIdx);
-        pSub->nextConsumerIdx = (pSub->nextConsumerIdx + 1) % taosArrayGetSize(pSub->availConsumer);
-
-        SMqConsumerEp *pCEp = taosArrayPop(pSub->unassignedVg);
-        pCEp->oldConsumerId = pCEp->consumerId;
-        pCEp->consumerId = consumerId;
-        taosArrayPush(pSub->assigned, pCEp);
-
-        SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, consumerId);
-        pConsumer->epoch++;
-        SSdbRaw* pConsumerRaw = mndConsumerActionEncode(pConsumer);
-        sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY);
-        sdbWrite(pMnode->pSdb, pConsumerRaw);
-        mndReleaseConsumer(pMnode, pConsumer);
-
-        void* msg;
-        int32_t msgLen;
-        mndBuildRebalanceMsg(&msg, &msgLen, pTopic, pCEp, cgroup, topic);
-
-        // persist msg
-        STransAction action = {0};
-        action.epSet = pCEp->epSet;
-        action.pCont = msg;
-        action.contLen = sizeof(SMsgHead) + msgLen;
-        action.msgType = TDMT_VND_MQ_SET_CONN;
-        mndTransAppendRedoAction(pTrans, &action);
-
-        // persist data
-        SSdbRaw *pRaw = mndSubActionEncode(pSub);
-        sdbSetRawStatus(pRaw, SDB_STATUS_READY);
-        mndTransAppendRedolog(pTrans, pRaw);
-      }
-
-      if (mndTransPrepare(pMnode, pTrans) != 0) {
-        mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-      }
-      mndReleaseTopic(pMnode, pTopic);
-      mndTransDrop(pTrans);
-      taosMemoryFreeClear(topic);
-      taosMemoryFreeClear(cgroup);
-    }
-    // rebalance condition2 : imbalance assignment
-  }
-  return 0;
-}
-#endif
-
-#if 0
-static int32_t mndInitUnassignedVg(SMnode *pMnode, const SMqTopicObj *pTopic, SMqSubscribeObj *pSub) {
-  SSdb      *pSdb = pMnode->pSdb;
-  SVgObj    *pVgroup = NULL;
-  SQueryPlan *pPlan = qStringToQueryPlan(pTopic->physicalPlan);
-  SArray    *pArray = NULL;
-  SNodeListNode    *inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
-  SSubplan  *plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
-  SArray    *unassignedVg = pSub->unassignedVg;
-
-  void *pIter = NULL;
-  while (1) {
-    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
-    if (pIter == NULL) break;
-    if (pVgroup->dbUid != pTopic->dbUid) {
-      sdbRelease(pSdb, pVgroup);
-      continue;
-    }
-
-    pSub->vgNum++;
-    plan->execNode.nodeId = pVgroup->vgId;
-    plan->execNode.epset = mndGetVgroupEpset(pMnode, pVgroup);
-
-    if (schedulerConvertDagToTaskList(pPlan, &pArray) < 0) {
-      terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC;
-      mError("unsupport topic: %s, sql: %s", pTopic->name, pTopic->sql);
-      return -1;
-    }
-
-    SMqConsumerEp consumerEp = {0};
-    consumerEp.status = 0;
-    consumerEp.consumerId = -1;
-    STaskInfo *pTaskInfo = taosArrayGet(pArray, 0);
-    consumerEp.epSet = pTaskInfo->addr.epset;
-    consumerEp.vgId = pTaskInfo->addr.nodeId;
-
-    ASSERT(consumerEp.vgId == pVgroup->vgId);
-    consumerEp.qmsg = strdup(pTaskInfo->msg->msg);
-    taosArrayPush(unassignedVg, &consumerEp);
-    // TODO: free taskInfo
-    taosArrayDestroy(pArray);
-  }
-
-  /*qDestroyQueryDag(pDag);*/
-  return 0;
-}
-#endif
-
 static int32_t mndPersistMqSetConnReq(SMnode *pMnode, STrans *pTrans, const SMqTopicObj *pTopic, const char *cgroup,
                                       const SMqConsumerEp *pConsumerEp) {
   ASSERT(pConsumerEp->oldConsumerId == -1);
@@ -1140,7 +846,7 @@ static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg) {
     }
   }
 
-  if (oldSub) taosArrayDestroyEx(oldSub, (void (*)(void*))taosMemoryFree);
+  if (oldSub) taosArrayDestroyEx(oldSub, (void (*)(void *))taosMemoryFree);
 
   // persist consumerObj
   SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pConsumer);

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

@@ -26,7 +26,7 @@
 #include "parser.h"
 #include "tname.h"
 
-#define MND_TOPIC_VER_NUMBER   1
+#define MND_TOPIC_VER_NUMBER 1
 #define MND_TOPIC_RESERVE_SIZE 64
 
 static int32_t mndTopicActionInsert(SSdb *pSdb, SMqTopicObj *pTopic);
@@ -65,9 +65,11 @@ void mndCleanupTopic(SMnode *pMnode) {}
 SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
-  int32_t  logicalPlanLen = strlen(pTopic->logicalPlan) + 1;
-  int32_t  physicalPlanLen = strlen(pTopic->physicalPlan) + 1;
-  int32_t  size = sizeof(SMqTopicObj) + logicalPlanLen + physicalPlanLen + pTopic->sqlLen + MND_TOPIC_RESERVE_SIZE;
+  int32_t logicalPlanLen = strlen(pTopic->logicalPlan) + 1;
+  int32_t physicalPlanLen = strlen(pTopic->physicalPlan) + 1;
+  int32_t swLen = taosEncodeSSchemaWrapper(NULL, &pTopic->schema);
+  int32_t size =
+      sizeof(SMqTopicObj) + logicalPlanLen + physicalPlanLen + pTopic->sqlLen + swLen + MND_TOPIC_RESERVE_SIZE;
   SSdbRaw *pRaw = sdbAllocRaw(SDB_TOPIC, MND_TOPIC_VER_NUMBER, size);
   if (pRaw == NULL) goto TOPIC_ENCODE_OVER;
 
@@ -86,8 +88,7 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
   SDB_SET_INT32(pRaw, dataPos, physicalPlanLen, TOPIC_ENCODE_OVER);
   SDB_SET_BINARY(pRaw, dataPos, pTopic->physicalPlan, physicalPlanLen, TOPIC_ENCODE_OVER);
 
-  int32_t swLen = taosEncodeSSchemaWrapper(NULL, &pTopic->schema);
-  void   *swBuf = taosMemoryMalloc(swLen);
+  void *swBuf = taosMemoryMalloc(swLen);
   if (swBuf == NULL) {
     goto TOPIC_ENCODE_OVER;
   }

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

@@ -771,7 +771,7 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) {
                       .ahandle = pTrans->rpcAHandle,
                       .pCont = rpcCont,
                       .contLen = pTrans->rpcRspLen};
-    tmsgSendRsp(&pMnode->msgCb, &rspMsg);
+    tmsgSendRsp(&rspMsg);
     pTrans->rpcHandle = NULL;
     pTrans->rpcRsp = NULL;
     pTrans->rpcRspLen = 0;
@@ -898,7 +898,7 @@ static int32_t mndTransSendActionMsg(SMnode *pMnode, STrans *pTrans, SArray *pAr
       pAction->msgReceived = 0;
       pAction->errCode = 0;
     } else {
-      mDebug("trans:%d, action:%d not send since %s", pTrans->id, action, terrstr());
+      mError("trans:%d, action:%d not send since %s", pTrans->id, action, terrstr());
       return -1;
     }
   }
@@ -938,7 +938,7 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA
       return errCode;
     }
   } else {
-    mDebug("trans:%d, %d of %d actions executed, code:0x%04x", pTrans->id, numOfReceived, numOfActions, errCode & 0XFFFF);
+    mDebug("trans:%d, %d of %d actions executing", pTrans->id, numOfReceived, numOfActions);
     return TSDB_CODE_MND_ACTION_IN_PROGRESS;
   }
 }

source/dnode/vnode/CMakeLists.txt

@@ -46,14 +46,11 @@ target_link_libraries(
     PUBLIC stream
     PUBLIC qworker
     PUBLIC sync
+    # TODO: get rid of BDB
+    PUBLIC bdb
+    PUBLIC tdb
 )
 
-if(${META_DB_IMPL} STREQUAL "BDB")
-    target_link_libraries(vnode PUBLIC bdb)
-elseif(${META_DB_IMPL} STREQUAL "TDB")
-    target_link_libraries(vnode PUBLIC tdb)
-endif()
-
 if(${BUILD_TEST})
     add_subdirectory(test)
 endif(${BUILD_TEST})

source/dnode/vnode/inc/tsdb.h

@@ -100,10 +100,11 @@ int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, const char *msg);
  * @brief Insert tSma(Time-range-wise SMA) data from stream computing engine
  *
  * @param pTsdb
+ * @param indexUid
  * @param msg
  * @return int32_t
  */
-int32_t tsdbInsertTSmaData(STsdb *pTsdb, char *msg);
+int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg);
 
 /**
  * @brief Drop tSma data and local cache.
@@ -130,16 +131,11 @@ int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg);
  * @param pTsdb 
  * @param pData 
  * @param indexUid 
- * @param interval 
- * @param intervalUnit 
- * @param tableUid 
- * @param colId 
  * @param querySKey 
  * @param nMaxResult 
  * @return int32_t 
  */
-int32_t tsdbGetTSmaData(STsdb *pTsdb, STSmaDataWrapper *pData, int64_t indexUid, int64_t interval, int8_t intervalUnit,
-                        tb_uid_t tableUid, col_id_t colId, TSKEY querySKey, int32_t nMaxResult);
+int32_t tsdbGetTSmaData(STsdb *pTsdb, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult);
 
 // STsdbCfg
 int  tsdbOptionsInit(STsdbCfg *);

source/dnode/vnode/inc/vnode.h

@@ -17,8 +17,9 @@
 #define _TD_VNODE_H_
 
 #include "os.h"
-#include "trpc.h"
 #include "tmsgcb.h"
+#include "tqueue.h"
+#include "trpc.h"
 
 #include "meta.h"
 #include "tarray.h"
@@ -166,7 +167,7 @@ int vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg);
  * @param pMsg The request message
  * @return int 0 for success, -1 for failure
  */
-int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg);
+int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo);
 
 /* ------------------------ SVnodeCfg ------------------------ */
 /**
@@ -185,7 +186,6 @@ void vnodeOptionsClear(SVnodeCfg *pOptions);
 
 int vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName);
 
-
 /* ------------------------ FOR COMPILE ------------------------ */
 
 int32_t vnodeAlter(SVnode *pVnode, const SVnodeCfg *pCfg);

source/dnode/vnode/src/inc/tsdbSma.h

@@ -44,15 +44,14 @@ int32_t tsdbRemoveTSmaData(STsdb *pTsdb, STSma *param, STimeWindow *pWin);
 #endif
 
 // internal func
-static FORCE_INLINE int32_t tsdbEncodeTSmaKey(tb_uid_t tableUid, col_id_t colId, TSKEY tsKey, void **pData) {
+static FORCE_INLINE int32_t tsdbEncodeTSmaKey(int64_t groupId, TSKEY tsKey, void **pData) {
   int32_t len = 0;
-  len += taosEncodeFixedI64(pData, tableUid);
-  len += taosEncodeFixedU16(pData, colId);
   len += taosEncodeFixedI64(pData, tsKey);
+  len += taosEncodeFixedI64(pData, groupId);
   return len;
 }
 
-static FORCE_INLINE int tsdbRLockSma(SSmaEnv *pEnv) {
+static FORCE_INLINE int32_t tsdbRLockSma(SSmaEnv *pEnv) {
   int code = taosThreadRwlockRdlock(&(pEnv->lock));
   if (code != 0) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -61,7 +60,7 @@ static FORCE_INLINE int tsdbRLockSma(SSmaEnv *pEnv) {
   return 0;
 }
 
-static FORCE_INLINE int tsdbWLockSma(SSmaEnv *pEnv) {
+static FORCE_INLINE int32_t tsdbWLockSma(SSmaEnv *pEnv) {
   int code = taosThreadRwlockWrlock(&(pEnv->lock));
   if (code != 0) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -70,7 +69,7 @@ static FORCE_INLINE int tsdbWLockSma(SSmaEnv *pEnv) {
   return 0;
 }
 
-static FORCE_INLINE int tsdbUnLockSma(SSmaEnv *pEnv) {
+static FORCE_INLINE int32_t tsdbUnLockSma(SSmaEnv *pEnv) {
   int code = taosThreadRwlockUnlock(&(pEnv->lock));
   if (code != 0) {
     terrno = TAOS_SYSTEM_ERROR(code);

source/dnode/vnode/src/inc/vnd.h

@@ -197,9 +197,9 @@ int tqCommit(STQ*);
 int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg);
 int32_t tqProcessSetConnReq(STQ* pTq, char* msg);
 int32_t tqProcessRebReq(STQ* pTq, char* msg);
-int32_t tqProcessTaskExec(STQ* pTq, char* msg, int32_t msgLen);
+int32_t tqProcessTaskExec(STQ* pTq, char* msg, int32_t msgLen, int32_t workerId);
 int32_t tqProcessTaskDeploy(STQ* pTq, char* msg, int32_t msgLen);
-int32_t tqProcessStreamTrigger(STQ* pTq, void* data, int32_t dataLen);
+int32_t tqProcessStreamTrigger(STQ* pTq, void* data, int32_t dataLen, int32_t workerId);
 
 // sma
 void smaHandleRes(void* pVnode, int64_t smaId, const SArray* data);

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

@@ -275,7 +275,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
     pMsg->pCont = NULL;
     pMsg->contLen = 0;
     pMsg->code = -1;
-    rpcSendResponse(pMsg);
+    tmsgSendRsp(pMsg);
     return 0;
   }
 
@@ -340,7 +340,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
         pMsg->pCont = buf;
         pMsg->contLen = tlen;
         pMsg->code = 0;
-        rpcSendResponse(pMsg);
+        tmsgSendRsp(pMsg);
         return 0;
       }
     } else {
@@ -367,7 +367,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) {
   pMsg->pCont = buf;
   pMsg->contLen = tlen;
   pMsg->code = 0;
-  rpcSendResponse(pMsg);
+  tmsgSendRsp(pMsg);
   /*}*/
 
   return 0;
@@ -489,7 +489,7 @@ int32_t tqProcessTaskDeploy(STQ* pTq, char* msg, int32_t msgLen) {
   return 0;
 }
 
-int32_t tqProcessStreamTrigger(STQ* pTq, void* data, int32_t dataLen) {
+int32_t tqProcessStreamTrigger(STQ* pTq, void* data, int32_t dataLen, int32_t workerId) {
   void* pIter = NULL;
 
   while (1) {
@@ -497,14 +497,14 @@ int32_t tqProcessStreamTrigger(STQ* pTq, void* data, int32_t dataLen) {
     if (pIter == NULL) break;
     SStreamTask* pTask = (SStreamTask*)pIter;
 
-    if (streamExecTask(pTask, &pTq->pVnode->msgCb, data, STREAM_DATA_TYPE_SUBMIT_BLOCK, 0) < 0) {
+    if (streamExecTask(pTask, &pTq->pVnode->msgCb, data, STREAM_DATA_TYPE_SUBMIT_BLOCK, workerId) < 0) {
       // TODO
     }
   }
   return 0;
 }
 
-int32_t tqProcessTaskExec(STQ* pTq, char* msg, int32_t msgLen) {
+int32_t tqProcessTaskExec(STQ* pTq, char* msg, int32_t msgLen, int32_t workerId) {
   SStreamTaskExecReq req;
   tDecodeSStreamTaskExecReq(msg, &req);
 
@@ -514,7 +514,7 @@ int32_t tqProcessTaskExec(STQ* pTq, char* msg, int32_t msgLen) {
   SStreamTask* pTask = taosHashGet(pTq->pStreamTasks, &taskId, sizeof(int32_t));
   ASSERT(pTask);
 
-  if (streamExecTask(pTask, &pTq->pVnode->msgCb, req.data, STREAM_DATA_TYPE_SSDATA_BLOCK, 0) < 0) {
+  if (streamExecTask(pTask, &pTq->pVnode->msgCb, req.data, STREAM_DATA_TYPE_SSDATA_BLOCK, workerId) < 0) {
     // TODO
   }
   return 0;

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

@@ -114,10 +114,9 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
   SSchemaWrapper* pSchemaWrapper = pHandle->pSchemaWrapper;
 
   int32_t numOfRows = pHandle->pBlock->numOfRows;
-  int32_t numOfCols = pHandle->pSchema->numOfCols;
+  /*int32_t numOfCols = pHandle->pSchema->numOfCols;*/
   int32_t colNumNeed = taosArrayGetSize(pHandle->pColIdList);
 
-  // TODO: stable case
   if (colNumNeed > pSchemaWrapper->nCols) {
     colNumNeed = pSchemaWrapper->nCols;
   }
@@ -138,58 +137,24 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
       colNeed++;
     } else {
       SColumnInfoData colInfo = {0};
-      int             sz = numOfRows * pColSchema->bytes;
+      /*int             sz = numOfRows * pColSchema->bytes;*/
       colInfo.info.bytes = pColSchema->bytes;
       colInfo.info.colId = pColSchema->colId;
       colInfo.info.type = pColSchema->type;
 
-      colInfo.pData = taosMemoryCalloc(1, sz);
-      if (colInfo.pData == NULL) {
-        // TODO free
-        taosArrayDestroy(pArray);
+      if (blockDataEnsureColumnCapacity(&colInfo, numOfRows) < 0) {
+        taosArrayDestroyEx(pArray, (void (*)(void*))tDeleteSSDataBlock);
         return NULL;
       }
-
-      blockDataEnsureColumnCapacity(&colInfo, numOfRows);
       taosArrayPush(pArray, &colInfo);
       colMeta++;
       colNeed++;
     }
   }
 
-#if 0
-  int j = 0;
-  for (int32_t i = 0; i < colNumNeed; i++) {
-    col_id_t colId = *(col_id_t*)taosArrayGet(pHandle->pColIdList, i);
-    while (j < pSchemaWrapper->nCols && pSchemaWrapper->pSchema[j].colId < colId) {
-      j++;
-    }
-    if (j >= pSchemaWrapper->nCols) {
-      continue;
-    }
-    SSchema*        pColSchema = &pSchemaWrapper->pSchema[j];
-    SColumnInfoData colInfo = {0};
-    int             sz = numOfRows * pColSchema->bytes;
-    colInfo.info.bytes = pColSchema->bytes;
-    colInfo.info.colId = colId;
-    colInfo.info.type = pColSchema->type;
-
-    colInfo.pData = taosMemoryCalloc(1, sz);
-    if (colInfo.pData == NULL) {
-      // TODO free
-      taosArrayDestroy(pArray);
-      return NULL;
-    }
-
-    blockDataEnsureColumnCapacity(&colInfo, numOfRows);
-    taosArrayPush(pArray, &colInfo);
-  }
-#endif
-
   STSRowIter iter = {0};
   tdSTSRowIterInit(&iter, pTschema);
   STSRow* row;
-  // int32_t kvIdx = 0;
   int32_t curRow = 0;
   tInitSubmitBlkIter(pHandle->pBlock, &pHandle->blkIter);
   while ((row = tGetSubmitBlkNext(&pHandle->blkIter)) != NULL) {
@@ -202,25 +167,11 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) {
       if (!tdSTSRowIterNext(&iter, pColData->info.colId, pColData->info.type, &sVal)) {
         break;
       }
-      memcpy(POINTER_SHIFT(pColData->pData, curRow * pColData->info.bytes), sVal.val, pColData->info.bytes);
-    }
-#if 0
-    for (int32_t i = 0; i < colNumNeed; i++) {
-      SColumnInfoData* pColData = taosArrayGet(pArray, i);
-      STColumn*        pCol = schemaColAt(pTschema, i);
-      // TODO
-      if(pCol->colId != pColData->info.colId) {
-        continue;
-      }
-      // void* val = tdGetMemRowDataOfColEx(row, pCol->colId, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset, &kvIdx);
-      SCellVal sVal = {0};
-      if (!tdSTSRowIterNext(&iter, pCol->colId, pCol->type, &sVal)) {
-        // TODO: reach end
-        break;
+      if (colDataAppend(pColData, curRow, sVal.val, sVal.valType == TD_VTYPE_NULL) < 0) {
+        taosArrayDestroyEx(pArray, (void (*)(void*))tDeleteSSDataBlock);
+        return NULL;
       }
-      memcpy(POINTER_SHIFT(pColData->pData, curRow * pCol->bytes), sVal.val, pCol->bytes);
     }
-#endif
     curRow++;
   }
   return pArray;

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

@@ -41,7 +41,7 @@ int vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) {
   }
 }
 
-int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg) {
+int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg, SQueueInfo *pInfo) {
   vTrace("message in fetch queue is processing");
   char   *msgstr = POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead));
   int32_t msgLen = pMsg->contLen - sizeof(SMsgHead);
@@ -69,9 +69,9 @@ int vnodeProcessFetchMsg(SVnode *pVnode, SRpcMsg *pMsg) {
       return tqProcessPollReq(pVnode->pTq, pMsg);
     case TDMT_VND_TASK_PIPE_EXEC:
     case TDMT_VND_TASK_MERGE_EXEC:
-      return tqProcessTaskExec(pVnode->pTq, msgstr, msgLen);
+      return tqProcessTaskExec(pVnode->pTq, msgstr, msgLen, pInfo->workerId);
     case TDMT_VND_STREAM_TRIGGER:
-      return tqProcessStreamTrigger(pVnode->pTq, pMsg->pCont, pMsg->contLen);
+      return tqProcessStreamTrigger(pVnode->pTq, pMsg->pCont, pMsg->contLen, pInfo->workerId);
     case TDMT_VND_QUERY_HEARTBEAT:
       return qWorkerProcessHbMsg(pVnode, pVnode->pQuery, pMsg);
     default:
@@ -205,8 +205,7 @@ _exit:
   rpcMsg.contLen = rspLen;
   rpcMsg.code = code;
 
-  rpcSendResponse(&rpcMsg);
-
+  tmsgSendRsp(&rpcMsg);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -276,8 +275,7 @@ static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg) {
       .code = 0,
   };
 
-  rpcSendResponse(&rpcMsg);
-
+  tmsgSendRsp(&rpcMsg);
   taosArrayDestroyEx(pArray, freeItemHelper);
   return 0;
 }

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

@@ -17,7 +17,9 @@
 
 void smaHandleRes(void *pVnode, int64_t smaId, const SArray *data) {
   // TODO
+
   blockDebugShowData(data);
+  tsdbInsertTSmaData(((SVnode *)pVnode)->pTsdb, smaId, (const char *)data);
 }
 
 void vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
@@ -184,24 +186,25 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       }
     } break;
     case TDMT_VND_TASK_WRITE_EXEC: {
-      if (tqProcessTaskExec(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)),
-                            pMsg->contLen - sizeof(SMsgHead)) < 0) {
+      if (tqProcessTaskExec(pVnode->pTq, POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)), pMsg->contLen - sizeof(SMsgHead),
+                            0) < 0) {
       }
     } break;
     case TDMT_VND_CREATE_SMA: {  // timeRangeSMA
 #if 1
-      
+
       SSmaCfg vCreateSmaReq = {0};
       if (tDeserializeSVCreateTSmaReq(POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)), &vCreateSmaReq) == NULL) {
         terrno = TSDB_CODE_OUT_OF_MEMORY;
-        vWarn("vgId%d: TDMT_VND_CREATE_SMA received but deserialize failed since %s", pVnode->config.vgId, terrstr(terrno));
+        vWarn("vgId%d: TDMT_VND_CREATE_SMA received but deserialize failed since %s", pVnode->config.vgId,
+              terrstr(terrno));
         return -1;
       }
       vWarn("vgId%d: TDMT_VND_CREATE_SMA received for %s:%" PRIi64, pVnode->config.vgId, vCreateSmaReq.tSma.indexName,
             vCreateSmaReq.tSma.indexUid);
 
       // record current timezone of server side
-      tstrncpy(vCreateSmaReq.tSma.timezone, tsTimezoneStr, TD_TIMEZONE_LEN);
+      vCreateSmaReq.tSma.timezoneInt = tsTimezone;
 
       if (metaCreateTSma(pVnode->pMeta, &vCreateSmaReq) < 0) {
         // TODO: handle error

source/libs/executor/inc/executorimpl.h

@@ -161,20 +161,8 @@ typedef struct STaskCostInfo {
 typedef struct SOperatorCostInfo {
   uint64_t openCost;
   uint64_t execCost;
-//  uint64_t totalRows;
-//  uint64_t totalBytes;
 } SOperatorCostInfo;
 
-typedef struct {
-  int64_t vgroupLimit;
-  int64_t ts;
-} SOrderedPrjQueryInfo;
-
-typedef struct {
-  char*   tags;
-  SArray* pResult;  // SArray<SStddevInterResult>
-} SInterResult;
-
 // The basic query information extracted from the SQueryInfo tree to support the
 // execution of query in a data node.
 typedef struct STaskAttr {
@@ -230,7 +218,6 @@ typedef struct STaskAttr {
   SColumnInfo*         tagColList;
   int32_t              numOfFilterCols;
   int64_t*             fillVal;
-  SOrderedPrjQueryInfo prjInfo;  // limit value for each vgroup, only available in global order projection query.
 
   SSingleColumnFilterInfo* pFilterInfo;
   //  SFilterInfo     *pFilters;
@@ -245,8 +232,9 @@ struct SOperatorInfo;
 
 typedef void (*__optr_encode_fn_t)(struct SOperatorInfo* pOperator, char **result, int32_t *length);
 typedef bool (*__optr_decode_fn_t)(struct SOperatorInfo* pOperator, char *result, int32_t length);
-typedef int32_t (*__optr_open_fn_t)(struct SOperatorInfo* param);
-typedef SSDataBlock* (*__optr_fn_t)(struct SOperatorInfo* param, bool* newgroup);
+
+typedef int32_t (*__optr_open_fn_t)(struct SOperatorInfo* pOptr);
+typedef SSDataBlock* (*__optr_fn_t)(struct SOperatorInfo* pOptr, bool* newgroup);
 typedef void (*__optr_close_fn_t)(void* param, int32_t num);
 
 typedef struct STaskIdInfo {
@@ -267,7 +255,8 @@ typedef struct SExecTaskInfo {
   uint64_t        totalRows;            // total number of rows
   STableGroupInfo tableqinfoGroupInfo;  // this is a group array list, including SArray<STableQueryInfo*> structure
   char*           sql;                  // query sql string
-  jmp_buf         env;                  //
+  jmp_buf         env;                  // jump to this position when error happens.
+  EOPTR_EXEC_MODEL execModel;            // operator execution model [batch model|stream model]
   struct SOperatorInfo* pRoot;
 } SExecTaskInfo;
 
@@ -330,11 +319,12 @@ typedef struct SOperatorInfo {
   SResultInfo            resultInfo;
   struct SOperatorInfo** pDownstream;      // downstram pointer list
   int32_t                numOfDownstream;  // number of downstream. The value is always ONE expect for join operator
+  __optr_open_fn_t       _openFn;          // DO NOT invoke this function directly
   __optr_fn_t            getNextFn;
-  __optr_fn_t            cleanupFn;
+  __optr_fn_t            getStreamResFn;   // execute the aggregate in the stream model.
+  __optr_fn_t            cleanupFn;        // call this function to release the allocated resources ASAP
   __optr_close_fn_t      closeFn;
-  __optr_open_fn_t       _openFn;          // DO NOT invoke this function directly
-  __optr_encode_fn_t     encodeResultRow;           //
+  __optr_encode_fn_t     encodeResultRow;
   __optr_decode_fn_t     decodeResultRow;
 } SOperatorInfo;
 
@@ -363,18 +353,18 @@ typedef struct SQInfo {
   STaskCostInfo   summary;
 } SQInfo;
 
-enum {
-  DATA_NOT_READY = 0x1,
-  DATA_READY     = 0x2,
-  DATA_EXHAUSTED = 0x3,
-};
+typedef enum {
+  EX_SOURCE_DATA_NOT_READY = 0x1,
+  EX_SOURCE_DATA_READY     = 0x2,
+  EX_SOURCE_DATA_EXHAUSTED = 0x3,
+} EX_SOURCE_STATUS;
 
 typedef struct SSourceDataInfo {
   struct SExchangeInfo *pEx;
-  int32_t            index;
-  SRetrieveTableRsp *pRsp;
-  uint64_t           totalRows;
-  int32_t            status;
+  int32_t               index;
+  SRetrieveTableRsp    *pRsp;
+  uint64_t              totalRows;
+  EX_SOURCE_STATUS      status;
 } SSourceDataInfo;
 
 typedef struct SLoadRemoteDataInfo {
@@ -383,12 +373,6 @@ typedef struct SLoadRemoteDataInfo {
   uint64_t           totalElapsed;  // total elapsed time
 } SLoadRemoteDataInfo;
 
-enum {
-  EX_SOURCE_DATA_NOT_READY = 0x1,
-  EX_SOURCE_DATA_READY     = 0x2,
-  EX_SOURCE_DATA_EXHAUSTED = 0x3,
-};
-
 typedef struct SExchangeInfo {
   SArray*            pSources;
   SArray*            pSourceDataInfo;
@@ -484,16 +468,18 @@ typedef struct SAggSupporter {
 } SAggSupporter;
 
 typedef struct STableIntervalOperatorInfo {
-  SOptrBasicInfo     binfo;
-  SGroupResInfo      groupResInfo;
-  SInterval          interval;
-  STimeWindow        win;
-  int32_t            precision;
-  bool               timeWindowInterpo;
-  char             **pRow;
-  SAggSupporter      aggSup;
-  STableQueryInfo   *pCurrent;
-  int32_t            order;
+  SOptrBasicInfo     binfo;                // basic info
+  SGroupResInfo      groupResInfo;         // multiple results build supporter
+  SInterval          interval;             // interval info
+  STimeWindow        win;                  // query time range
+  bool               timeWindowInterpo;    // interpolation needed or not
+  char             **pRow;                 // previous row/tuple of already processed datablock
+  SAggSupporter      aggSup;               // aggregate supporter
+  STableQueryInfo   *pCurrent;             // current tableQueryInfo struct
+  int32_t            order;                // current SSDataBlock scan order
+  EOPTR_EXEC_MODEL    execModel;            // operator execution model [batch model|stream model]
+  SArray            *pUpdatedWindow;       // updated time window due to the input data block from the downstream operator.
+  SColumnInfoData    timeWindowData;       // query time window info for scalar function execution.
 } STableIntervalOperatorInfo;
 
 typedef struct SAggOperatorInfo {
@@ -695,12 +681,6 @@ SOperatorInfo* createSLimitOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorI
 SOperatorInfo* createJoinOperatorInfo(SOperatorInfo** pdownstream, int32_t numOfDownstream, SSchema* pSchema,
                                       int32_t numOfOutput);
 
-void doSetFilterColumnInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, SSDataBlock* pBlock);
-bool doFilterDataBlock(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, int32_t numOfRows, int8_t* p);
-void doCompactSDataBlock(SSDataBlock* pBlock, int32_t numOfRows, int8_t* p);
-
-SSDataBlock* createOutputBuf(SExprInfo* pExpr, int32_t numOfOutput, int32_t numOfRows);
-
 void* doDestroyFilterInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols);
 
 void setInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order);
@@ -734,7 +714,7 @@ int32_t getMaximumIdleDurationSec();
 
 void    doInvokeUdf(struct SUdfInfo* pUdfInfo, SqlFunctionCtx* pCtx, int32_t idx, int32_t type);
 void    setTaskStatus(SExecTaskInfo* pTaskInfo, int8_t status);
-int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SReadHandle* pHandle, uint64_t taskId);
+int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SReadHandle* pHandle, uint64_t taskId, EOPTR_EXEC_MODEL model);
 
 #ifdef __cplusplus
 }

source/libs/executor/src/executor.c

@@ -14,12 +14,12 @@
  */
 
 #include "executor.h"
-#include "tdatablock.h"
 #include "executorimpl.h"
 #include "planner.h"
+#include "tdatablock.h"
 #include "vnode.h"
 
-static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void** input, size_t numOfBlocks, int32_t type, char* id) {
+static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, char* id) {
   ASSERT(pOperator != NULL);
   if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) {
     if (pOperator->numOfDownstream == 0) {
@@ -44,17 +44,18 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void** input, size_t n
     }
 
     if (type == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-      if (tqReadHandleSetMsg(pInfo->readerHandle, input[0], 0) < 0) {
+      if (tqReadHandleSetMsg(pInfo->readerHandle, input, 0) < 0) {
         qError("submit msg messed up when initing stream block, %s" PRIx64, id);
         return TSDB_CODE_QRY_APP_ERROR;
       }
     } else {
       for (int32_t i = 0; i < numOfBlocks; ++i) {
-        SSDataBlock* pDataBlock = input[i];
+        SSDataBlock* pDataBlock = &((SSDataBlock*)input)[i];
 
         SSDataBlock* p = createOneDataBlock(pDataBlock);
         p->info = pDataBlock->info;
 
+        taosArrayClear(p->pDataBlock);
         taosArrayAddAll(p->pDataBlock, pDataBlock->pDataBlock);
         taosArrayPush(pInfo->pBlockLists, &p);
       }
@@ -65,10 +66,10 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void** input, size_t n
 }
 
 int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type) {
-  qSetMultiStreamInput(tinfo, (void**) &input, 1, type);
+  return qSetMultiStreamInput(tinfo, input, 1, type);
 }
 
-int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, void** pBlocks, size_t numOfBlocks, int32_t type) {
+int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type) {
   if (tinfo == NULL) {
     return TSDB_CODE_QRY_APP_ERROR;
   }
@@ -112,7 +113,7 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, void* streamReadHandle) {
   }
 
   qTaskInfo_t pTaskInfo = NULL;
-  code = qCreateExecTask(streamReadHandle, 0, 0, plan, &pTaskInfo, NULL);
+  code = qCreateExecTask(streamReadHandle, 0, 0, plan, &pTaskInfo, NULL, OPTR_EXEC_MODEL_STREAM);
   if (code != TSDB_CODE_SUCCESS) {
     // TODO: destroy SSubplan & pTaskInfo
     terrno = code;