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

include/client/taos.h

@@ -315,6 +315,16 @@ DLL_EXPORT TAOS_RES *tmq_create_stream(TAOS *taos, const char *streamName, const
 typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code);
 #endif
 
+typedef enum {
+  TSDB_SRV_STATUS_UNAVAILABLE = 0,
+  TSDB_SRV_STATUS_NETWORK_OK = 1,
+  TSDB_SRV_STATUS_SERVICE_OK = 2,
+  TSDB_SRV_STATUS_SERVICE_DEGRADED = 3,
+  TSDB_SRV_STATUS_EXTING = 4,
+} TSDB_SERVER_STATUS;
+
+DLL_EXPORT TSDB_SERVER_STATUS taos_check_server_status(const char *fqdn, int port, char *details, int maxlen);
+
 #ifdef __cplusplus
 }
 #endif

include/common/tmsg.h

@@ -280,10 +280,14 @@ typedef struct {
   int32_t numOfTags;
   int32_t numOfSmas;
   int32_t commentLen;
+  int32_t ast1Len;
+  int32_t ast2Len;
   SArray* pColumns;  // array of SField
   SArray* pTags;     // array of SField
   SArray* pSmas;     // array of SField
   char*   comment;
+  char*   pAst1;
+  char*   pAst2;
 } SMCreateStbReq;
 
 int32_t tSerializeSMCreateStbReq(void* buf, int32_t bufLen, SMCreateStbReq* pReq);
@@ -509,7 +513,7 @@ typedef struct {
   int8_t  precision;  // time resolution
   int8_t  compression;
   int8_t  replications;
-  int8_t  quorum;
+  int8_t  strict;
   int8_t  update;
   int8_t  cacheLastRow;
   int8_t  ignoreExist;
@@ -531,7 +535,7 @@ typedef struct {
   int32_t daysToKeep2;
   int32_t fsyncPeriod;
   int8_t  walLevel;
-  int8_t  quorum;
+  int8_t  strict;
   int8_t  cacheLastRow;
   int8_t  replications;
 } SAlterDbReq;
@@ -604,11 +608,13 @@ typedef struct {
   int8_t  precision;
   int8_t  compression;
   int8_t  replications;
-  int8_t  quorum;
+  int8_t  strict;
   int8_t  update;
   int8_t  cacheLastRow;
   int8_t  streamMode;
   int8_t  singleSTable;
+  int32_t numOfRetensions;
+  SArray* pRetensions;
 } SDbCfgRsp;
 
 int32_t tSerializeSDbCfgRsp(void* buf, int32_t bufLen, const SDbCfgRsp* pRsp);
@@ -639,10 +645,10 @@ void    tFreeSUseDbBatchRsp(SUseDbBatchRsp* pRsp);
 
 typedef struct {
   char db[TSDB_DB_FNAME_LEN];
-} SSyncDbReq, SCompactDbReq;
+} SCompactDbReq;
 
-int32_t tSerializeSSyncDbReq(void* buf, int32_t bufLen, SSyncDbReq* pReq);
-int32_t tDeserializeSSyncDbReq(void* buf, int32_t bufLen, SSyncDbReq* pReq);
+int32_t tSerializeSCompactDbReq(void* buf, int32_t bufLen, SCompactDbReq* pReq);
+int32_t tDeserializeSCompactDbReq(void* buf, int32_t bufLen, SCompactDbReq* pReq);
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
@@ -723,7 +729,7 @@ typedef struct {
 
 typedef struct {
   int32_t vgId;
-  int8_t  role;
+  int32_t syncState;
   int64_t numOfTables;
   int64_t numOfTimeSeries;
   int64_t totalStorage;
@@ -736,6 +742,10 @@ typedef struct {
   int64_t numOfBatchInsertSuccessReqs;
 } SVnodeLoad;
 
+typedef struct {
+  int32_t syncState;
+} SMnodeLoad;
+
 typedef struct {
   int32_t     sver;      // software version
   int64_t     dnodeVer;  // dnode table version in sdb
@@ -810,7 +820,7 @@ typedef struct {
   int8_t   walLevel;
   int8_t   precision;
   int8_t   compression;
-  int8_t   quorum;
+  int8_t   strict;
   int8_t   update;
   int8_t   cacheLastRow;
   int8_t   replica;
@@ -819,7 +829,7 @@ typedef struct {
   SReplica replicas[TSDB_MAX_REPLICA];
   int32_t  numOfRetensions;
   SArray*  pRetensions;  // SRetention
-} SCreateVnodeReq, SAlterVnodeReq;
+} SCreateVnodeReq;
 
 int32_t tSerializeSCreateVnodeReq(void* buf, int32_t bufLen, SCreateVnodeReq* pReq);
 int32_t tDeserializeSCreateVnodeReq(void* buf, int32_t bufLen, SCreateVnodeReq* pReq);
@@ -830,11 +840,36 @@ typedef struct {
   int32_t dnodeId;
   int64_t dbUid;
   char    db[TSDB_DB_FNAME_LEN];
-} SDropVnodeReq, SSyncVnodeReq, SCompactVnodeReq;
+} SDropVnodeReq;
 
 int32_t tSerializeSDropVnodeReq(void* buf, int32_t bufLen, SDropVnodeReq* pReq);
 int32_t tDeserializeSDropVnodeReq(void* buf, int32_t bufLen, SDropVnodeReq* pReq);
 
+typedef struct {
+  int64_t dbUid;
+  char    db[TSDB_DB_FNAME_LEN];
+} SCompactVnodeReq;
+
+int32_t tSerializeSCompactVnodeReq(void* buf, int32_t bufLen, SCompactVnodeReq* pReq);
+int32_t tDeserializeSCompactVnodeReq(void* buf, int32_t bufLen, SCompactVnodeReq* pReq);
+
+typedef struct {
+  int32_t  vgVersion;
+  int32_t  totalBlocks;
+  int32_t  daysToKeep0;
+  int32_t  daysToKeep1;
+  int32_t  daysToKeep2;
+  int8_t   walLevel;
+  int8_t   strict;
+  int8_t   cacheLastRow;
+  int8_t   replica;
+  int8_t   selfIndex;
+  SReplica replicas[TSDB_MAX_REPLICA];
+} SAlterVnodeReq;
+
+int32_t tSerializeSAlterVnodeReq(void* buf, int32_t bufLen, SAlterVnodeReq* pReq);
+int32_t tDeserializeSAlterVnodeReq(void* buf, int32_t bufLen, SAlterVnodeReq* pReq);
+
 typedef struct {
   SMsgHead header;
   char     dbFName[TSDB_DB_FNAME_LEN];
@@ -1071,10 +1106,12 @@ int32_t tSerializeSAuthReq(void* buf, int32_t bufLen, SAuthReq* pReq);
 int32_t tDeserializeSAuthReq(void* buf, int32_t bufLen, SAuthReq* pReq);
 
 typedef struct {
-  int8_t finished;
-  char   name[TSDB_STEP_NAME_LEN];
-  char   desc[TSDB_STEP_DESC_LEN];
-} SStartupReq;
+  int32_t statusCode;
+  char    details[1024];
+} SServerStatusRsp;
+
+int32_t tSerializeSServerStatusRsp(void* buf, int32_t bufLen, SServerStatusRsp* pRsp);
+int32_t tDeserializeSServerStatusRsp(void* buf, int32_t bufLen, SServerStatusRsp* pRsp);
 
 /**
  * The layout of the query message payload is as following:

include/common/tmsgcb.h

@@ -44,6 +44,7 @@ typedef int32_t (*SendMnodeReqFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq);
 typedef void (*SendRspFp)(SMgmtWrapper* pWrapper, const SRpcMsg* pRsp);
 typedef void (*RegisterBrokenLinkArgFp)(SMgmtWrapper* pWrapper, SRpcMsg* pMsg);
 typedef void (*ReleaseHandleFp)(SMgmtWrapper* pWrapper, void* handle, int8_t type);
+typedef void (*ReportStartup)(SMgmtWrapper* pWrapper, const char* name, const char* desc);
 
 typedef struct {
   SMgmtWrapper*           pWrapper;
@@ -53,6 +54,7 @@ typedef struct {
   SendRspFp               sendRspFp;
   RegisterBrokenLinkArgFp registerBrokenLinkArgFp;
   ReleaseHandleFp         releaseHandleFp;
+  ReportStartup           reportStartupFp;
 } SMsgCb;
 
 void    tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb);
@@ -62,6 +64,7 @@ int32_t tmsgSendReq(const SMsgCb* pMsgCb, const SEpSet* epSet, SRpcMsg* pReq);
 void    tmsgSendRsp(const SRpcMsg* pRsp);
 void    tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg);
 void    tmsgReleaseHandle(void* handle, int8_t type);
+void    tmsgReportStartup(const char* name, const char* desc);
 
 #ifdef __cplusplus
 }

include/common/tmsgdef.h

@@ -82,12 +82,9 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_DND_ALTER_BNODE, "dnode-alter-bnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_DND_DROP_BNODE, "dnode-drop-bnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_DND_CREATE_VNODE, "dnode-create-vnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_DND_ALTER_VNODE, "dnode-alter-vnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_DND_DROP_VNODE, "dnode-drop-vnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_DND_SYNC_VNODE, "dnode-sync-vnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_DND_COMPACT_VNODE, "dnode-compact-vnode", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_DND_CONFIG_DNODE, "dnode-config-dnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_DND_NETWORK_TEST, "dnode-nettest", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_DND_SERVER_STATUS, "dnode-server-status", NULL, NULL)
 
   // Requests handled by MNODE
   TD_NEW_MSG_SEG(TDMT_MND_MSG)
@@ -206,6 +203,10 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_CANCEL_SMA, "vnode-cancel-sma", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_DROP_SMA, "vnode-drop-sma", NULL, NULL)
 
+  TD_DEF_MSG_TYPE(TDMT_VND_SYNC_VNODE, "vnode-sync-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_VNODE, "vnode-alter-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_COMPACT_VNODE, "vnode-compact-vnode", NULL, NULL)
+
   // Requests handled by QNODE
   TD_NEW_MSG_SEG(TDMT_QND_MSG)
 
@@ -228,6 +229,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MON_SM_INFO, "monitor-sinfo", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MON_BM_INFO, "monitor-binfo", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MON_VM_LOAD, "monitor-vload", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MON_MM_LOAD, "monitor-mload", NULL, NULL)
   
 #if defined(TD_MSG_NUMBER_)
   TDMT_MAX

include/common/trow.h

@@ -308,8 +308,8 @@ static FORCE_INLINE int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx,
   // use literal value directly and not use formula to simplify the codes
   switch (nOffset) {
     case 0:
-      *pDestByte = ((*pDestByte) & 0x3F) | (valType << 6);
       // set the value and clear other partitions for offset 0
+      *pDestByte = (valType << 6);
       // *pDestByte |= (valType << 6);
       break;
     case 1:
@@ -417,8 +417,8 @@ static FORCE_INLINE int32_t tdSetBitmapValTypeI(void *pBitmap, int16_t colIdx, T
   // use literal value directly and not use formula to simplify the codes
   switch (nOffset) {
     case 0:
-      *pDestByte = ((*pDestByte) & 0x7F) | (valType << 7);
       // set the value and clear other partitions for offset 0
+      *pDestByte = (valType << 7);  
       // *pDestByte |= (valType << 7);
       break;
     case 1:
@@ -651,6 +651,8 @@ static int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
   TD_ROW_SET_INFO(pBuilder->pBuf, 0);
   TD_ROW_SET_TYPE(pBuilder->pBuf, pBuilder->rowType);
 
+  TASSERT(pBuilder->nBitmaps > 0 && pBuilder->flen > 0);
+
   uint32_t len = 0;
   switch (pBuilder->rowType) {
     case TD_ROW_TP:
@@ -1165,6 +1167,18 @@ static FORCE_INLINE int32_t tdGetColDataOfRow(SCellVal *pVal, SDataCol *pCol, in
   return TSDB_CODE_SUCCESS;
 }
 
+/**
+ * @brief 
+ * 
+ * @param pRow 
+ * @param colId 
+ * @param colType 
+ * @param flen 
+ * @param offset 
+ * @param colIdx start from 0
+ * @param pVal 
+ * @return FORCE_INLINE 
+ */
 static FORCE_INLINE bool tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t flen, uint32_t offset,
                                         col_id_t colIdx, SCellVal *pVal) {
   if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
@@ -1172,10 +1186,20 @@ static FORCE_INLINE bool tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t
     return true;
   }
   void *pBitmap = tdGetBitmapAddrTp(pRow, flen);
-  tdGetTpRowValOfCol(pVal, pRow, pBitmap, colType, offset - sizeof(TSKEY), colIdx - 1);
+  tdGetTpRowValOfCol(pVal, pRow, pBitmap, colType, offset - sizeof(TSKEY), colIdx);
   return true;
 }
 
+/**
+ * @brief 
+ * 
+ * @param pRow 
+ * @param colId 
+ * @param offset 
+ * @param colIdx start from 0
+ * @param pVal 
+ * @return FORCE_INLINE 
+ */
 static FORCE_INLINE bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, uint32_t offset, col_id_t colIdx,
                                         SCellVal *pVal) {
   if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
@@ -1183,7 +1207,7 @@ static FORCE_INLINE bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, uint32_t o
     return true;
   }
   void *pBitmap = tdGetBitmapAddrKv(pRow, tdRowGetNCols(pRow));
-  tdGetKvRowValOfCol(pVal, pRow, pBitmap, offset, colIdx - 1);
+  tdGetKvRowValOfCol(pVal, pRow, pBitmap, offset, colIdx);
   return true;
 }
 

include/common/ttokendef.h

@@ -86,155 +86,156 @@
 #define TK_SINGLE_STABLE                   68
 #define TK_STREAM_MODE                     69
 #define TK_RETENTIONS                      70
-#define TK_NK_COMMA                        71
-#define TK_NK_COLON                        72
-#define TK_TABLE                           73
-#define TK_NK_LP                           74
-#define TK_NK_RP                           75
-#define TK_STABLE                          76
-#define TK_ADD                             77
-#define TK_COLUMN                          78
-#define TK_MODIFY                          79
-#define TK_RENAME                          80
-#define TK_TAG                             81
-#define TK_SET                             82
-#define TK_NK_EQ                           83
-#define TK_USING                           84
-#define TK_TAGS                            85
-#define TK_NK_DOT                          86
-#define TK_COMMENT                         87
-#define TK_BOOL                            88
-#define TK_TINYINT                         89
-#define TK_SMALLINT                        90
-#define TK_INT                             91
-#define TK_INTEGER                         92
-#define TK_BIGINT                          93
-#define TK_FLOAT                           94
-#define TK_DOUBLE                          95
-#define TK_BINARY                          96
-#define TK_TIMESTAMP                       97
-#define TK_NCHAR                           98
-#define TK_UNSIGNED                        99
-#define TK_JSON                           100
-#define TK_VARCHAR                        101
-#define TK_MEDIUMBLOB                     102
-#define TK_BLOB                           103
-#define TK_VARBINARY                      104
-#define TK_DECIMAL                        105
-#define TK_SMA                            106
-#define TK_ROLLUP                         107
-#define TK_FILE_FACTOR                    108
-#define TK_NK_FLOAT                       109
-#define TK_DELAY                          110
-#define TK_SHOW                           111
-#define TK_DATABASES                      112
-#define TK_TABLES                         113
-#define TK_STABLES                        114
-#define TK_MNODES                         115
-#define TK_MODULES                        116
-#define TK_QNODES                         117
-#define TK_FUNCTIONS                      118
-#define TK_INDEXES                        119
-#define TK_FROM                           120
-#define TK_ACCOUNTS                       121
-#define TK_APPS                           122
-#define TK_CONNECTIONS                    123
-#define TK_LICENCE                        124
-#define TK_GRANTS                         125
-#define TK_QUERIES                        126
-#define TK_SCORES                         127
-#define TK_TOPICS                         128
-#define TK_VARIABLES                      129
-#define TK_BNODES                         130
-#define TK_SNODES                         131
-#define TK_LIKE                           132
-#define TK_INDEX                          133
-#define TK_FULLTEXT                       134
-#define TK_FUNCTION                       135
-#define TK_INTERVAL                       136
-#define TK_TOPIC                          137
-#define TK_AS                             138
-#define TK_DESC                           139
-#define TK_DESCRIBE                       140
-#define TK_RESET                          141
-#define TK_QUERY                          142
-#define TK_EXPLAIN                        143
-#define TK_ANALYZE                        144
-#define TK_VERBOSE                        145
-#define TK_NK_BOOL                        146
-#define TK_RATIO                          147
-#define TK_COMPACT                        148
-#define TK_VNODES                         149
-#define TK_IN                             150
-#define TK_OUTPUTTYPE                     151
-#define TK_AGGREGATE                      152
-#define TK_BUFSIZE                        153
-#define TK_STREAM                         154
-#define TK_INTO                           155
-#define TK_TRIGGER                        156
-#define TK_AT_ONCE                        157
-#define TK_WINDOW_CLOSE                   158
-#define TK_WATERMARK                      159
-#define TK_KILL                           160
-#define TK_CONNECTION                     161
-#define TK_MERGE                          162
-#define TK_VGROUP                         163
-#define TK_REDISTRIBUTE                   164
-#define TK_SPLIT                          165
-#define TK_SYNCDB                         166
-#define TK_NULL                           167
-#define TK_NK_QUESTION                    168
-#define TK_NK_ARROW                       169
-#define TK_ROWTS                          170
-#define TK_TBNAME                         171
-#define TK_QSTARTTS                       172
-#define TK_QENDTS                         173
-#define TK_WSTARTTS                       174
-#define TK_WENDTS                         175
-#define TK_WDURATION                      176
-#define TK_CAST                           177
-#define TK_NOW                            178
-#define TK_TODAY                          179
-#define TK_TIMEZONE                       180
-#define TK_COUNT                          181
-#define TK_FIRST                          182
-#define TK_LAST                           183
-#define TK_LAST_ROW                       184
-#define TK_BETWEEN                        185
-#define TK_IS                             186
-#define TK_NK_LT                          187
-#define TK_NK_GT                          188
-#define TK_NK_LE                          189
-#define TK_NK_GE                          190
-#define TK_NK_NE                          191
-#define TK_MATCH                          192
-#define TK_NMATCH                         193
-#define TK_CONTAINS                       194
-#define TK_JOIN                           195
-#define TK_INNER                          196
-#define TK_SELECT                         197
-#define TK_DISTINCT                       198
-#define TK_WHERE                          199
-#define TK_PARTITION                      200
-#define TK_BY                             201
-#define TK_SESSION                        202
-#define TK_STATE_WINDOW                   203
-#define TK_SLIDING                        204
-#define TK_FILL                           205
-#define TK_VALUE                          206
-#define TK_NONE                           207
-#define TK_PREV                           208
-#define TK_LINEAR                         209
-#define TK_NEXT                           210
-#define TK_GROUP                          211
-#define TK_HAVING                         212
-#define TK_ORDER                          213
-#define TK_SLIMIT                         214
-#define TK_SOFFSET                        215
-#define TK_LIMIT                          216
-#define TK_OFFSET                         217
-#define TK_ASC                            218
-#define TK_NULLS                          219
+#define TK_STRICT                          71
+#define TK_NK_COMMA                        72
+#define TK_NK_COLON                        73
+#define TK_TABLE                           74
+#define TK_NK_LP                           75
+#define TK_NK_RP                           76
+#define TK_STABLE                          77
+#define TK_ADD                             78
+#define TK_COLUMN                          79
+#define TK_MODIFY                          80
+#define TK_RENAME                          81
+#define TK_TAG                             82
+#define TK_SET                             83
+#define TK_NK_EQ                           84
+#define TK_USING                           85
+#define TK_TAGS                            86
+#define TK_NK_DOT                          87
+#define TK_COMMENT                         88
+#define TK_BOOL                            89
+#define TK_TINYINT                         90
+#define TK_SMALLINT                        91
+#define TK_INT                             92
+#define TK_INTEGER                         93
+#define TK_BIGINT                          94
+#define TK_FLOAT                           95
+#define TK_DOUBLE                          96
+#define TK_BINARY                          97
+#define TK_TIMESTAMP                       98
+#define TK_NCHAR                           99
+#define TK_UNSIGNED                       100
+#define TK_JSON                           101
+#define TK_VARCHAR                        102
+#define TK_MEDIUMBLOB                     103
+#define TK_BLOB                           104
+#define TK_VARBINARY                      105
+#define TK_DECIMAL                        106
+#define TK_SMA                            107
+#define TK_ROLLUP                         108
+#define TK_FILE_FACTOR                    109
+#define TK_NK_FLOAT                       110
+#define TK_DELAY                          111
+#define TK_SHOW                           112
+#define TK_DATABASES                      113
+#define TK_TABLES                         114
+#define TK_STABLES                        115
+#define TK_MNODES                         116
+#define TK_MODULES                        117
+#define TK_QNODES                         118
+#define TK_FUNCTIONS                      119
+#define TK_INDEXES                        120
+#define TK_FROM                           121
+#define TK_ACCOUNTS                       122
+#define TK_APPS                           123
+#define TK_CONNECTIONS                    124
+#define TK_LICENCE                        125
+#define TK_GRANTS                         126
+#define TK_QUERIES                        127
+#define TK_SCORES                         128
+#define TK_TOPICS                         129
+#define TK_VARIABLES                      130
+#define TK_BNODES                         131
+#define TK_SNODES                         132
+#define TK_LIKE                           133
+#define TK_INDEX                          134
+#define TK_FULLTEXT                       135
+#define TK_FUNCTION                       136
+#define TK_INTERVAL                       137
+#define TK_TOPIC                          138
+#define TK_AS                             139
+#define TK_DESC                           140
+#define TK_DESCRIBE                       141
+#define TK_RESET                          142
+#define TK_QUERY                          143
+#define TK_EXPLAIN                        144
+#define TK_ANALYZE                        145
+#define TK_VERBOSE                        146
+#define TK_NK_BOOL                        147
+#define TK_RATIO                          148
+#define TK_COMPACT                        149
+#define TK_VNODES                         150
+#define TK_IN                             151
+#define TK_OUTPUTTYPE                     152
+#define TK_AGGREGATE                      153
+#define TK_BUFSIZE                        154
+#define TK_STREAM                         155
+#define TK_INTO                           156
+#define TK_TRIGGER                        157
+#define TK_AT_ONCE                        158
+#define TK_WINDOW_CLOSE                   159
+#define TK_WATERMARK                      160
+#define TK_KILL                           161
+#define TK_CONNECTION                     162
+#define TK_MERGE                          163
+#define TK_VGROUP                         164
+#define TK_REDISTRIBUTE                   165
+#define TK_SPLIT                          166
+#define TK_SYNCDB                         167
+#define TK_NULL                           168
+#define TK_NK_QUESTION                    169
+#define TK_NK_ARROW                       170
+#define TK_ROWTS                          171
+#define TK_TBNAME                         172
+#define TK_QSTARTTS                       173
+#define TK_QENDTS                         174
+#define TK_WSTARTTS                       175
+#define TK_WENDTS                         176
+#define TK_WDURATION                      177
+#define TK_CAST                           178
+#define TK_NOW                            179
+#define TK_TODAY                          180
+#define TK_TIMEZONE                       181
+#define TK_COUNT                          182
+#define TK_FIRST                          183
+#define TK_LAST                           184
+#define TK_LAST_ROW                       185
+#define TK_BETWEEN                        186
+#define TK_IS                             187
+#define TK_NK_LT                          188
+#define TK_NK_GT                          189
+#define TK_NK_LE                          190
+#define TK_NK_GE                          191
+#define TK_NK_NE                          192
+#define TK_MATCH                          193
+#define TK_NMATCH                         194
+#define TK_CONTAINS                       195
+#define TK_JOIN                           196
+#define TK_INNER                          197
+#define TK_SELECT                         198
+#define TK_DISTINCT                       199
+#define TK_WHERE                          200
+#define TK_PARTITION                      201
+#define TK_BY                             202
+#define TK_SESSION                        203
+#define TK_STATE_WINDOW                   204
+#define TK_SLIDING                        205
+#define TK_FILL                           206
+#define TK_VALUE                          207
+#define TK_NONE                           208
+#define TK_PREV                           209
+#define TK_LINEAR                         210
+#define TK_NEXT                           211
+#define TK_GROUP                          212
+#define TK_HAVING                         213
+#define TK_ORDER                          214
+#define TK_SLIMIT                         215
+#define TK_SOFFSET                        216
+#define TK_LIMIT                          217
+#define TK_OFFSET                         218
+#define TK_ASC                            219
+#define TK_NULLS                          220
 
 #define TK_NK_SPACE                       300
 #define TK_NK_COMMENT                     301

include/dnode/mnode/mnode.h

@@ -80,6 +80,7 @@ void    mndStop(SMnode *pMnode);
  * @return int32_t 0 for success, -1 for failure.
  */
 int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pCluster, SMonVgroupInfo *pVgroup, SMonGrantInfo *pGrant);
+int32_t mndGetLoad(SMnode *pMnode, SMnodeLoad *pLoad);
 
 /**
  * @brief Process the read, write, sync request.

include/libs/monitor/monitor.h

@@ -202,6 +202,14 @@ int32_t tSerializeSMonVloadInfo(void *buf, int32_t bufLen, SMonVloadInfo *pInfo)
 int32_t tDeserializeSMonVloadInfo(void *buf, int32_t bufLen, SMonVloadInfo *pInfo);
 void    tFreeSMonVloadInfo(SMonVloadInfo *pInfo);
 
+typedef struct {
+  int8_t     isMnode;
+  SMnodeLoad load;
+} SMonMloadInfo;
+
+int32_t tSerializeSMonMloadInfo(void *buf, int32_t bufLen, SMonMloadInfo *pInfo);
+int32_t tDeserializeSMonMloadInfo(void *buf, int32_t bufLen, SMonMloadInfo *pInfo);
+
 typedef struct {
   const char *server;
   uint16_t    port;

include/libs/nodes/cmdnodes.h

@@ -47,6 +47,7 @@ typedef struct SDatabaseOptions {
   SValueNode* pNumOfVgroups;
   SValueNode* pSingleStable;
   SValueNode* pStreamMode;
+  SValueNode* pStrict;
   SNodeList* pRetentions;
 } SDatabaseOptions;
 

include/libs/sync/sync.h

@@ -172,6 +172,8 @@ int32_t syncForwardToPeer(int64_t rid, const SRpcMsg* pMsg, bool isWeak);
 
 extern int32_t sDebugFlag;
 
+const char *syncStr(ESyncState state);
+
 #ifdef __cplusplus
 }
 #endif

include/util/taoserror.h

@@ -617,6 +617,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_FUNC_FUNTION_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2800)
 #define TSDB_CODE_FUNC_FUNTION_PARA_NUM         TAOS_DEF_ERROR_CODE(0, 0x2801)
 #define TSDB_CODE_FUNC_FUNTION_PARA_TYPE        TAOS_DEF_ERROR_CODE(0, 0x2802)
+#define TSDB_CODE_FUNC_FUNTION_PARA_VALUE       TAOS_DEF_ERROR_CODE(0, 0x2803)
 
 #ifdef __cplusplus
 }

include/util/tdef.h

@@ -297,16 +297,6 @@ typedef enum ELogicConditionType {
 #define TSDB_DNODE_CONFIG_LEN 128
 #define TSDB_DNODE_VALUE_LEN  256
 
-#define TSDB_MQTT_HOSTNAME_LEN  64
-#define TSDB_MQTT_PORT_LEN      8
-#define TSDB_MQTT_USER_LEN      24
-#define TSDB_MQTT_PASS_LEN      24
-#define TSDB_MQTT_TOPIC_LEN     64
-#define TSDB_MQTT_CLIENT_ID_LEN 32
-
-#define TSDB_DB_TYPE_DEFAULT 0
-#define TSDB_DB_TYPE_TOPIC   1
-
 #define TSDB_DEFAULT_PKT_SIZE 65480  // same as RPC_MAX_UDP_SIZE
 
 #define TSDB_PAYLOAD_SIZE         TSDB_DEFAULT_PKT_SIZE
@@ -315,9 +305,6 @@ typedef enum ELogicConditionType {
 #define TSDB_CQ_SQL_SIZE          1024
 #define TSDB_MIN_VNODES           16
 #define TSDB_MAX_VNODES           512
-#define TSDB_MIN_VNODES_PER_DB    1
-#define TSDB_MAX_VNODES_PER_DB    4096
-#define TSDB_DEFAULT_VN_PER_DB    2
 
 #define TSDB_DNODE_ROLE_ANY   0
 #define TSDB_DNODE_ROLE_MGMT  1
@@ -331,104 +318,81 @@ typedef enum ELogicConditionType {
 
 #define TSDB_MULTI_TABLEMETA_MAX_NUM 100000  // maximum batch size allowed to load table meta
 
+#define TSDB_MIN_VNODES_PER_DB        1
+#define TSDB_MAX_VNODES_PER_DB        4096
+#define TSDB_DEFAULT_VN_PER_DB        2
 #define TSDB_MIN_CACHE_BLOCK_SIZE     1
 #define TSDB_MAX_CACHE_BLOCK_SIZE     128  // 128MB for each vnode
 #define TSDB_DEFAULT_CACHE_BLOCK_SIZE 16
-
 #define TSDB_MIN_TOTAL_BLOCKS         3
 #define TSDB_MAX_TOTAL_BLOCKS         10000
 #define TSDB_DEFAULT_TOTAL_BLOCKS     6
-
 #define TSDB_MIN_DAYS_PER_FILE        60  // unit minute
 #define TSDB_MAX_DAYS_PER_FILE        (3650 * 1440)
 #define TSDB_DEFAULT_DAYS_PER_FILE    (10 * 1440)
-
 #define TSDB_MIN_KEEP                 (1 * 1440)       // data in db to be reserved. unit minute
 #define TSDB_MAX_KEEP                 (365000 * 1440)  // data in db to be reserved.
 #define TSDB_DEFAULT_KEEP             (3650 * 1440)    // ten years
-
-#define TSDB_MIN_MIN_ROW_FBLOCK     10
-#define TSDB_MAX_MIN_ROW_FBLOCK     1000
-#define TSDB_DEFAULT_MIN_ROW_FBLOCK 100
-
-#define TSDB_MIN_MAX_ROW_FBLOCK     200
-#define TSDB_MAX_MAX_ROW_FBLOCK     10000
-#define TSDB_DEFAULT_MAX_ROW_FBLOCK 4096
-
+#define TSDB_MIN_MINROWS_FBLOCK       10
+#define TSDB_MAX_MINROWS_FBLOCK       1000
+#define TSDB_DEFAULT_MINROWS_FBLOCK   100
+#define TSDB_MIN_MAXROWS_FBLOCK       200
+#define TSDB_MAX_MAXROWS_FBLOCK       10000
+#define TSDB_DEFAULT_MAXROWS_FBLOCK   4096
 #define TSDB_MIN_COMMIT_TIME          30
 #define TSDB_MAX_COMMIT_TIME          40960
 #define TSDB_DEFAULT_COMMIT_TIME      3600
-
 #define TSDB_MIN_FSYNC_PERIOD         0
 #define TSDB_MAX_FSYNC_PERIOD         180000  // millisecond
 #define TSDB_DEFAULT_FSYNC_PERIOD     3000    // three second
-
+#define TSDB_MIN_DB_TTL               1
+#define TSDB_DEFAULT_DB_TTL           1
 #define TSDB_MIN_WAL_LEVEL            1
 #define TSDB_MAX_WAL_LEVEL            2
 #define TSDB_DEFAULT_WAL_LEVEL        1
-
 #define TSDB_MIN_PRECISION            TSDB_TIME_PRECISION_MILLI
 #define TSDB_MAX_PRECISION            TSDB_TIME_PRECISION_NANO
 #define TSDB_DEFAULT_PRECISION        TSDB_TIME_PRECISION_MILLI
-
 #define TSDB_MIN_COMP_LEVEL           0
 #define TSDB_MAX_COMP_LEVEL           2
 #define TSDB_DEFAULT_COMP_LEVEL       2
-
-#define TSDB_MIN_DB_REPLICA_OPTION     1
-#define TSDB_MAX_DB_REPLICA_OPTION     3
-#define TSDB_DEFAULT_DB_REPLICA_OPTION 1
-
-#define TSDB_MIN_DB_QUORUM_OPTION     1
-#define TSDB_MAX_DB_QUORUM_OPTION     2
-#define TSDB_DEFAULT_DB_QUORUM_OPTION 1
-
-#define TSDB_MIN_DB_TTL_OPTION     1
-#define TSDB_DEFAULT_DB_TTL_OPTION 0
-
-#define TSDB_MIN_DB_SINGLE_STABLE_OPTION     0
-#define TSDB_MAX_DB_SINGLE_STABLE_OPTION     1
-#define TSDB_DEFAULT_DB_SINGLE_STABLE_OPTION 0
-
-#define TSDB_MIN_DB_STREAM_MODE_OPTION     0
-#define TSDB_MAX_DB_STREAM_MODE_OPTION     1
-#define TSDB_DEFAULT_DB_STREAM_MODE_OPTION 0
-
-#define TSDB_MAX_JOIN_TABLE_NUM 10
-#define TSDB_MAX_UNION_CLAUSE   5
-
+#define TSDB_MIN_DB_REPLICA           1
+#define TSDB_MAX_DB_REPLICA           3
+#define TSDB_DEFAULT_DB_REPLICA       1
+#define TSDB_DB_STRICT_OFF            0
+#define TSDB_DB_STRICT_ON             1
+#define TSDB_DEFAULT_DB_STRICT        0
 #define TSDB_MIN_DB_UPDATE            0
 #define TSDB_MAX_DB_UPDATE            2
-#define TSDB_DEFAULT_DB_UPDATE_OPTION 0
-
+#define TSDB_DEFAULT_DB_UPDATE        0
 #define TSDB_MIN_DB_CACHE_LAST_ROW    0
 #define TSDB_MAX_DB_CACHE_LAST_ROW    3
 #define TSDB_DEFAULT_CACHE_LAST_ROW   0
-
-#define TSDB_MIN_DB_STREAM_MODE     0
-#define TSDB_MAX_DB_STREAM_MODE     1
+#define TSDB_DB_STREAM_MODE_OFF       0
+#define TSDB_DB_STREAM_MODE_ON        1
 #define TSDB_DEFAULT_DB_STREAM_MODE   0
+#define TSDB_DB_SINGLE_STABLE_ON     0
+#define TSDB_DB_SINGLE_STABLE_OFF     1
+#define TSDB_DEFAULT_DB_SINGLE_STABLE 0
 
 #define TSDB_MIN_DB_FILE_FACTOR     0
 #define TSDB_MAX_DB_FILE_FACTOR     1
 #define TSDB_DEFAULT_DB_FILE_FACTOR 0.1
-
 #define TSDB_MIN_DB_DELAY           1
 #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_EXPLAIN_RESULT_COLUMN_NAME "QUERY PLAN"
-
 #define TSDB_MAX_JOIN_TABLE_NUM 10
 #define TSDB_MAX_UNION_CLAUSE   5
 
+#define TSDB_DEFAULT_EXPLAIN_VERBOSE false
+
+#define TSDB_EXPLAIN_RESULT_ROW_SIZE    1024
+#define TSDB_EXPLAIN_RESULT_COLUMN_NAME "QUERY PLAN"
+
 #define TSDB_MAX_FIELD_LEN             16384
 #define TSDB_MAX_BINARY_LEN            (TSDB_MAX_FIELD_LEN - TSDB_KEYSIZE)  // keep 16384
 #define TSDB_MAX_NCHAR_LEN             (TSDB_MAX_FIELD_LEN - TSDB_KEYSIZE)  // keep 16384

source/client/src/clientHb.c

@@ -630,10 +630,29 @@ void appHbMgrCleanup(void) {
   int sz = taosArrayGetSize(clientHbMgr.appHbMgrs);
   for (int i = 0; i < sz; i++) {
     SAppHbMgr *pTarget = taosArrayGetP(clientHbMgr.appHbMgrs, i);
+    
+    void   *pIter = taosHashIterate(pTarget->activeInfo, NULL);
+    while (pIter != NULL) {
+      SClientHbReq *pOneReq = pIter;
+      hbFreeReq(pOneReq);
+      taosHashCleanup(pOneReq->info);
+      pIter = taosHashIterate(pTarget->activeInfo, pIter);
+    }    
     taosHashCleanup(pTarget->activeInfo);
     pTarget->activeInfo = NULL;
+
+
+    pIter = taosHashIterate(pTarget->connInfo, NULL);
+    while (pIter != NULL) {
+      SHbConnInfo *info = pIter;
+      taosMemoryFree(info->param);
+      pIter = taosHashIterate(pTarget->connInfo, pIter);
+    }    
     taosHashCleanup(pTarget->connInfo);
     pTarget->connInfo = NULL;
+
+    taosMemoryFree(pTarget->key);
+    taosMemoryFree(pTarget);
   }
 }
 
@@ -716,12 +735,23 @@ int hbRegisterConn(SAppHbMgr *pAppHbMgr, int64_t tscRefId, int64_t clusterId, in
 }
 
 void hbDeregisterConn(SAppHbMgr *pAppHbMgr, SClientHbKey connKey) {
-  int32_t code = 0;
-  code = taosHashRemove(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
-  code = taosHashRemove(pAppHbMgr->connInfo, &connKey, sizeof(SClientHbKey));
-  if (code) {
+  SClientHbReq *pReq = taosHashGet(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
+  if (pReq) {
+    hbFreeReq(pReq);
+    taosHashCleanup(pReq->info);
+    taosHashRemove(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
+  }
+
+  SHbConnInfo *info = taosHashGet(pAppHbMgr->connInfo, &connKey, sizeof(SClientHbKey));
+  if (info) {
+    taosMemoryFree(info->param);
+    taosHashRemove(pAppHbMgr->connInfo, &connKey, sizeof(SClientHbKey));
+  }
+  
+  if (NULL == pReq || NULL == info) {
     return;
   }
+  
   atomic_sub_fetch_32(&pAppHbMgr->connKeyCnt, 1);
 }
 

source/client/src/clientImpl.c

@@ -815,3 +815,68 @@ int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableR
   return setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows,
                           convertUcs4);
 }
+
+TSDB_SERVER_STATUS taos_check_server_status(const char* fqdn, int port, char* details, int maxlen) {
+  TSDB_SERVER_STATUS code = TSDB_SRV_STATUS_UNAVAILABLE;
+  void*              clientRpc = NULL;
+  SServerStatusRsp   statusRsp = {0};
+  SEpSet             epSet = {.inUse = 0, .numOfEps = 1};
+  SRpcMsg            rpcMsg = {.ahandle = (void*)0x9526, .msgType = TDMT_DND_SERVER_STATUS};
+  SRpcMsg            rpcRsp = {0};
+  SRpcInit           rpcInit = {0};
+  char               pass[TSDB_PASSWORD_LEN + 1] = {0};
+
+  taosEncryptPass_c((uint8_t*)("_pwd"), strlen("_pwd"), pass);
+  rpcInit.label = "CHK";
+  rpcInit.numOfThreads = 1;
+  rpcInit.cfp = NULL;
+  rpcInit.sessions = 16;
+  rpcInit.connType = TAOS_CONN_CLIENT;
+  rpcInit.idleTime = tsShellActivityTimer * 1000;
+  rpcInit.user = "_dnd";
+  rpcInit.ckey = "_key";
+  rpcInit.spi = 1;
+  rpcInit.secret = pass;
+
+  clientRpc = rpcOpen(&rpcInit);
+  if (clientRpc == NULL) {
+    tscError("failed to init server status client");
+    goto _OVER;
+  }
+
+  if (fqdn == NULL) {
+    fqdn = tsLocalFqdn;
+  }
+
+  if (port == 0) {
+    port = tsServerPort;
+  }
+
+  tstrncpy(epSet.eps[0].fqdn, fqdn, TSDB_FQDN_LEN);
+  epSet.eps[0].port = (uint16_t)port;
+  rpcSendRecv(clientRpc, &epSet, &rpcMsg, &rpcRsp);
+
+  if (rpcRsp.code != 0 || rpcRsp.contLen <= 0 || rpcRsp.pCont == NULL) {
+    tscError("failed to send server status req since %s", terrstr());
+    goto _OVER;
+  }
+
+  if (tDeserializeSServerStatusRsp(rpcRsp.pCont, rpcRsp.contLen, &statusRsp) != 0) {
+    tscError("failed to parse server status rsp since %s", terrstr());
+    goto _OVER;
+  }
+
+  code = statusRsp.statusCode;
+  if (details != NULL && statusRsp.details != NULL) {
+    tstrncpy(details, statusRsp.details, maxlen);
+  }
+
+_OVER:
+  if (clientRpc != NULL) {
+    rpcClose(clientRpc);
+  }
+  if (rpcRsp.pCont != NULL) {
+    rpcFreeCont(rpcRsp.pCont);
+  }
+  return code;
+}

source/common/src/tmsg.c

@@ -611,6 +611,8 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
   if (tEncodeI32(&encoder, pReq->numOfTags) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->numOfSmas) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->commentLen) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->ast1Len) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->ast2Len) < 0) return -1;
 
   for (int32_t i = 0; i < pReq->numOfColumns; ++i) {
     SField *pField = taosArrayGet(pReq->pColumns, i);
@@ -636,6 +638,12 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
   if (pReq->commentLen > 0) {
     if (tEncodeBinary(&encoder, pReq->comment, pReq->commentLen) < 0) return -1;
   }
+  if (pReq->ast1Len > 0) {
+    if (tEncodeBinary(&encoder, pReq->pAst1, pReq->ast1Len) < 0) return -1;
+  }
+  if (pReq->ast2Len > 0) {
+    if (tEncodeBinary(&encoder, pReq->pAst2, pReq->ast2Len) < 0) return -1;
+  }
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -658,6 +666,8 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
   if (tDecodeI32(&decoder, &pReq->numOfTags) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->numOfSmas) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->commentLen) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->ast1Len) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->ast2Len) < 0) return -1;
 
   pReq->pColumns = taosArrayInit(pReq->numOfColumns, sizeof(SField));
   pReq->pTags = taosArrayInit(pReq->numOfTags, sizeof(SField));
@@ -706,6 +716,18 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
     if (tDecodeCStrTo(&decoder, pReq->comment) < 0) return -1;
   }
 
+  if (pReq->ast1Len > 0) {
+    pReq->pAst1 = taosMemoryMalloc(pReq->ast1Len);
+    if (pReq->pAst1 == NULL) return -1;
+    if (tDecodeCStrTo(&decoder, pReq->pAst1) < 0) return -1;
+  }
+
+  if (pReq->ast2Len > 0) {
+    pReq->pAst2 = taosMemoryMalloc(pReq->ast2Len);
+    if (pReq->pAst2 == NULL) return -1;
+    if (tDecodeCStrTo(&decoder, pReq->pAst2) < 0) return -1;
+  }
+
   tEndDecode(&decoder);
 
   tCoderClear(&decoder);
@@ -717,6 +739,8 @@ void tFreeSMCreateStbReq(SMCreateStbReq *pReq) {
   taosArrayDestroy(pReq->pTags);
   taosArrayDestroy(pReq->pSmas);
   taosMemoryFreeClear(pReq->comment);
+  taosMemoryFreeClear(pReq->pAst1);
+  taosMemoryFreeClear(pReq->pAst2);
   pReq->pColumns = NULL;
   pReq->pTags = NULL;
   pReq->pSmas = NULL;
@@ -1003,7 +1027,7 @@ int32_t tSerializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
   for (int32_t i = 0; i < vlen; ++i) {
     SVnodeLoad *pload = taosArrayGet(pReq->pVloads, i);
     if (tEncodeI32(&encoder, pload->vgId) < 0) return -1;
-    if (tEncodeI8(&encoder, pload->role) < 0) return -1;
+    if (tEncodeI32(&encoder, pload->syncState) < 0) return -1;
     if (tEncodeI64(&encoder, pload->numOfTables) < 0) return -1;
     if (tEncodeI64(&encoder, pload->numOfTimeSeries) < 0) return -1;
     if (tEncodeI64(&encoder, pload->totalStorage) < 0) return -1;
@@ -1054,7 +1078,7 @@ int32_t tDeserializeSStatusReq(void *buf, int32_t bufLen, SStatusReq *pReq) {
   for (int32_t i = 0; i < vlen; ++i) {
     SVnodeLoad vload = {0};
     if (tDecodeI32(&decoder, &vload.vgId) < 0) return -1;
-    if (tDecodeI8(&decoder, &vload.role) < 0) return -1;
+    if (tDecodeI32(&decoder, &vload.syncState) < 0) return -1;
     if (tDecodeI64(&decoder, &vload.numOfTables) < 0) return -1;
     if (tDecodeI64(&decoder, &vload.numOfTimeSeries) < 0) return -1;
     if (tDecodeI64(&decoder, &vload.totalStorage) < 0) return -1;
@@ -1736,7 +1760,7 @@ int32_t tSerializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq) {
   if (tEncodeI8(&encoder, pReq->precision) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->compression) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->replications) < 0) return -1;
-  if (tEncodeI8(&encoder, pReq->quorum) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->update) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->ignoreExist) < 0) return -1;
@@ -1779,7 +1803,7 @@ int32_t tDeserializeSCreateDbReq(void *buf, int32_t bufLen, SCreateDbReq *pReq)
   if (tDecodeI8(&decoder, &pReq->precision) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->replications) < 0) return -1;
-  if (tDecodeI8(&decoder, &pReq->quorum) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->update) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->ignoreExist) < 0) return -1;
@@ -1827,7 +1851,7 @@ int32_t tSerializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
   if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->fsyncPeriod) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
-  if (tEncodeI8(&encoder, pReq->quorum) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->replications) < 0) return -1;
   tEndEncode(&encoder);
@@ -1849,7 +1873,7 @@ int32_t tDeserializeSAlterDbReq(void *buf, int32_t bufLen, SAlterDbReq *pReq) {
   if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->fsyncPeriod) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
-  if (tDecodeI8(&decoder, &pReq->quorum) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->replications) < 0) return -1;
   tEndDecode(&decoder);
@@ -2006,7 +2030,7 @@ int32_t tDeserializeSQnodeListRsp(void *buf, int32_t bufLen, SQnodeListRsp *pRsp
 
 void tFreeSQnodeListRsp(SQnodeListRsp *pRsp) { taosArrayDestroy(pRsp->epSetList); }
 
-int32_t tSerializeSSyncDbReq(void *buf, int32_t bufLen, SSyncDbReq *pReq) {
+int32_t tSerializeSCompactDbReq(void *buf, int32_t bufLen, SCompactDbReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
 
@@ -2019,7 +2043,7 @@ int32_t tSerializeSSyncDbReq(void *buf, int32_t bufLen, SSyncDbReq *pReq) {
   return tlen;
 }
 
-int32_t tDeserializeSSyncDbReq(void *buf, int32_t bufLen, SSyncDbReq *pReq) {
+int32_t tDeserializeSCompactDbReq(void *buf, int32_t bufLen, SCompactDbReq *pReq) {
   SCoder decoder = {0};
   tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
 
@@ -2207,10 +2231,18 @@ int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) {
   if (tEncodeI8(&encoder, pRsp->precision) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->compression) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->replications) < 0) return -1;
-  if (tEncodeI8(&encoder, pRsp->quorum) < 0) return -1;
+  if (tEncodeI8(&encoder, pRsp->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->update) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->cacheLastRow) < 0) return -1;
   if (tEncodeI8(&encoder, pRsp->streamMode) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->numOfRetensions) < 0) return -1;
+  for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
+    SRetention *pRetension = taosArrayGet(pRsp->pRetensions, i);
+    if (tEncodeI32(&encoder, pRetension->freq) < 0) return -1;
+    if (tEncodeI32(&encoder, pRetension->keep) < 0) return -1;
+    if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1;
+    if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
+  }
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -2238,11 +2270,28 @@ int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) {
   if (tDecodeI8(&decoder, &pRsp->precision) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->compression) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->replications) < 0) return -1;
-  if (tDecodeI8(&decoder, &pRsp->quorum) < 0) return -1;
+  if (tDecodeI8(&decoder, &pRsp->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->update) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->cacheLastRow) < 0) return -1;
   if (tDecodeI8(&decoder, &pRsp->streamMode) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->numOfRetensions) < 0) return -1;
+  pRsp->pRetensions = taosArrayInit(pRsp->numOfRetensions, sizeof(SRetention));
+  if (pRsp->pRetensions == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
 
+  for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
+    SRetention rentension = {0};
+    if (tDecodeI32(&decoder, &rentension.freq) < 0) return -1;
+    if (tDecodeI32(&decoder, &rentension.keep) < 0) return -1;
+    if (tDecodeI8(&decoder, &rentension.freqUnit) < 0) return -1;
+    if (tDecodeI8(&decoder, &rentension.keepUnit) < 0) return -1;
+    if (taosArrayPush(pRsp->pRetensions, &rentension) == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+  }
   tEndDecode(&decoder);
 
   tCoderClear(&decoder);
@@ -2831,7 +2880,7 @@ int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pR
   if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->precision) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->compression) < 0) return -1;
-  if (tEncodeI8(&encoder, pReq->quorum) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->update) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
@@ -2882,7 +2931,7 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *
   if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->precision) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1;
-  if (tDecodeI8(&decoder, &pReq->quorum) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->update) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
@@ -2954,6 +3003,87 @@ int32_t tDeserializeSDropVnodeReq(void *buf, int32_t bufLen, SDropVnodeReq *pReq
   return 0;
 }
 
+int32_t tSerializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+
+int32_t tSerializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pReq) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->totalBlocks) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep0) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep1) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->daysToKeep2) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->selfIndex) < 0) return -1;
+  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
+    SReplica *pReplica = &pReq->replicas[i];
+    if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
+  }
+  
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pReq) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->totalBlocks) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep0) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep1) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->daysToKeep2) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->selfIndex) < 0) return -1;
+  for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
+    SReplica *pReplica = &pReq->replicas[i];
+    if (tDecodeSReplica(&decoder, pReplica) < 0) return -1;
+  }
+
+  tEndDecode(&decoder);
+  tCoderClear(&decoder);
+  return 0;
+}
+
+
 int32_t tSerializeSKillQueryReq(void *buf, int32_t bufLen, SKillQueryReq *pReq) {
   SCoder encoder = {0};
   tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
@@ -3099,6 +3229,34 @@ int32_t tDeserializeSAuthReq(void *buf, int32_t bufLen, SAuthReq *pReq) {
   return 0;
 }
 
+int32_t tSerializeSServerStatusRsp(void *buf, int32_t bufLen, SServerStatusRsp *pRsp) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->statusCode) < 0) return -1;
+  if (tEncodeCStr(&encoder, pRsp->details) < 0) return -1;
+
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSServerStatusRsp(void *buf, int32_t bufLen, SServerStatusRsp *pRsp) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->statusCode) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pRsp->details) < 0) return -1;
+
+  tEndDecode(&decoder);
+  tCoderClear(&decoder);
+  return 0;
+}
+
 int32_t tEncodeSMqOffset(SCoder *encoder, const SMqOffset *pOffset) {
   if (tEncodeI32(encoder, pOffset->vgId) < 0) return -1;
   if (tEncodeI64(encoder, pOffset->offset) < 0) return -1;

source/common/src/tmsgcb.c

@@ -41,3 +41,7 @@ void tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg) {
 void tmsgReleaseHandle(void* handle, int8_t type) {
   (*tsDefaultMsgCb.releaseHandleFp)(tsDefaultMsgCb.pWrapper, handle, type);
 }
+
+void tmsgReportStartup(const char* name, const char* desc) {
+  (*tsDefaultMsgCb.reportStartupFp)(tsDefaultMsgCb.pWrapper, name, desc);
+}
\ No newline at end of file

source/dnode/mgmt/implement/inc/dmImp.h

@@ -49,6 +49,7 @@ int32_t dmProcessDropNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg)
 
 // dmMonitor.c
 void dmGetVnodeLoads(SDnode *pDnode, SMonVloadInfo *pInfo);
+void dmGetMnodeLoads(SDnode *pDnode, SMonMloadInfo *pInfo);
 void dmSendMonitorReport(SDnode *pDnode);
 
 // dmWorker.c
@@ -70,6 +71,7 @@ void vmSetMgmtFp(SMgmtWrapper *pWrapper);
 void mmSetMgmtFp(SMgmtWrapper *pWrapper);
 
 void vmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo);
+void mmGetMnodeLoads(SMgmtWrapper *pWrapper, SMonMloadInfo *pInfo);
 void mmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonMmInfo *mmInfo);
 void vmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonVmInfo *vmInfo);
 void qmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonQmInfo *qmInfo);

source/dnode/mgmt/implement/src/dmExec.c

@@ -140,6 +140,7 @@ int32_t dmOpenNode(SMgmtWrapper *pWrapper) {
     if (dmRunParentProc(pWrapper) != 0) return -1;
   }
 
+  dmReportStartup(pWrapper->pDnode, pWrapper->name, "openned");
   return 0;
 }
 
@@ -161,6 +162,7 @@ int32_t dmStartNode(SMgmtWrapper *pWrapper) {
     }
   }
 
+  dmReportStartup(pWrapper->pDnode, pWrapper->name, "started");
   return 0;
 }
 
@@ -172,6 +174,11 @@ void dmStopNode(SMgmtWrapper *pWrapper) {
 
 void dmCloseNode(SMgmtWrapper *pWrapper) {
   dInfo("node:%s, start to close", pWrapper->name);
+
+  while (pWrapper->refCount > 0) {
+    taosMsleep(10);
+  }
+
   if (pWrapper->procType == DND_PROC_PARENT) {
     if (pWrapper->procId > 0 && taosProcExist(pWrapper->procId)) {
       dInfo("node:%s, send kill signal to the child process:%d", pWrapper->name, pWrapper->procId);
@@ -184,18 +191,10 @@ void dmCloseNode(SMgmtWrapper *pWrapper) {
 
   dmStopNode(pWrapper);
 
-  pWrapper->required = false;
   taosWLockLatch(&pWrapper->latch);
-  if (pWrapper->deployed) {
   (*pWrapper->fp.closeFp)(pWrapper);
-    pWrapper->deployed = false;
-  }
   taosWUnLockLatch(&pWrapper->latch);
 
-  while (pWrapper->refCount > 0) {
-    taosMsleep(10);
-  }
-
   if (pWrapper->procObj) {
     taosProcCleanup(pWrapper->procObj);
     pWrapper->procObj = NULL;

source/dnode/mgmt/implement/src/dmHandle.c

@@ -36,7 +36,8 @@ static int32_t dmProcessStatusRsp(SDnode *pDnode, SRpcMsg *pRsp) {
     }
   } else {
     SStatusRsp statusRsp = {0};
-    if (pRsp->pCont != NULL && pRsp->contLen > 0 && tDeserializeSStatusRsp(pRsp->pCont, pRsp->contLen, &statusRsp) == 0) {
+    if (pRsp->pCont != NULL && pRsp->contLen > 0 &&
+        tDeserializeSStatusRsp(pRsp->pCont, pRsp->contLen, &statusRsp) == 0) {
       pDnode->data.dnodeVer = statusRsp.dnodeVer;
       dmUpdateDnodeCfg(pDnode, &statusRsp.dnodeCfg);
       dmUpdateEps(pDnode, statusRsp.pDnodeEps);
@@ -71,12 +72,26 @@ void dmSendStatusReq(SDnode *pDnode) {
   memcpy(req.clusterCfg.charset, tsCharset, TD_LOCALE_LEN);
   taosRUnLockLatch(&pDnode->data.latch);
 
-  SMonVloadInfo info = {0};
-  dmGetVnodeLoads(pDnode, &info);
-  req.pVloads = info.pVloads;
+  SMonVloadInfo vinfo = {0};
+  dmGetVnodeLoads(pDnode, &vinfo);
+  req.pVloads = vinfo.pVloads;
+  pDnode->data.unsyncedVgId = 0;
+  pDnode->data.vndState = TAOS_SYNC_STATE_LEADER;
+  for (int32_t i = 0; i < taosArrayGetSize(req.pVloads); ++i) {
+    SVnodeLoad *pLoad = taosArrayGet(req.pVloads, i);
+    if (pLoad->syncState != TAOS_SYNC_STATE_LEADER && pLoad->syncState != TAOS_SYNC_STATE_FOLLOWER) {
+      pDnode->data.unsyncedVgId = pLoad->vgId;
+      pDnode->data.vndState = pLoad->syncState;
+    }
+  }
+
+  SMonMloadInfo minfo = {0};
+  dmGetMnodeLoads(pDnode, &minfo);
+  pDnode->data.isMnode = minfo.isMnode;
+  pDnode->data.mndState = minfo.load.syncState;
 
   int32_t contLen = tSerializeSStatusReq(NULL, 0, &req);
-  void *  pHead = rpcMallocCont(contLen);
+  void   *pHead = rpcMallocCont(contLen);
   tSerializeSStatusReq(pHead, contLen, &req);
   tFreeSStatusReq(&req);
 
@@ -101,7 +116,7 @@ int32_t dmProcessGrantRsp(SDnode *pDnode, SNodeMsg *pMsg) {
 }
 
 int32_t dmProcessConfigReq(SDnode *pDnode, SNodeMsg *pMsg) {
-  SRpcMsg *      pReq = &pMsg->rpcMsg;
+  SRpcMsg       *pReq = &pMsg->rpcMsg;
   SDCfgDnodeReq *pCfg = pReq->pCont;
   dError("config req is received, but not supported yet");
   return TSDB_CODE_OPS_NOT_SUPPORT;
@@ -160,9 +175,9 @@ int32_t dmProcessDropNodeReq(SDnode *pDnode, EDndNodeType ntype, SNodeMsg *pMsg)
   dmReleaseWrapper(pWrapper);
 
   if (code == 0) {
-    dmCloseNode(pWrapper);
     pWrapper->required = false;
     pWrapper->deployed = false;
+    dmCloseNode(pWrapper);
     taosRemoveDir(pWrapper->path);
   }
   taosThreadMutexUnlock(&pDnode->mutex);
@@ -230,6 +245,7 @@ static int32_t dmInitMgmt(SMgmtWrapper *pWrapper) {
     dError("failed to init transport since %s", terrstr());
     return -1;
   }
+  dmReportStartup(pDnode, "dnode-transport", "initialized");
 
   dInfo("dnode-mgmt is initialized");
   return 0;

source/dnode/mgmt/implement/src/dmMonitor.c

@@ -183,3 +183,29 @@ void dmGetVnodeLoads(SDnode *pDnode, SMonVloadInfo *pInfo) {
   }
   dmReleaseWrapper(pWrapper);
 }
+
+void dmGetMnodeLoads(SDnode *pDnode, SMonMloadInfo *pInfo) {
+  SMgmtWrapper *pWrapper = dmAcquireWrapper(pDnode, MNODE);
+  if (pWrapper == NULL) {
+    pInfo->isMnode = 0;
+    return;
+  }
+
+  bool getFromAPI = !tsMultiProcess;
+  if (getFromAPI) {
+    mmGetMnodeLoads(pWrapper, pInfo);
+  } else {
+    SRpcMsg req = {.msgType = TDMT_MON_MM_LOAD};
+    SRpcMsg rsp = {0};
+    SEpSet  epset = {.inUse = 0, .numOfEps = 1};
+    tstrncpy(epset.eps[0].fqdn, pDnode->data.localFqdn, TSDB_FQDN_LEN);
+    epset.eps[0].port = tsServerPort;
+
+    dmSendRecv(pDnode, &epset, &req, &rsp);
+    if (rsp.code == 0 && rsp.contLen > 0) {
+      tDeserializeSMonMloadInfo(rsp.pCont, rsp.contLen, pInfo);
+    }
+    rpcFreeCont(rsp.pCont);
+  }
+  dmReleaseWrapper(pWrapper);
+}

source/dnode/mgmt/implement/src/dmTransport.c

@@ -125,9 +125,9 @@ static void dmProcessMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet) {
   SMsgHandle   *pHandle = &pTrans->msgHandles[TMSG_INDEX(msgType)];
   SMgmtWrapper *pWrapper = pHandle->pNdWrapper;
 
-  if (msgType == TDMT_DND_NETWORK_TEST) {
-    dTrace("network test req will be processed, handle:%p, app:%p", pMsg->handle, pMsg->ahandle);
-    dmProcessStartupReq(pDnode, pMsg);
+  if (msgType == TDMT_DND_SERVER_STATUS) {
+    dTrace("server status req will be processed, handle:%p, app:%p", pMsg->handle, pMsg->ahandle);
+    dmProcessServerStatusReq(pDnode, pMsg);
     return;
   }
 
@@ -519,6 +519,7 @@ SMsgCb dmGetMsgcb(SMgmtWrapper *pWrapper) {
       .sendRspFp = dmSendRsp,
       .registerBrokenLinkArgFp = dmRegisterBrokenLinkArg,
       .releaseHandleFp = dmReleaseHandle,
+      .reportStartupFp = dmReportStartupByWrapper,
       .pWrapper = pWrapper,
   };
   return msgCb;

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

@@ -74,6 +74,7 @@ int32_t dmStartStatusThread(SDnode *pDnode) {
     return -1;
   }
 
+  dmReportStartup(pDnode, "dnode-status", "initialized");
   return 0;
 }
 
@@ -92,6 +93,7 @@ int32_t dmStartMonitorThread(SDnode *pDnode) {
     return -1;
   }
 
+  dmReportStartup(pDnode, "dnode-monitor", "initialized");
   return 0;
 }
 

source/dnode/mgmt/interface/inc/dmDef.h

@@ -38,6 +38,7 @@
 #include "dnode.h"
 #include "mnode.h"
 #include "monitor.h"
+#include "sync.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -110,6 +111,10 @@ typedef struct {
   int64_t       dnodeVer;
   int64_t       updateTime;
   int64_t       rebootTime;
+  int32_t       unsyncedVgId;
+  ESyncState    vndState;
+  ESyncState    mndState;
+  bool          isMnode;
   bool          dropped;
   SEpSet        mnodeEps;
   SArray       *dnodeEps;
@@ -132,12 +137,17 @@ typedef struct {
   uint16_t      serverPort;
 } SDnodeData;
 
+typedef struct {
+  char name[TSDB_STEP_NAME_LEN];
+  char desc[TSDB_STEP_DESC_LEN];
+} SStartupInfo;
+
 typedef struct SDnode {
   EDndProcType  ptype;
   EDndNodeType  ntype;
   EDndRunStatus status;
   EDndEvent     event;
-  SStartupReq   startup;
+  SStartupInfo  startup;
   SDnodeTrans   trans;
   SDnodeData    data;
   TdThreadMutex mutex;

source/dnode/mgmt/interface/inc/dmInt.h

@@ -35,7 +35,8 @@ void   dmSetStatus(SDnode *pDnode, EDndRunStatus stat);
 void   dmSetEvent(SDnode *pDnode, EDndEvent event);
 void   dmSetMsgHandle(SMgmtWrapper *pWrapper, tmsg_t msgType, NodeMsgFp nodeMsgFp, int8_t vgId);
 void   dmReportStartup(SDnode *pDnode, const char *pName, const char *pDesc);
-void   dmProcessStartupReq(SDnode *pDnode, SRpcMsg *pMsg);
+void   dmReportStartupByWrapper(SMgmtWrapper *pWrapper, const char *pName, const char *pDesc);
+void   dmProcessServerStatusReq(SDnode *pDnode, SRpcMsg *pMsg);
 void   dmGetMonitorSysInfo(SMonSysInfo *pInfo);
 
 // dmFile.c

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

@@ -137,26 +137,65 @@ void dmReleaseWrapper(SMgmtWrapper *pWrapper) {
 }
 
 void dmReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) {
-  SStartupReq *pStartup = &pDnode->startup;
+  SStartupInfo *pStartup = &pDnode->startup;
   tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN);
   tstrncpy(pStartup->desc, pDesc, TSDB_STEP_DESC_LEN);
-  pStartup->finished = 0;
+  dInfo("step:%s, %s", pStartup->name, pStartup->desc);
 }
 
-static void dmGetStartup(SDnode *pDnode, SStartupReq *pStartup) {
-  memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
-  pStartup->finished = (pDnode->status == DND_STAT_RUNNING);
+void dmReportStartupByWrapper(SMgmtWrapper *pWrapper, const char *pName, const char *pDesc) {
+  dmReportStartup(pWrapper->pDnode, pName, pDesc);
 }
 
-void dmProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
-  dDebug("startup req is received");
-  SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));
-  dmGetStartup(pDnode, pStartup);
+static void dmGetServerStatus(SDnode *pDnode, SServerStatusRsp *pStatus) {
+  pStatus->details[0] = 0;
 
-  dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
-  SRpcMsg rpcRsp = {
-      .handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq), .ahandle = pReq->ahandle};
-  rpcSendResponse(&rpcRsp);
+  if (pDnode->status == DND_STAT_INIT) {
+    pStatus->statusCode = TSDB_SRV_STATUS_NETWORK_OK;
+    snprintf(pStatus->details, sizeof(pStatus->details), "%s: %s", pDnode->startup.name, pDnode->startup.desc);
+  } else if (pDnode->status == DND_STAT_STOPPED) {
+    pStatus->statusCode = TSDB_SRV_STATUS_EXTING;
+  } else {
+    SDnodeData *pData = &pDnode->data;
+    if (pData->isMnode && pData->mndState != TAOS_SYNC_STATE_LEADER && pData->mndState == TAOS_SYNC_STATE_FOLLOWER) {
+      pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_DEGRADED;
+      snprintf(pStatus->details, sizeof(pStatus->details), "mnode sync state is %s", syncStr(pData->mndState));
+    } else if (pData->unsyncedVgId != 0 && pData->vndState != TAOS_SYNC_STATE_LEADER &&
+               pData->vndState != TAOS_SYNC_STATE_FOLLOWER) {
+      pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_DEGRADED;
+      snprintf(pStatus->details, sizeof(pStatus->details), "vnode:%d sync state is %s", pData->unsyncedVgId,
+               syncStr(pData->vndState));
+    } else {
+      pStatus->statusCode = TSDB_SRV_STATUS_SERVICE_OK;
+    }
+  }
+}
+
+void dmProcessServerStatusReq(SDnode *pDnode, SRpcMsg *pReq) {
+  dDebug("server status req is received");
+
+  SServerStatusRsp statusRsp = {0};
+  dmGetServerStatus(pDnode, &statusRsp);
+
+  SRpcMsg rspMsg = {.handle = pReq->handle, .ahandle = pReq->ahandle};
+  int32_t rspLen = tSerializeSServerStatusRsp(NULL, 0, &statusRsp);
+  if (rspLen < 0) {
+    rspMsg.code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
+
+  void *pRsp = rpcMallocCont(rspLen);
+  if (pRsp == NULL) {
+    rspMsg.code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
+
+  tSerializeSServerStatusRsp(pRsp, rspLen, &statusRsp);
+  rspMsg.pCont = pRsp;
+  rspMsg.contLen = rspLen;
+
+_OVER:
+  rpcSendResponse(&rspMsg);
 }
 
 void dmGetMonitorSysInfo(SMonSysInfo *pInfo) {

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

@@ -61,12 +61,14 @@ int32_t bmOpen(SMgmtWrapper *pWrapper) {
     bmClose(pWrapper);
     return -1;
   }
+  dmReportStartup(pWrapper->pDnode, "bnode-impl", "initialized");
 
   if (bmStartWorker(pMgmt) != 0) {
     dError("failed to start bnode worker since %s", terrstr());
     bmClose(pWrapper);
     return -1;
   }
+  dmReportStartup(pWrapper->pDnode, "bnode-worker", "initialized");
 
   return 0;
 }

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

@@ -52,6 +52,8 @@ int32_t mmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
 int32_t mmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
 int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t mmProcessGetMonMmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
+int32_t mmProcessGetMnodeLoadsReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
+void    mmGetMnodeLoads(SMgmtWrapper *pWrapper, SMonMloadInfo *pInfo);
 
 // mmWorker.c
 int32_t mmStartWorker(SMnodeMgmt *pMgmt);

source/dnode/mgmt/mgmt_mnode/src/mmHandle.c

@@ -46,6 +46,34 @@ int32_t mmProcessGetMonMmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
   return 0;
 }
 
+void mmGetMnodeLoads(SMgmtWrapper *pWrapper, SMonMloadInfo *pInfo) {
+  SMnodeMgmt *pMgmt = pWrapper->pMgmt;
+  pInfo->isMnode = 1;
+  mndGetLoad(pMgmt->pMnode, &pInfo->load);
+}
+
+int32_t mmProcessGetMnodeLoadsReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
+  SMonMloadInfo mloads = {0};
+  mmGetMnodeLoads(pWrapper, &mloads);
+
+  int32_t rspLen = tSerializeSMonMloadInfo(NULL, 0, &mloads);
+  if (rspLen < 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    return -1;
+  }
+
+  void *pRsp = rpcMallocCont(rspLen);
+  if (pRsp == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  tSerializeSMonMloadInfo(pRsp, rspLen, &mloads);
+  pReq->pRsp = pRsp;
+  pReq->rspLen = rspLen;
+  return 0;
+}
+
 int32_t mmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg) {
   SDnode  *pDnode = pWrapper->pDnode;
   SRpcMsg *pReq = &pMsg->rpcMsg;
@@ -117,6 +145,7 @@ int32_t mmProcessAlterReq(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
 
 void mmInitMsgHandle(SMgmtWrapper *pWrapper) {
   dmSetMsgHandle(pWrapper, TDMT_MON_MM_INFO, mmProcessMonitorMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_MON_MM_LOAD, mmProcessMonitorMsg, DEFAULT_HANDLE);
 
   // Requests handled by DNODE
   dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
@@ -129,10 +158,7 @@ void mmInitMsgHandle(SMgmtWrapper *pWrapper) {
   dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_ALTER_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_DND_DROP_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_SYNC_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_COMPACT_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
 
   // Requests handled by MNODE
@@ -159,7 +185,6 @@ void mmInitMsgHandle(SMgmtWrapper *pWrapper) {
   dmSetMsgHandle(pWrapper, TDMT_MND_DROP_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_MND_USE_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_MND_ALTER_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_MND_SYNC_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_MND_COMPACT_DB, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_MND_CREATE_FUNC, mmProcessWriteMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_MND_RETRIEVE_FUNC, mmProcessWriteMsg, DEFAULT_HANDLE);
@@ -206,4 +231,8 @@ void mmInitMsgHandle(SMgmtWrapper *pWrapper) {
   dmSetMsgHandle(pWrapper, TDMT_VND_FETCH, mmProcessQueryMsg, MNODE_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, mmProcessQueryMsg, MNODE_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, mmProcessQueryMsg, MNODE_HANDLE);
+
+  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_SYNC_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_COMPACT_VNODE_RSP, mmProcessWriteMsg, DEFAULT_HANDLE);
 }

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

@@ -176,12 +176,14 @@ static int32_t mmOpen(SMgmtWrapper *pWrapper) {
     mmClose(pWrapper);
     return -1;
   }
+  dmReportStartup(pWrapper->pDnode, "mnode-impl", "initialized");
 
   if (mmStartWorker(pMgmt) != 0) {
     dError("failed to start mnode worker since %s", terrstr());
     mmClose(pWrapper);
     return -1;
   }
+  dmReportStartup(pWrapper->pDnode, "mnode-worker", "initialized");
 
   if (!deployed) {
     deployed = true;

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

@@ -36,6 +36,8 @@ static void mmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
     code = mmProcessAlterReq(pMgmt, pMsg);
   } else if (pMsg->rpcMsg.msgType == TDMT_MON_MM_INFO) {
     code = mmProcessGetMonMmInfoReq(pMgmt->pWrapper, pMsg);
+  } else if (pMsg->rpcMsg.msgType == TDMT_MON_MM_LOAD) {
+    code = mmProcessGetMnodeLoadsReq(pMgmt->pWrapper, pMsg);
   } else {
     pMsg->pNode = pMgmt->pMnode;
     code = mndProcessMsg(pMsg);

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

@@ -64,12 +64,14 @@ static int32_t qmOpen(SMgmtWrapper *pWrapper) {
     qmClose(pWrapper);
     return -1;
   }
+  dmReportStartup(pWrapper->pDnode, "qnode-impl", "initialized");
 
   if (qmStartWorker(pMgmt) != 0) {
     dError("failed to start qnode worker since %s", terrstr());
     qmClose(pWrapper);
     return -1;
   }
+  dmReportStartup(pWrapper->pDnode, "qnode-worker", "initialized");
 
   dInfo("qnode-mgmt is initialized");
   return 0;

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

@@ -60,11 +60,13 @@ int32_t smOpen(SMgmtWrapper *pWrapper) {
     dError("failed to open snode since %s", terrstr());
     return -1;
   }
+  dmReportStartup(pWrapper->pDnode, "snode-impl", "initialized");
 
   if (smStartWorker(pMgmt) != 0) {
     dError("failed to start snode worker since %s", terrstr());
     return -1;
   }
+  dmReportStartup(pWrapper->pDnode, "snode-worker", "initialized");
 
   return 0;
 }

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

@@ -29,7 +29,6 @@ typedef struct SVnodesMgmt {
   SHashObj     *hash;
   SRWLatch      latch;
   SVnodesStat   state;
-  SVnodesStat   lastState;
   STfs         *pTfs;
   SQWorkerPool  queryPool;
   SQWorkerPool  fetchPool;
@@ -90,10 +89,7 @@ void       vmCloseVnode(SVnodesMgmt *pMgmt, SVnodeObj *pVnode);
 // vmHandle.c
 void    vmInitMsgHandle(SMgmtWrapper *pWrapper);
 int32_t vmProcessCreateVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pReq);
-int32_t vmProcessAlterVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pReq);
 int32_t vmProcessDropVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pReq);
-int32_t vmProcessSyncVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pReq);
-int32_t vmProcessCompactVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pReq);
 int32_t vmProcessGetMonVmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
 int32_t vmProcessGetVnodeLoadsReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq);
 void    vmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo);

source/dnode/mgmt/mgmt_vnode/src/vmHandle.c

@@ -16,21 +16,42 @@
 #define _DEFAULT_SOURCE
 #include "vmInt.h"
 
-void vmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonVmInfo *vmInfo) {
+void vmGetMonitorInfo(SMgmtWrapper *pWrapper, SMonVmInfo *pInfo) {
   SVnodesMgmt *pMgmt = pWrapper->pMgmt;
-  tfsGetMonitorInfo(pMgmt->pTfs, &vmInfo->tfs);
-
-  taosWLockLatch(&pMgmt->latch);
-  vmInfo->vstat.totalVnodes = pMgmt->state.totalVnodes;
-  vmInfo->vstat.masterNum = pMgmt->state.masterNum;
-  vmInfo->vstat.numOfSelectReqs = pMgmt->state.numOfSelectReqs - pMgmt->lastState.numOfSelectReqs;
-  vmInfo->vstat.numOfInsertReqs = pMgmt->state.numOfInsertReqs - pMgmt->lastState.numOfInsertReqs;
-  vmInfo->vstat.numOfInsertSuccessReqs = pMgmt->state.numOfInsertSuccessReqs - pMgmt->lastState.numOfInsertSuccessReqs;
-  vmInfo->vstat.numOfBatchInsertReqs = pMgmt->state.numOfBatchInsertReqs - pMgmt->lastState.numOfBatchInsertReqs;
-  vmInfo->vstat.numOfBatchInsertSuccessReqs =
-      pMgmt->state.numOfBatchInsertSuccessReqs - pMgmt->lastState.numOfBatchInsertSuccessReqs;
-  pMgmt->lastState = pMgmt->state;
-  taosWUnLockLatch(&pMgmt->latch);
+
+  SMonVloadInfo vloads = {0};
+  vmGetVnodeLoads(pWrapper, &vloads);
+  if (vloads.pVloads == NULL) return;
+
+  int32_t totalVnodes = 0;
+  int32_t masterNum = 0;
+  int64_t numOfSelectReqs = 0;
+  int64_t numOfInsertReqs = 0;
+  int64_t numOfInsertSuccessReqs = 0;
+  int64_t numOfBatchInsertReqs = 0;
+  int64_t numOfBatchInsertSuccessReqs = 0;
+
+  for (int32_t i = 0; i < taosArrayGetSize(vloads.pVloads); ++i) {
+    SVnodeLoad *pLoad = taosArrayGet(vloads.pVloads, i);
+    numOfSelectReqs += pLoad->numOfSelectReqs;
+    numOfInsertReqs += pLoad->numOfInsertReqs;
+    numOfInsertSuccessReqs += pLoad->numOfInsertSuccessReqs;
+    numOfBatchInsertReqs += pLoad->numOfBatchInsertReqs;
+    numOfBatchInsertSuccessReqs += pLoad->numOfBatchInsertSuccessReqs;
+    if (pLoad->syncState == TAOS_SYNC_STATE_LEADER) masterNum++;
+    totalVnodes++;
+  }
+
+  pInfo->vstat.totalVnodes = totalVnodes;
+  pInfo->vstat.masterNum = masterNum;
+  pInfo->vstat.numOfSelectReqs = numOfSelectReqs - pMgmt->state.numOfSelectReqs;
+  pInfo->vstat.numOfInsertReqs = numOfInsertReqs - pMgmt->state.numOfInsertReqs;
+  pInfo->vstat.numOfInsertSuccessReqs = numOfInsertSuccessReqs - pMgmt->state.numOfInsertSuccessReqs;
+  pInfo->vstat.numOfBatchInsertReqs = numOfBatchInsertReqs - pMgmt->state.numOfBatchInsertReqs;
+  pInfo->vstat.numOfBatchInsertSuccessReqs = numOfBatchInsertSuccessReqs - pMgmt->state.numOfBatchInsertSuccessReqs;
+  pMgmt->state = pInfo->vstat;
+
+  taosArrayDestroy(vloads.pVloads);
 }
 
 int32_t vmProcessGetMonVmInfoReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
@@ -182,48 +203,6 @@ int32_t vmProcessCreateVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t vmProcessAlterVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
-  SRpcMsg       *pReq = &pMsg->rpcMsg;
-  SAlterVnodeReq alterReq = {0};
-  if (tDeserializeSCreateVnodeReq(pReq->pCont, pReq->contLen, &alterReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    return -1;
-  }
-
-  dDebug("vgId:%d, alter vnode req is received", alterReq.vgId);
-
-  SVnodeCfg vnodeCfg = {0};
-  vmGenerateVnodeCfg(&alterReq, &vnodeCfg);
-
-  SVnodeObj *pVnode = vmAcquireVnode(pMgmt, alterReq.vgId);
-  if (pVnode == NULL) {
-    dDebug("vgId:%d, failed to alter vnode since %s", alterReq.vgId, terrstr());
-    return -1;
-  }
-
-  if (alterReq.vgVersion == pVnode->vgVersion) {
-    vmReleaseVnode(pMgmt, pVnode);
-    dDebug("vgId:%d, no need to alter vnode cfg for version unchanged ", alterReq.vgId);
-    return 0;
-  }
-
-  if (vnodeAlter(pVnode->pImpl, &vnodeCfg) != 0) {
-    dError("vgId:%d, failed to alter vnode since %s", alterReq.vgId, terrstr());
-    vmReleaseVnode(pMgmt, pVnode);
-    return -1;
-  }
-
-  int32_t oldVersion = pVnode->vgVersion;
-  pVnode->vgVersion = alterReq.vgVersion;
-  int32_t code = vmWriteVnodesToFile(pMgmt);
-  if (code != 0) {
-    pVnode->vgVersion = oldVersion;
-  }
-
-  vmReleaseVnode(pMgmt, pVnode);
-  return code;
-}
-
 int32_t vmProcessDropVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
   SRpcMsg      *pReq = &pMsg->rpcMsg;
   SDropVnodeReq dropReq = {0};
@@ -255,100 +234,52 @@ int32_t vmProcessDropVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
   return 0;
 }
 
-int32_t vmProcessSyncVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
-  SRpcMsg      *pReq = &pMsg->rpcMsg;
-  SSyncVnodeReq syncReq = {0};
-  tDeserializeSDropVnodeReq(pReq->pCont, pReq->contLen, &syncReq);
-
-  int32_t vgId = syncReq.vgId;
-  dDebug("vgId:%d, sync vnode req is received", vgId);
-
-  SVnodeObj *pVnode = vmAcquireVnode(pMgmt, vgId);
-  if (pVnode == NULL) {
-    dDebug("vgId:%d, failed to sync since %s", vgId, terrstr());
-    return -1;
-  }
-
-  if (vnodeSync(pVnode->pImpl) != 0) {
-    dError("vgId:%d, failed to sync vnode since %s", vgId, terrstr());
-    vmReleaseVnode(pMgmt, pVnode);
-    return -1;
-  }
-
-  vmReleaseVnode(pMgmt, pVnode);
-  return 0;
-}
-
-int32_t vmProcessCompactVnodeReq(SVnodesMgmt *pMgmt, SNodeMsg *pMsg) {
-  SRpcMsg         *pReq = &pMsg->rpcMsg;
-  SCompactVnodeReq compatcReq = {0};
-  tDeserializeSDropVnodeReq(pReq->pCont, pReq->contLen, &compatcReq);
-
-  int32_t vgId = compatcReq.vgId;
-  dDebug("vgId:%d, compact vnode req is received", vgId);
-
-  SVnodeObj *pVnode = vmAcquireVnode(pMgmt, vgId);
-  if (pVnode == NULL) {
-    dDebug("vgId:%d, failed to compact since %s", vgId, terrstr());
-    return -1;
-  }
-
-  if (vnodeCompact(pVnode->pImpl) != 0) {
-    dError("vgId:%d, failed to compact vnode since %s", vgId, terrstr());
-    vmReleaseVnode(pMgmt, pVnode);
-    return -1;
-  }
-
-  vmReleaseVnode(pMgmt, pVnode);
-  return 0;
-}
-
 void vmInitMsgHandle(SMgmtWrapper *pWrapper) {
   dmSetMsgHandle(pWrapper, TDMT_MON_VM_INFO, vmProcessMonitorMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_MON_VM_LOAD, vmProcessMonitorMsg, DEFAULT_HANDLE);
 
   // Requests handled by VNODE
-  dmSetMsgHandle(pWrapper, TDMT_VND_SUBMIT, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_UPDATE_TAG_VAL, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TABLE_META, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TABLES_META, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CONSUME, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_QUERY, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CONNECT, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_DISCONNECT, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_RES_READY, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_REB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CANCEL_CONN, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CONSUME, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_PIPE_EXEC, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_MERGE_EXEC, (NodeMsgFp)vmProcessMergeMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_WRITE_EXEC, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_STREAM_TRIGGER, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_SUBMIT, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY, vmProcessQueryMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, vmProcessQueryMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_TABLE, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_UPDATE_TAG_VAL, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TABLE_META, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TABLES_META, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CONSUME, vmProcessQueryMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_QUERY, vmProcessQueryMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CONNECT, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_DISCONNECT, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_RES_READY, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_STB, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_TABLE, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TABLE, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_SMA, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_REB, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CANCEL_CONN, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CONSUME, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_PIPE_EXEC, vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_MERGE_EXEC, vmProcessMergeMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_WRITE_EXEC, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_STREAM_TRIGGER, vmProcessFetchMsg, DEFAULT_HANDLE);
+
+  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_VNODE, vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_COMPACT_VNODE, vmProcessWriteMsg, DEFAULT_HANDLE);
 
   dmSetMsgHandle(pWrapper, TDMT_DND_CREATE_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_ALTER_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
   dmSetMsgHandle(pWrapper, TDMT_DND_DROP_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_SYNC_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_DND_COMPACT_VNODE, vmProcessMgmtMsg, DEFAULT_HANDLE);
 }

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

@@ -130,7 +130,7 @@ static void *vmOpenVnodeFunc(void *param) {
     char stepDesc[TSDB_STEP_DESC_LEN] = {0};
     snprintf(stepDesc, TSDB_STEP_DESC_LEN, "vgId:%d, start to restore, %d of %d have been opened", pCfg->vgId,
              pMgmt->state.openVnodes, pMgmt->state.totalVnodes);
-    dmReportStartup(pDnode, "open-vnodes", stepDesc);
+    dmReportStartup(pDnode, "vnode-open", stepDesc);
 
     SMsgCb msgCb = pMgmt->pDnode->data.msgCb;
     msgCb.pWrapper = pMgmt->pWrapper;
@@ -298,25 +298,30 @@ static int32_t vmInit(SMgmtWrapper *pWrapper) {
     dError("failed to init tfs since %s", terrstr());
     goto _OVER;
   }
+  dmReportStartup(pDnode, "vnode-tfs", "initialized");
 
   if (walInit() != 0) {
     dError("failed to init wal since %s", terrstr());
     goto _OVER;
   }
+  dmReportStartup(pDnode, "vnode-wal", "initialized");
 
   if (vnodeInit(tsNumOfCommitThreads) != 0) {
     dError("failed to init vnode since %s", terrstr());
     goto _OVER;
   }
+  dmReportStartup(pDnode, "vnode-commit", "initialized");
 
   if (vmStartWorker(pMgmt) != 0) {
     dError("failed to init workers since %s", terrstr()) goto _OVER;
   }
+  dmReportStartup(pDnode, "vnode-worker", "initialized");
 
   if (vmOpenVnodes(pMgmt) != 0) {
     dError("failed to open vnode since %s", terrstr());
     return -1;
   }
+  dmReportStartup(pDnode, "vnode-vnodes", "initialized");
 
   code = 0;
 
@@ -351,19 +356,9 @@ void vmSetMgmtFp(SMgmtWrapper *pWrapper) {
 
 void vmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo) {
   SVnodesMgmt *pMgmt = pWrapper->pMgmt;
-  SVnodesStat *pStat = &pMgmt->state;
-  SArray      *pLoads = taosArrayInit(pMgmt->state.totalVnodes, sizeof(SVnodeLoad));
 
-  int32_t totalVnodes = 0;
-  int32_t masterNum = 0;
-  int64_t numOfSelectReqs = 0;
-  int64_t numOfInsertReqs = 0;
-  int64_t numOfInsertSuccessReqs = 0;
-  int64_t numOfBatchInsertReqs = 0;
-  int64_t numOfBatchInsertSuccessReqs = 0;
-
-  pInfo->pVloads = pLoads;
-  if (pLoads == NULL) return;
+  pInfo->pVloads = taosArrayInit(pMgmt->state.totalVnodes, sizeof(SVnodeLoad));
+  if (pInfo->pVloads == NULL) return;
 
   taosRLockLatch(&pMgmt->latch);
 
@@ -375,28 +370,9 @@ void vmGetVnodeLoads(SMgmtWrapper *pWrapper, SMonVloadInfo *pInfo) {
     SVnodeObj *pVnode = *ppVnode;
     SVnodeLoad vload = {0};
     vnodeGetLoad(pVnode->pImpl, &vload);
-    taosArrayPush(pLoads, &vload);
-
-    numOfSelectReqs += vload.numOfSelectReqs;
-    numOfInsertReqs += vload.numOfInsertReqs;
-    numOfInsertSuccessReqs += vload.numOfInsertSuccessReqs;
-    numOfBatchInsertReqs += vload.numOfBatchInsertReqs;
-    numOfBatchInsertSuccessReqs += vload.numOfBatchInsertSuccessReqs;
-    totalVnodes++;
-    if (vload.role == TAOS_SYNC_STATE_LEADER) masterNum++;
-
+    taosArrayPush(pInfo->pVloads, &vload);
     pIter = taosHashIterate(pMgmt->hash, pIter);
   }
 
   taosRUnLockLatch(&pMgmt->latch);
-
-  taosWLockLatch(&pMgmt->latch);
-  pStat->totalVnodes = totalVnodes;
-  pStat->masterNum = masterNum;
-  pStat->numOfSelectReqs = numOfSelectReqs;
-  pStat->numOfInsertReqs = numOfInsertReqs;
-  pStat->numOfInsertSuccessReqs = numOfInsertSuccessReqs;
-  pStat->numOfBatchInsertReqs = numOfBatchInsertReqs;
-  pStat->numOfBatchInsertSuccessReqs = numOfBatchInsertSuccessReqs;
-  taosWUnLockLatch(&pMgmt->latch);
 }
\ No newline at end of file

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

@@ -42,18 +42,9 @@ static void vmProcessMgmtQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
     case TDMT_DND_CREATE_VNODE:
       code = vmProcessCreateVnodeReq(pMgmt, pMsg);
       break;
-    case TDMT_DND_ALTER_VNODE:
-      code = vmProcessAlterVnodeReq(pMgmt, pMsg);
-      break;
     case TDMT_DND_DROP_VNODE:
       code = vmProcessDropVnodeReq(pMgmt, pMsg);
       break;
-    case TDMT_DND_SYNC_VNODE:
-      code = vmProcessSyncVnodeReq(pMgmt, pMsg);
-      break;
-    case TDMT_DND_COMPACT_VNODE:
-      code = vmProcessCompactVnodeReq(pMgmt, pMsg);
-      break;
     default:
       terrno = TSDB_CODE_MSG_NOT_PROCESSED;
       dError("msg:%p, not processed in vnode-mgmt queue", pMsg);

source/dnode/mgmt/test/vnode/vnode.cpp

@@ -47,7 +47,7 @@ TEST_F(DndTestVnode, 01_Create_Vnode) {
     createReq.precision = 0;
     createReq.compression = 2;
     createReq.replica = 1;
-    createReq.quorum = 1;
+    createReq.strict = 1;
     createReq.update = 0;
     createReq.cacheLastRow = 0;
     createReq.selfIndex = 0;
@@ -94,7 +94,7 @@ TEST_F(DndTestVnode, 02_Alter_Vnode) {
     alterReq.precision = 0;
     alterReq.compression = 2;
     alterReq.replica = 1;
-    alterReq.quorum = 1;
+    alterReq.strict = 1;
     alterReq.update = 0;
     alterReq.cacheLastRow = 0;
     alterReq.selfIndex = 0;
@@ -108,7 +108,7 @@ TEST_F(DndTestVnode, 02_Alter_Vnode) {
     void*   pReq = rpcMallocCont(contLen);
     tSerializeSCreateVnodeReq(pReq, contLen, &alterReq);
 
-    SRpcMsg* pRsp = test.SendReq(TDMT_DND_ALTER_VNODE, pReq, contLen);
+    SRpcMsg* pRsp = test.SendReq(TDMT_VND_ALTER_VNODE, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
   }

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

@@ -33,7 +33,7 @@ int32_t mndCheckNodeAuth(SUserObj *pOperUser);
 int32_t mndCheckFuncAuth(SUserObj *pOperUser);
 
 int32_t mndCheckCreateDbAuth(SUserObj *pOperUser);
-int32_t mndCheckAlterDropCompactSyncDbAuth(SUserObj *pOperUser, SDbObj *pDb);
+int32_t mndCheckAlterDropCompactDbAuth(SUserObj *pOperUser, SDbObj *pDb);
 int32_t mndCheckUseDbAuth(SUserObj *pOperUser, SDbObj *pDb);
 
 int32_t mndCheckWriteAuth(SUserObj *pOperUser, SDbObj *pDb);

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

@@ -27,9 +27,10 @@ void    mndCleanupDb(SMnode *pMnode);
 SDbObj *mndAcquireDb(SMnode *pMnode, const char *db);
 void    mndReleaseDb(SMnode *pMnode, SDbObj *pDb);
 int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen);
-char   *mndGetDbStr(char *src);
 int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUseDbReq *pReq);
 
+const char *mndGetDbStr(const char *src);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -265,11 +265,12 @@ typedef struct {
   int8_t  precision;
   int8_t  compression;
   int8_t  replications;
-  int8_t  quorum;
+  int8_t  strict;
   int8_t  update;
   int8_t  cacheLastRow;
   int8_t  streamMode;
   int8_t  singleSTable;
+  int8_t  hashMethod;  // default is 1
   int32_t numOfRetensions;
   SArray* pRetensions;
 } SDbCfg;
@@ -283,7 +284,6 @@ typedef struct {
   int64_t  uid;
   int32_t  cfgVersion;
   int32_t  vgVersion;
-  int8_t   hashMethod;  // default is 1
   SDbCfg   cfg;
   SRWLatch lock;
 } SDbObj;
@@ -355,10 +355,14 @@ typedef struct {
   int32_t  numOfTags;
   int32_t  numOfSmas;
   int32_t  commentLen;
+  int32_t  ast1Len;
+  int32_t  ast2Len;
   SSchema* pColumns;
   SSchema* pTags;
   SSchema* pSmas;
   char*    comment;
+  char*    pAst1;
+  char*    pAst2;
   SRWLatch lock;
 } SStbObj;
 

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

@@ -47,21 +47,6 @@ typedef int32_t (*MndInitFp)(SMnode *pMnode);
 typedef void (*MndCleanupFp)(SMnode *pMnode);
 typedef int32_t (*ShowRetrieveFp)(SNodeMsg *pMsg, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows);
 typedef void (*ShowFreeIterFp)(SMnode *pMnode, void *pIter);
-
-typedef struct SMnodeLoad {
-  int64_t numOfDnode;
-  int64_t numOfMnode;
-  int64_t numOfVgroup;
-  int64_t numOfDatabase;
-  int64_t numOfSuperTable;
-  int64_t numOfChildTable;
-  int64_t numOfNormalTable;
-  int64_t numOfColumn;
-  int64_t totalPoints;
-  int64_t totalStorage;
-  int64_t compStorage;
-} SMnodeLoad;
-
 typedef struct SQWorkerMgmt SQHandle;
 
 typedef struct {
@@ -129,7 +114,6 @@ struct SMnode {
 
 void    mndSetMsgHandle(SMnode *pMnode, tmsg_t msgType, MndMsgFp fp);
 int64_t mndGenerateUid(char *name, int32_t len);
-void    mndGetLoad(SMnode *pMnode, SMnodeLoad *pLoad);
 
 #ifdef __cplusplus
 }

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

@@ -29,7 +29,6 @@ void        mndReleaseMnode(SMnode *pMnode, SMnodeObj *pObj);
 bool       mndIsMnode(SMnode *pMnode, int32_t dnodeId);
 void       mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet);
 void       mndUpdateMnodeRole(SMnode *pMnode);
-const char *mndGetRoleStr(int32_t role);
 
 #ifdef __cplusplus
 }

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

@@ -146,7 +146,7 @@ int32_t mndCheckFuncAuth(SUserObj *pOperUser) {
 
 int32_t mndCheckCreateDbAuth(SUserObj *pOperUser) { return 0; }
 
-int32_t mndCheckAlterDropCompactSyncDbAuth(SUserObj *pOperUser, SDbObj *pDb) {
+int32_t mndCheckAlterDropCompactDbAuth(SUserObj *pOperUser, SDbObj *pDb) {
   if (pOperUser->superUser || strcmp(pOperUser->user, pDb->createUser) == 0) {
     return 0;
   }

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

@@ -326,7 +326,7 @@ static int32_t mndProcessStatusReq(SNodeMsg *pReq) {
 
     SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVload->vgId);
     if (pVgroup != NULL) {
-      if (pVload->role == TAOS_SYNC_STATE_LEADER) {
+      if (pVload->syncState == TAOS_SYNC_STATE_LEADER) {
         pVgroup->numOfTables = pVload->numOfTables;
         pVgroup->numOfTimeSeries = pVload->numOfTimeSeries;
         pVgroup->totalStorage = pVload->totalStorage;
@@ -335,10 +335,10 @@ static int32_t mndProcessStatusReq(SNodeMsg *pReq) {
       }
       bool roleChanged = false;
       for (int32_t vg = 0; vg < pVgroup->replica; ++vg) {
-        if (pVgroup->vnodeGid[vg].role != pVload->role) {
+        if (pVgroup->vnodeGid[vg].role != pVload->syncState) {
           roleChanged = true;
         }
-        pVgroup->vnodeGid[vg].role = pVload->role;
+        pVgroup->vnodeGid[vg].role = pVload->syncState;
       }
       if (roleChanged) {
         // notify scheduler role has changed

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

@@ -75,7 +75,7 @@ static const SInfosTableSchema userDBSchema[] = {
     {.name = "vgroups", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT},
     {.name = "ntables", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT},
     {.name = "replica", .bytes = 2, .type = TSDB_DATA_TYPE_TINYINT},
-    {.name = "quorum", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT},
+    {.name = "strict", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "days", .bytes = 4, .type = TSDB_DATA_TYPE_INT},
     {.name = "keep", .bytes = 24 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "cache", .bytes = 4, .type = TSDB_DATA_TYPE_INT},

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

@@ -75,19 +75,6 @@ void mndReleaseMnode(SMnode *pMnode, SMnodeObj *pObj) {
   sdbRelease(pMnode->pSdb, pObj);
 }
 
-const char *mndGetRoleStr(int32_t showType) {
-  switch (showType) {
-    case TAOS_SYNC_STATE_FOLLOWER:
-      return "FOLLOWER";
-    case TAOS_SYNC_STATE_CANDIDATE:
-      return "CANDIDATE";
-    case TAOS_SYNC_STATE_LEADER:
-      return "LEADER";
-    default:
-      return "ERROR";
-  }
-}
-
 void mndUpdateMnodeRole(SMnode *pMnode) {
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
@@ -637,7 +624,7 @@ static int32_t mndRetrieveMnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *p
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, numOfRows, b1, false);
 
-    const char *roles = mndGetRoleStr(pObj->role);
+    const char *roles = syncStr(pObj->role);
     char       *b2 = taosMemoryCalloc(1, strlen(roles) + VARSTR_HEADER_SIZE);
     STR_WITH_MAXSIZE_TO_VARSTR(b2, roles, pShow->bytes[cols]);
 

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

@@ -72,7 +72,7 @@ SSdbRaw *mndStbActionEncode(SStbObj *pStb) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int32_t size = sizeof(SStbObj) + (pStb->numOfColumns + pStb->numOfTags + pStb->numOfSmas) * sizeof(SSchema) +
-                 TSDB_STB_RESERVE_SIZE;
+                 + pStb->commentLen + pStb->ast1Len + pStb->ast2Len + TSDB_STB_RESERVE_SIZE;
   SSdbRaw *pRaw = sdbAllocRaw(SDB_STB, TSDB_STB_VER_NUMBER, size);
   if (pRaw == NULL) goto _OVER;
 
@@ -93,6 +93,8 @@ SSdbRaw *mndStbActionEncode(SStbObj *pStb) {
   SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags, _OVER)
   SDB_SET_INT32(pRaw, dataPos, pStb->numOfSmas, _OVER)
   SDB_SET_INT32(pRaw, dataPos, pStb->commentLen, _OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->ast1Len, _OVER)
+  SDB_SET_INT32(pRaw, dataPos, pStb->ast2Len, _OVER)
 
   for (int32_t i = 0; i < pStb->numOfColumns; ++i) {
     SSchema *pSchema = &pStb->pColumns[i];
@@ -121,6 +123,12 @@ SSdbRaw *mndStbActionEncode(SStbObj *pStb) {
   if (pStb->commentLen > 0) {
     SDB_SET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, _OVER)
   }
+  if (pStb->ast1Len > 0) {
+    SDB_SET_BINARY(pRaw, dataPos, pStb->pAst1, pStb->ast1Len, _OVER)
+  }
+  if (pStb->ast2Len > 0) {
+    SDB_SET_BINARY(pRaw, dataPos, pStb->pAst2, pStb->ast2Len, _OVER)
+  }
   SDB_SET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, _OVER)
   SDB_SET_DATALEN(pRaw, dataPos, _OVER)
 
@@ -173,6 +181,8 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT32(pRaw, dataPos, &pStb->numOfTags, _OVER)
   SDB_GET_INT32(pRaw, dataPos, &pStb->numOfSmas, _OVER)
   SDB_GET_INT32(pRaw, dataPos, &pStb->commentLen, _OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->ast1Len, _OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pStb->ast2Len, _OVER)
 
   pStb->pColumns = taosMemoryCalloc(pStb->numOfColumns, sizeof(SSchema));
   pStb->pTags = taosMemoryCalloc(pStb->numOfTags, sizeof(SSchema));
@@ -210,6 +220,16 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
     if (pStb->comment == NULL) goto _OVER;
     SDB_GET_BINARY(pRaw, dataPos, pStb->comment, pStb->commentLen, _OVER)
   }
+  if (pStb->ast1Len > 0) {
+    pStb->pAst1 = taosMemoryCalloc(pStb->ast1Len, 1);
+    if (pStb->pAst1 == NULL) goto _OVER;
+    SDB_GET_BINARY(pRaw, dataPos, pStb->pAst1, pStb->ast1Len, _OVER)
+  }
+  if (pStb->ast2Len > 0) {
+    pStb->pAst2 = taosMemoryCalloc(pStb->ast2Len, 1);
+    if (pStb->pAst2 == NULL) goto _OVER;
+    SDB_GET_BINARY(pRaw, dataPos, pStb->pAst2, pStb->ast2Len, _OVER)
+  }
   SDB_GET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, _OVER)
 
   terrno = 0;
@@ -238,6 +258,8 @@ static int32_t mndStbActionDelete(SSdb *pSdb, SStbObj *pStb) {
   taosMemoryFreeClear(pStb->pColumns);
   taosMemoryFreeClear(pStb->pTags);
   taosMemoryFreeClear(pStb->comment);
+  taosMemoryFreeClear(pStb->pAst1);
+  taosMemoryFreeClear(pStb->pAst2);
   return 0;
 }
 
@@ -294,6 +316,30 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOld, SStbObj *pNew) {
     }
   }
 
+  if (pOld->ast1Len < pNew->ast1Len) {
+    void *pAst1 = taosMemoryMalloc(pNew->ast1Len);
+    if (pAst1 != NULL) {
+      taosMemoryFree(pOld->pAst1);
+      pOld->pAst1 = pAst1;
+    } else {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      mTrace("stb:%s, failed to perform update action since %s", pOld->name, terrstr());
+      taosWUnLockLatch(&pOld->lock);
+    }
+  }
+
+  if (pOld->ast2Len < pNew->ast2Len) {
+    void *pAst2 = taosMemoryMalloc(pNew->ast2Len);
+    if (pAst2 != NULL) {
+      taosMemoryFree(pOld->pAst2);
+      pOld->pAst2 = pAst2;
+    } else {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      mTrace("stb:%s, failed to perform update action since %s", pOld->name, terrstr());
+      taosWUnLockLatch(&pOld->lock);
+    }
+  }
+
   pOld->updateTime = pNew->updateTime;
   pOld->version = pNew->version;
   pOld->nextColId = pNew->nextColId;
@@ -304,6 +350,12 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOld, SStbObj *pNew) {
   if (pNew->commentLen != 0) {
     memcpy(pOld->comment, pNew->comment, TSDB_STB_COMMENT_LEN);
   }
+  if (pNew->ast1Len != 0) {
+    memcpy(pOld->pAst1, pNew->pAst1, pNew->ast1Len);
+  }
+  if (pNew->ast2Len != 0) {
+    memcpy(pOld->pAst2, pNew->pAst2, pNew->ast2Len);
+  }
   taosWUnLockLatch(&pOld->lock);
   return 0;
 }
@@ -646,6 +698,26 @@ static int32_t mndCreateStb(SMnode *pMnode, SNodeMsg *pReq, SMCreateStbReq *pCre
     memcpy(stbObj.comment, pCreate->comment, stbObj.commentLen);
   }
 
+  stbObj.ast1Len = pCreate->ast1Len;
+  if (stbObj.ast1Len > 0) {
+    stbObj.pAst1 = taosMemoryCalloc(stbObj.ast1Len, 1);
+    if (stbObj.pAst1 == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+    memcpy(stbObj.pAst1, pCreate->pAst1, stbObj.ast1Len);
+  }
+
+  stbObj.ast2Len = pCreate->ast2Len;
+  if (stbObj.ast2Len > 0) {
+    stbObj.pAst2 = taosMemoryCalloc(stbObj.ast2Len, 1);
+    if (stbObj.pAst2 == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return -1;
+    }
+    memcpy(stbObj.pAst2, pCreate->pAst2, stbObj.ast2Len);
+  }
+
   stbObj.pColumns = taosMemoryMalloc(stbObj.numOfColumns * sizeof(SSchema));
   stbObj.pTags = taosMemoryMalloc(stbObj.numOfTags * sizeof(SSchema));
   stbObj.pSmas = taosMemoryMalloc(stbObj.numOfSmas * sizeof(SSchema));

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

@@ -24,20 +24,60 @@
 #define TELEMETRY_SERVER "telemetry.taosdata.com"
 #define TELEMETRY_PORT   80
 
+typedef struct {
+  int64_t numOfDnode;
+  int64_t numOfMnode;
+  int64_t numOfVgroup;
+  int64_t numOfDatabase;
+  int64_t numOfSuperTable;
+  int64_t numOfChildTable;
+  int64_t numOfNormalTable;
+  int64_t numOfColumn;
+  int64_t totalPoints;
+  int64_t totalStorage;
+  int64_t compStorage;
+} SMnodeStat;
+
+static void mndGetStat(SMnode* pMnode, SMnodeStat* pStat) {
+  memset(pStat, 0, sizeof(SMnodeStat));
+
+  SSdb* pSdb = pMnode->pSdb;
+  pStat->numOfDnode = sdbGetSize(pSdb, SDB_DNODE);
+  pStat->numOfMnode = sdbGetSize(pSdb, SDB_MNODE);
+  pStat->numOfVgroup = sdbGetSize(pSdb, SDB_VGROUP);
+  pStat->numOfDatabase = sdbGetSize(pSdb, SDB_DB);
+  pStat->numOfSuperTable = sdbGetSize(pSdb, SDB_STB);
+
+  void* pIter = NULL;
+  while (1) {
+    SVgObj* pVgroup = NULL;
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void**)&pVgroup);
+    if (pIter == NULL) break;
+
+    pStat->numOfChildTable += pVgroup->numOfTables;
+    pStat->numOfColumn += pVgroup->numOfTimeSeries;
+    pStat->totalPoints += pVgroup->pointsWritten;
+    pStat->totalStorage += pVgroup->totalStorage;
+    pStat->compStorage += pVgroup->compStorage;
+
+    sdbRelease(pSdb, pVgroup);
+  }
+}
+
 static void mndBuildRuntimeInfo(SMnode* pMnode, SJson* pJson) {
-  SMnodeLoad load = {0};
-  mndGetLoad(pMnode, &load);
-
-  tjsonAddDoubleToObject(pJson, "numOfDnode", load.numOfDnode);
-  tjsonAddDoubleToObject(pJson, "numOfMnode", load.numOfMnode);
-  tjsonAddDoubleToObject(pJson, "numOfVgroup", load.numOfVgroup);
-  tjsonAddDoubleToObject(pJson, "numOfDatabase", load.numOfDatabase);
-  tjsonAddDoubleToObject(pJson, "numOfSuperTable", load.numOfSuperTable);
-  tjsonAddDoubleToObject(pJson, "numOfChildTable", load.numOfChildTable);
-  tjsonAddDoubleToObject(pJson, "numOfColumn", load.numOfColumn);
-  tjsonAddDoubleToObject(pJson, "numOfPoint", load.totalPoints);
-  tjsonAddDoubleToObject(pJson, "totalStorage", load.totalStorage);
-  tjsonAddDoubleToObject(pJson, "compStorage", load.compStorage);
+  SMnodeStat mstat = {0};
+  mndGetStat(pMnode, &mstat);
+
+  tjsonAddDoubleToObject(pJson, "numOfDnode", mstat.numOfDnode);
+  tjsonAddDoubleToObject(pJson, "numOfMnode", mstat.numOfMnode);
+  tjsonAddDoubleToObject(pJson, "numOfVgroup", mstat.numOfVgroup);
+  tjsonAddDoubleToObject(pJson, "numOfDatabase", mstat.numOfDatabase);
+  tjsonAddDoubleToObject(pJson, "numOfSuperTable", mstat.numOfSuperTable);
+  tjsonAddDoubleToObject(pJson, "numOfChildTable", mstat.numOfChildTable);
+  tjsonAddDoubleToObject(pJson, "numOfColumn", mstat.numOfColumn);
+  tjsonAddDoubleToObject(pJson, "numOfPoint", mstat.totalPoints);
+  tjsonAddDoubleToObject(pJson, "totalStorage", mstat.totalStorage);
+  tjsonAddDoubleToObject(pJson, "compStorage", mstat.compStorage);
 }
 
 static char* mndBuildTelemetryReport(SMnode* pMnode) {

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

@@ -32,7 +32,6 @@ static int32_t  mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOld, SVgObj *pNew);
 static int32_t mndProcessCreateVnodeRsp(SNodeMsg *pRsp);
 static int32_t mndProcessAlterVnodeRsp(SNodeMsg *pRsp);
 static int32_t mndProcessDropVnodeRsp(SNodeMsg *pRsp);
-static int32_t mndProcessSyncVnodeRsp(SNodeMsg *pRsp);
 static int32_t mndProcessCompactVnodeRsp(SNodeMsg *pRsp);
 
 static int32_t mndRetrieveVgroups(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rows);
@@ -50,10 +49,9 @@ int32_t mndInitVgroup(SMnode *pMnode) {
                      .deleteFp = (SdbDeleteFp)mndVgroupActionUpdate};
 
   mndSetMsgHandle(pMnode, TDMT_DND_CREATE_VNODE_RSP, mndProcessCreateVnodeRsp);
-  mndSetMsgHandle(pMnode, TDMT_DND_ALTER_VNODE_RSP, mndProcessAlterVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_VNODE_RSP, mndProcessAlterVnodeRsp);
   mndSetMsgHandle(pMnode, TDMT_DND_DROP_VNODE_RSP, mndProcessDropVnodeRsp);
-  mndSetMsgHandle(pMnode, TDMT_DND_SYNC_VNODE_RSP, mndProcessSyncVnodeRsp);
-  mndSetMsgHandle(pMnode, TDMT_DND_COMPACT_VNODE_RSP, mndProcessCompactVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_COMPACT_VNODE_RSP, mndProcessCompactVnodeRsp);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndRetrieveVgroups);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndCancelGetNextVgroup);
@@ -205,7 +203,7 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg
   createReq.walLevel = pDb->cfg.walLevel;
   createReq.precision = pDb->cfg.precision;
   createReq.compression = pDb->cfg.compression;
-  createReq.quorum = pDb->cfg.quorum;
+  createReq.strict = pDb->cfg.strict;
   createReq.update = pDb->cfg.update;
   createReq.cacheLastRow = pDb->cfg.cacheLastRow;
   createReq.replica = pVgroup->replica;
@@ -213,7 +211,7 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg
   createReq.streamMode = pVgroup->streamMode;
   createReq.hashBegin = pVgroup->hashBegin;
   createReq.hashEnd = pVgroup->hashEnd;
-  createReq.hashMethod = pDb->hashMethod;
+  createReq.hashMethod = pDb->cfg.hashMethod;
   createReq.numOfRetensions = pDb->cfg.numOfRetensions;
   createReq.pRetensions = pDb->cfg.pRetensions;
 
@@ -465,8 +463,6 @@ static int32_t mndProcessDropVnodeRsp(SNodeMsg *pRsp) {
   return 0;
 }
 
-static int32_t mndProcessSyncVnodeRsp(SNodeMsg *pRsp) { return 0; }
-
 static int32_t mndProcessCompactVnodeRsp(SNodeMsg *pRsp) { return 0; }
 
 static bool mndGetVgroupMaxReplicaFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {
@@ -545,7 +541,7 @@ static int32_t mndRetrieveVgroups(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock*
         colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->vnodeGid[i].dnodeId, false);
 
         char        buf1[20] = {0};
-        const char *role = mndGetRoleStr(pVgroup->vnodeGid[i].role);
+        const char *role = syncStr(pVgroup->vnodeGid[i].role);
         STR_WITH_MAXSIZE_TO_VARSTR(buf1, role, pShow->bytes[cols]);
 
         pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
@@ -636,7 +632,7 @@ static int32_t mndRetrieveVnodes(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* p
       colDataAppend(pColInfo, numOfRows, (const char *)&val, false);
 
       char buf[20] = {0};
-      STR_TO_VARSTR(buf, mndGetRoleStr(pVgid->role));
+      STR_TO_VARSTR(buf, syncStr(pVgid->role));
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       colDataAppend(pColInfo, numOfRows, (const char *)buf, false);
 

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

@@ -262,6 +262,7 @@ static int32_t mndExecSteps(SMnode *pMnode) {
       return -1;
     } else {
       mDebug("%s is initialized", pStep->name);
+      tmsgReportStartup(pStep->name, "initialized");
     }
   }
 
@@ -413,31 +414,6 @@ int64_t mndGenerateUid(char *name, int32_t len) {
   } while (true);
 }
 
-void mndGetLoad(SMnode *pMnode, SMnodeLoad *pLoad) {
-  memset(pLoad, 0, sizeof(SMnodeLoad));
-
-  SSdb *pSdb = pMnode->pSdb;
-  pLoad->numOfDnode = sdbGetSize(pSdb, SDB_DNODE);
-  pLoad->numOfMnode = sdbGetSize(pSdb, SDB_MNODE);
-  pLoad->numOfVgroup = sdbGetSize(pSdb, SDB_VGROUP);
-  pLoad->numOfDatabase = sdbGetSize(pSdb, SDB_DB);
-  pLoad->numOfSuperTable = sdbGetSize(pSdb, SDB_STB);
-
-  void *pIter = NULL;
-  while (1) {
-    SVgObj *pVgroup = NULL;
-    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
-    if (pIter == NULL) break;
-
-    pLoad->numOfChildTable += pVgroup->numOfTables;
-    pLoad->numOfColumn += pVgroup->numOfTimeSeries;
-    pLoad->totalPoints += pVgroup->pointsWritten;
-    pLoad->totalStorage += pVgroup->totalStorage;
-    pLoad->compStorage += pVgroup->compStorage;
-
-    sdbRelease(pSdb, pVgroup);
-  }
-}
 
 int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgroupInfo *pVgroupInfo,
                           SMonGrantInfo *pGrantInfo) {
@@ -485,7 +461,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
     SMonMnodeDesc desc = {0};
     desc.mnode_id = pObj->id;
     tstrncpy(desc.mnode_ep, pObj->pDnode->ep, sizeof(desc.mnode_ep));
-    tstrncpy(desc.role, mndGetRoleStr(pObj->role), sizeof(desc.role));
+    tstrncpy(desc.role, syncStr(pObj->role), sizeof(desc.role));
     taosArrayPush(pClusterInfo->mnodes, &desc);
     sdbRelease(pSdb, pObj);
 
@@ -519,7 +495,7 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
       SVnodeGid     *pVgid = &pVgroup->vnodeGid[i];
       SMonVnodeDesc *pVnDesc = &desc.vnodes[i];
       pVnDesc->dnode_id = pVgid->dnodeId;
-      tstrncpy(pVnDesc->vnode_role, mndGetRoleStr(pVgid->role), sizeof(pVnDesc->vnode_role));
+      tstrncpy(pVnDesc->vnode_role, syncStr(pVgid->role), sizeof(pVnDesc->vnode_role));
       if (pVgid->role == TAOS_SYNC_STATE_LEADER) {
         tstrncpy(desc.status, "ready", sizeof(desc.status));
         pClusterInfo->vgroups_alive++;
@@ -544,3 +520,8 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
 
   return 0;
 }
+
+int32_t mndGetLoad(SMnode *pMnode, SMnodeLoad *pLoad) {
+  pLoad->syncState = pMnode->syncMgmt.state;
+  return 0;
+}
\ No newline at end of file

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

@@ -45,12 +45,12 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
     createReq.maxRows = 4096;
     createReq.commitTime = 3600;
     createReq.fsyncPeriod = 3000;
-    createReq.ttl = 0;
+    createReq.ttl = 1;
     createReq.walLevel = 1;
     createReq.precision = 0;
     createReq.compression = 2;
     createReq.replications = 1;
-    createReq.quorum = 1;
+    createReq.strict = 1;
     createReq.update = 0;
     createReq.cacheLastRow = 0;
     createReq.ignoreExist = 1;
@@ -82,7 +82,7 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
     alterdbReq.daysToKeep2 = 500;
     alterdbReq.fsyncPeriod = 4000;
     alterdbReq.walLevel = 2;
-    alterdbReq.quorum = 2;
+    alterdbReq.strict = 2;
     alterdbReq.cacheLastRow = 1;
 
     int32_t contLen = tSerializeSAlterDbReq(NULL, 0, &alterdbReq);
@@ -139,12 +139,12 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
     createReq.maxRows = 4096;
     createReq.commitTime = 3600;
     createReq.fsyncPeriod = 3000;
-    createReq.ttl = 0;
+    createReq.ttl = 1;
     createReq.walLevel = 1;
     createReq.precision = 0;
     createReq.compression = 2;
     createReq.replications = 1;
-    createReq.quorum = 1;
+    createReq.strict = 1;
     createReq.update = 0;
     createReq.cacheLastRow = 0;
     createReq.ignoreExist = 1;

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

@@ -54,9 +54,10 @@ void* MndTestSma::BuildCreateDbReq(const char* dbname, int32_t* pContLen) {
   createReq.precision = 0;
   createReq.compression = 2;
   createReq.replications = 1;
-  createReq.quorum = 1;
+  createReq.strict = 1;
   createReq.update = 0;
   createReq.cacheLastRow = 0;
+  createReq.ttl = 1;
   createReq.ignoreExist = 1;
 
   int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);

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

@@ -55,9 +55,10 @@ void* MndTestStb::BuildCreateDbReq(const char* dbname, int32_t* pContLen) {
   createReq.precision = 0;
   createReq.compression = 2;
   createReq.replications = 1;
-  createReq.quorum = 1;
+  createReq.strict = 1;
   createReq.update = 0;
   createReq.cacheLastRow = 0;
+  createReq.ttl = 1;
   createReq.ignoreExist = 1;
 
   int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);

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

@@ -47,9 +47,10 @@ void* MndTestTopic::BuildCreateDbReq(const char* dbname, int32_t* pContLen) {
   createReq.precision = 0;
   createReq.compression = 2;
   createReq.replications = 1;
-  createReq.quorum = 1;
+  createReq.strict = 1;
   createReq.update = 0;
   createReq.cacheLastRow = 0;
+  createReq.ttl = 1;
   createReq.ignoreExist = 1;
 
   int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);

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

@@ -300,9 +300,10 @@ TEST_F(MndTestUser, 03_Alter_User) {
     createReq.precision = 0;
     createReq.compression = 2;
     createReq.replications = 1;
-    createReq.quorum = 1;
+    createReq.strict = 1;
     createReq.update = 0;
     createReq.cacheLastRow = 0;
+    createReq.ttl = 1;
     createReq.ignoreExist = 1;
 
     int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);

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

@@ -601,26 +601,26 @@ static int32_t tsdbCheckAndSetDefaultCfg(STsdbCfg *pCfg) {
 
   // Check minRowsPerFileBlock and maxRowsPerFileBlock
   if (pCfg->minRowsPerFileBlock == -1) {
-    pCfg->minRowsPerFileBlock = TSDB_DEFAULT_MIN_ROW_FBLOCK;
+    pCfg->minRowsPerFileBlock = TSDB_DEFAULT_MINROWS_FBLOCK;
   } else {
-    if (pCfg->minRowsPerFileBlock < TSDB_MIN_MIN_ROW_FBLOCK || pCfg->minRowsPerFileBlock > TSDB_MAX_MIN_ROW_FBLOCK) {
+    if (pCfg->minRowsPerFileBlock < TSDB_MIN_MINROWS_FBLOCK || pCfg->minRowsPerFileBlock > TSDB_MAX_MINROWS_FBLOCK) {
       tsdbError(
-          "vgId:%d invalid minRowsPerFileBlock configuration! minRowsPerFileBlock %d TSDB_MIN_MIN_ROW_FBLOCK %d "
-          "TSDB_MAX_MIN_ROW_FBLOCK %d",
-          pCfg->tsdbId, pCfg->minRowsPerFileBlock, TSDB_MIN_MIN_ROW_FBLOCK, TSDB_MAX_MIN_ROW_FBLOCK);
+          "vgId:%d invalid minRowsPerFileBlock configuration! minRowsPerFileBlock %d TSDB_MIN_MINROWS_FBLOCK %d "
+          "TSDB_MAX_MINROWS_FBLOCK %d",
+          pCfg->tsdbId, pCfg->minRowsPerFileBlock, TSDB_MIN_MINROWS_FBLOCK, TSDB_MAX_MINROWS_FBLOCK);
       terrno = TSDB_CODE_TDB_INVALID_CONFIG;
       return -1;
     }
   }
 
   if (pCfg->maxRowsPerFileBlock == -1) {
-    pCfg->maxRowsPerFileBlock = TSDB_DEFAULT_MAX_ROW_FBLOCK;
+    pCfg->maxRowsPerFileBlock = TSDB_DEFAULT_MAXROWS_FBLOCK;
   } else {
-    if (pCfg->maxRowsPerFileBlock < TSDB_MIN_MAX_ROW_FBLOCK || pCfg->maxRowsPerFileBlock > TSDB_MAX_MAX_ROW_FBLOCK) {
+    if (pCfg->maxRowsPerFileBlock < TSDB_MIN_MAXROWS_FBLOCK || pCfg->maxRowsPerFileBlock > TSDB_MAX_MAXROWS_FBLOCK) {
       tsdbError(
-          "vgId:%d invalid maxRowsPerFileBlock configuration! maxRowsPerFileBlock %d TSDB_MIN_MAX_ROW_FBLOCK %d "
-          "TSDB_MAX_MAX_ROW_FBLOCK %d",
-          pCfg->tsdbId, pCfg->maxRowsPerFileBlock, TSDB_MIN_MIN_ROW_FBLOCK, TSDB_MAX_MIN_ROW_FBLOCK);
+          "vgId:%d invalid maxRowsPerFileBlock configuration! maxRowsPerFileBlock %d TSDB_MIN_MAXROWS_FBLOCK %d "
+          "TSDB_MAX_MAXROWS_FBLOCK %d",
+          pCfg->tsdbId, pCfg->maxRowsPerFileBlock, TSDB_MIN_MINROWS_FBLOCK, TSDB_MAX_MINROWS_FBLOCK);
       terrno = TSDB_CODE_TDB_INVALID_CONFIG;
       return -1;
     }

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

@@ -1567,12 +1567,19 @@ static void mergeTwoRowFromMem(STsdbReadHandle* pTsdbReadHandle, int32_t capacit
     if (isChosenRowDataRow) {
       colId = pSchema->columns[chosen_itr].colId;
       offset = pSchema->columns[chosen_itr].offset;
-      tdSTpRowGetVal(row, colId, pSchema->columns[chosen_itr].type, pSchema->flen, offset, chosen_itr, &sVal);
+      // TODO: use STSRowIter
+      tdSTpRowGetVal(row, colId, pSchema->columns[chosen_itr].type, pSchema->flen, offset, chosen_itr - 1, &sVal);
     } else {
-      SKvRowIdx* pColIdx = tdKvRowColIdxAt(row, chosen_itr);
+      // TODO: use STSRowIter
+      if (chosen_itr == 0) {
+        colId = PRIMARYKEY_TIMESTAMP_COL_ID;
+        tdSKvRowGetVal(row, PRIMARYKEY_TIMESTAMP_COL_ID, -1, -1, &sVal);
+      } else {
+        SKvRowIdx* pColIdx = tdKvRowColIdxAt(row, chosen_itr - 1);
         colId = pColIdx->colId;
         offset = pColIdx->offset;
-      tdSKvRowGetVal(row, colId, offset, chosen_itr, &sVal);
+        tdSKvRowGetVal(row, colId, offset, chosen_itr - 1, &sVal);
+      }
     }
 
     if (colId == pColInfo->info.colId) {

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

@@ -152,7 +152,7 @@ _exit:
 
 int32_t vnodeGetLoad(SVnode *pVnode, SVnodeLoad *pLoad) {
   pLoad->vgId = TD_VID(pVnode);
-  pLoad->role = TAOS_SYNC_STATE_LEADER;
+  pLoad->syncState = TAOS_SYNC_STATE_LEADER;
   pLoad->numOfTables = metaGetTbNum(pVnode->pMeta);
   pLoad->numOfTimeSeries = 400;
   pLoad->totalStorage = 300;

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

@@ -117,6 +117,8 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
       //   }
 
     } break;
+    case TDMT_VND_ALTER_VNODE:
+      break;
     default:
       ASSERT(0);
       break;

source/libs/catalog/test/catalogTests.cpp

@@ -108,9 +108,10 @@ void sendCreateDbMsg(void *shandle, SEpSet *pEpSet) {
   createReq.precision = 0;
   createReq.compression = 2;
   createReq.replications = 1;
-  createReq.quorum = 1;
+  createReq.strict = 1;
   createReq.update = 0;
   createReq.cacheLastRow = 0;
+  createReq.ttl = 1;
   createReq.ignoreExist = 1;
 
   int32_t contLen = tSerializeSCreateDbReq(NULL, 0, &createReq);

source/libs/executor/src/scanoperator.c

@@ -451,8 +451,8 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator, bool* newgroup) {
   STableBlockDistInfo tableBlockDist = {0};
   tableBlockDist.numOfTables = 1;  // TODO set the correct number of tables
 
-  int32_t numRowSteps = TSDB_DEFAULT_MAX_ROW_FBLOCK / TSDB_BLOCK_DIST_STEP_ROWS;
-  if (TSDB_DEFAULT_MAX_ROW_FBLOCK % TSDB_BLOCK_DIST_STEP_ROWS != 0) {
+  int32_t numRowSteps = TSDB_DEFAULT_MAXROWS_FBLOCK / TSDB_BLOCK_DIST_STEP_ROWS;
+  if (TSDB_DEFAULT_MAXROWS_FBLOCK % TSDB_BLOCK_DIST_STEP_ROWS != 0) {
     ++numRowSteps;
   }
 

source/libs/function/src/builtins.c

@@ -28,11 +28,15 @@ static int32_t buildFuncErrMsg(char* pErrBuf, int32_t len, int32_t errCode, cons
 }
 
 static int32_t invaildFuncParaNumErrMsg(char* pErrBuf, int32_t len, const char* pFuncName) {
-  return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_PARA_NUM, "Invalid number of arguments : %s", pFuncName);
+  return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_PARA_NUM, "Invalid number of parameters : %s", pFuncName);
 }
 
 static int32_t invaildFuncParaTypeErrMsg(char* pErrBuf, int32_t len, const char* pFuncName) {
-  return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_PARA_TYPE, "Inconsistent datatypes : %s", pFuncName);
+  return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_PARA_TYPE, "Invalid datatypes : %s", pFuncName);
+}
+
+static int32_t invaildFuncParaValueErrMsg(char* pErrBuf, int32_t len, const char* pFuncName) {
+  return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_PARA_VALUE, "Invalid parameter value : %s", pFuncName);
 }
 
 // There is only one parameter of numeric type, and the return type is parameter type
@@ -139,8 +143,9 @@ static int32_t translateTimePseudoColumn(SFunctionNode* pFunc, char* pErrBuf, in
 }
 
 static int32_t translateTimezone(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
-  // pseudo column do not need to check parameters
-  pFunc->node.resType = (SDataType){.bytes = TD_TIMEZONE_LEN, .type = TSDB_DATA_TYPE_BINARY};
+  SExprNode* pPara1 = (SExprNode*)nodesListGetNode(pFunc->pParameterList, 0);
+  pFunc->node.resType = (SDataType){.bytes = pPara1->resType.bytes, .type = pPara1->resType.type};
+  //pFunc->node.resType = (SDataType){.bytes = TD_TIMEZONE_LEN, .type = TSDB_DATA_TYPE_BINARY};
   return TSDB_CODE_SUCCESS;
 }
 
@@ -317,10 +322,15 @@ static int32_t translateCast(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
   uint8_t para1Type = ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->resType.type;
   // The function return type has been set during syntax parsing
   uint8_t para2Type = pFunc->node.resType.type;
-  if ((TSDB_DATA_TYPE_JSON == para1Type || TSDB_DATA_TYPE_BLOB == para1Type || TSDB_DATA_TYPE_MEDIUMBLOB == para1Type) ||
-      (TSDB_DATA_TYPE_JSON == para2Type || TSDB_DATA_TYPE_BLOB == para2Type || TSDB_DATA_TYPE_MEDIUMBLOB == para2Type)) {
+  if (para2Type != TSDB_DATA_TYPE_BIGINT && para2Type != TSDB_DATA_TYPE_UBIGINT &&
+      para2Type != TSDB_DATA_TYPE_VARCHAR && para2Type != TSDB_DATA_TYPE_NCHAR &&
+      para2Type != TSDB_DATA_TYPE_TIMESTAMP) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
+  int32_t para2Bytes = pFunc->node.resType.bytes;
+  if (para2Bytes <= 0) { //non-positive value or overflow
+    return invaildFuncParaValueErrMsg(pErrBuf, len, pFunc->functionName);
+  }
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/function/src/taggfunction.c

@@ -4034,8 +4034,8 @@ static void mergeTableBlockDist(SResultRowEntryInfo* pResInfo, const STableBlock
     pDist->maxRows = pSrc->maxRows;
     pDist->minRows = pSrc->minRows;
 
-    int32_t maxSteps = TSDB_MAX_MAX_ROW_FBLOCK/TSDB_BLOCK_DIST_STEP_ROWS;
-    if (TSDB_MAX_MAX_ROW_FBLOCK % TSDB_BLOCK_DIST_STEP_ROWS != 0) {
+    int32_t maxSteps = TSDB_MAX_MAXROWS_FBLOCK/TSDB_BLOCK_DIST_STEP_ROWS;
+    if (TSDB_MAX_MAXROWS_FBLOCK % TSDB_BLOCK_DIST_STEP_ROWS != 0) {
       ++maxSteps;
     }
     pDist->dataBlockInfos = taosArrayInit(maxSteps, sizeof(SFileBlockInfo));

source/libs/monitor/src/monMsg.c

@@ -473,7 +473,7 @@ int32_t tSerializeSMonVloadInfo(void *buf, int32_t bufLen, SMonVloadInfo *pInfo)
   for (int32_t i = 0; i < taosArrayGetSize(pInfo->pVloads); ++i) {
     SVnodeLoad *pLoad = taosArrayGet(pInfo->pVloads, i);
     if (tEncodeI32(&encoder, pLoad->vgId) < 0) return -1;
-    if (tEncodeI8(&encoder, pLoad->role) < 0) return -1;
+    if (tEncodeI32(&encoder, pLoad->syncState) < 0) return -1;
     if (tEncodeI64(&encoder, pLoad->numOfTables) < 0) return -1;
     if (tEncodeI64(&encoder, pLoad->numOfTimeSeries) < 0) return -1;
     if (tEncodeI64(&encoder, pLoad->totalStorage) < 0) return -1;
@@ -507,7 +507,7 @@ int32_t tDeserializeSMonVloadInfo(void *buf, int32_t bufLen, SMonVloadInfo *pInf
   for (int32_t i = 0; i < arraySize; ++i) {
     SVnodeLoad load = {0};
     if (tDecodeI32(&decoder, &load.vgId) < 0) return -1;
-    if (tDecodeI8(&decoder, &load.role) < 0) return -1;
+    if (tDecodeI32(&decoder, &load.syncState) < 0) return -1;
     if (tDecodeI64(&decoder, &load.numOfTables) < 0) return -1;
     if (tDecodeI64(&decoder, &load.numOfTimeSeries) < 0) return -1;
     if (tDecodeI64(&decoder, &load.totalStorage) < 0) return -1;
@@ -530,3 +530,30 @@ void tFreeSMonVloadInfo(SMonVloadInfo *pInfo) {
   taosArrayDestroy(pInfo->pVloads);
   pInfo->pVloads = NULL;
 }
+
+int32_t tSerializeSMonMloadInfo(void *buf, int32_t bufLen, SMonMloadInfo *pInfo) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI8(&encoder, pInfo->isMnode) < 0) return -1;
+  if (tEncodeI32(&encoder, pInfo->load.syncState) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSMonMloadInfo(void *buf, int32_t bufLen, SMonMloadInfo *pInfo) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI8(&decoder, &pInfo->isMnode) < 0) return -1;
+  if (tDecodeI32(&decoder, &pInfo->load.syncState) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
\ No newline at end of file

source/libs/parser/inc/parAst.h

@@ -53,6 +53,7 @@ typedef enum EDatabaseOptionType {
   DB_OPTION_VGROUPS,
   DB_OPTION_SINGLE_STABLE,
   DB_OPTION_STREAM_MODE,
+  DB_OPTION_STRICT,
   DB_OPTION_RETENTIONS
 } EDatabaseOptionType;
 

source/libs/parser/inc/sql.y

@@ -161,6 +161,7 @@ db_options(A) ::= db_options(B) VGROUPS NK_INTEGER(C).
 db_options(A) ::= db_options(B) SINGLE_STABLE NK_INTEGER(C).                      { ((SDatabaseOptions*)B)->pSingleStable = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
 db_options(A) ::= db_options(B) STREAM_MODE NK_INTEGER(C).                        { ((SDatabaseOptions*)B)->pStreamMode = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
 db_options(A) ::= db_options(B) RETENTIONS retention_list(C).                     { ((SDatabaseOptions*)B)->pRetentions = C; A = B; }
+db_options(A) ::= db_options(B) STRICT NK_INTEGER(C).                             { ((SDatabaseOptions*)B)->pStrict = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &C); A = B; }
 
 alter_db_options(A) ::= alter_db_option(B).                                       { A = createDatabaseOptions(pCxt); A = setDatabaseAlterOption(pCxt, A, &B); }
 alter_db_options(A) ::= alter_db_options(B) alter_db_option(C).                   { A = setDatabaseAlterOption(pCxt, B, &C); }
@@ -175,6 +176,7 @@ alter_db_option(A) ::= WAL NK_INTEGER(B).
 alter_db_option(A) ::= QUORUM NK_INTEGER(B).                                      { A.type = DB_OPTION_QUORUM; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
 alter_db_option(A) ::= CACHELAST NK_INTEGER(B).                                   { A.type = DB_OPTION_CACHELAST; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
 alter_db_option(A) ::= REPLICA NK_INTEGER(B).                                     { A.type = DB_OPTION_REPLICA; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
+alter_db_option(A) ::= STRICT NK_INTEGER(B).                                      { A.type = DB_OPTION_STRICT; A.pVal = (SValueNode*)createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &B); }
 
 %type integer_list                                                                { SNodeList* }
 %destructor integer_list                                                          { nodesDestroyList($$); }
@@ -359,7 +361,7 @@ from_db_opt(A) ::= FROM db_name(B).
 %type func_name_list                                                              { SNodeList* }
 %destructor func_name_list                                                        { nodesDestroyList($$); }
 func_name_list(A) ::= func_name(B).                                               { A = createNodeList(pCxt, B); }
-func_name_list(A) ::= func_name_list(B) NK_COMMA col_name(C).                     { A = addNodeToList(pCxt, B, C); }
+func_name_list(A) ::= func_name_list(B) NK_COMMA func_name(C).                    { A = addNodeToList(pCxt, B, C); }
 
 func_name(A) ::= function_name(B).                                                { A = createFunctionNode(pCxt, &B, NULL); }
 

source/libs/parser/src/parAstCreater.c

@@ -677,9 +677,6 @@ SNode* setDatabaseAlterOption(SAstCreateContext* pCxt, SNode* pOptions, SAlterOp
     case DB_OPTION_PRECISION:
       ((SDatabaseOptions*)pOptions)->pPrecision = pAlterOption->pVal;
       break;
-    case DB_OPTION_QUORUM:
-      ((SDatabaseOptions*)pOptions)->pQuorum = pAlterOption->pVal;
-      break;
     case DB_OPTION_REPLICA:
       ((SDatabaseOptions*)pOptions)->pReplica = pAlterOption->pVal;
       break;

source/libs/parser/src/parTokenizer.c

@@ -168,6 +168,7 @@ static SKeyword keywordTable[] = {
     {"STREAM",        TK_STREAM},
     {"STREAMS",       TK_STREAMS},
     {"STREAM_MODE",   TK_STREAM_MODE},
+    {"STRICT",        TK_STRICT},
     {"SYNCDB",        TK_SYNCDB},
     {"TABLE",         TK_TABLE},
     {"TABLES",        TK_TABLES},

source/libs/scalar/src/sclfunc.c

@@ -304,7 +304,7 @@ static int32_t doLengthFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
       continue;
     }
 
-    char *in = pInputData->pData + pInputData->varmeta.offset[i];
+    char *in = colDataGetData(pInputData, i);
     out[i] = lenFn(in, type);
   }
 
@@ -395,11 +395,8 @@ int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 
     int16_t dataLen = 0;
     for (int32_t i = 0; i < inputNum; ++i) {
-      if (pInput[i].numOfRows == 1) {
-        input[i] = pInputData[i]->pData + pInputData[i]->varmeta.offset[0];
-      } else {
-        input[i] = pInputData[i]->pData + pInputData[i]->varmeta.offset[k];
-      }
+      int32_t rowIdx = (pInput[i].numOfRows == 1) ? 0 : k;
+      input[i] = colDataGetData(pInputData[i], rowIdx);
 
       ret = concatCopyHelper(input[i], output, hasNchar, GET_PARAM_TYPE(&pInput[i]), &dataLen);
       if (ret != TSDB_CODE_SUCCESS) {
@@ -473,11 +470,8 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
         break;
       }
 
-      if (pInput[i].numOfRows == 1) {
-        input[i] = pInputData[i]->pData + pInputData[i]->varmeta.offset[0];
-      } else {
-        input[i] = pInputData[i]->pData + pInputData[i]->varmeta.offset[k];
-      }
+      int32_t rowIdx = (pInput[i].numOfRows == 1) ? 0 : k;
+      input[i] = colDataGetData(pInputData[i], rowIdx);
 
       ret = concatCopyHelper(input[i], output, hasNchar, GET_PARAM_TYPE(&pInput[i]), &dataLen);
       if (ret != TSDB_CODE_SUCCESS) {
@@ -534,7 +528,7 @@ static int32_t doCaseConvFunction(SScalarParam *pInput, int32_t inputNum, SScala
       continue;
     }
 
-    char *input = pInputData->pData + pInputData->varmeta.offset[i];
+    char *input = colDataGetData(pInput[0].columnData, i);
     int32_t len = varDataLen(input);
     if (type == TSDB_DATA_TYPE_VARCHAR) {
       for (int32_t j = 0; j < len; ++j) {
@@ -575,8 +569,8 @@ static int32_t doTrimFunction(SScalarParam *pInput, int32_t inputNum, SScalarPar
       colDataAppendNULL(pOutputData, i);
       continue;
     }
-    char *input  = pInputData->pData + pInputData->varmeta.offset[i];
 
+    char *input = colDataGetData(pInput[0].columnData, i);
     int32_t len = varDataLen(input);
     int32_t charLen = (type == TSDB_DATA_TYPE_VARCHAR) ? len : len / TSDB_NCHAR_SIZE;
     trimFn(input, output, type, charLen);
@@ -606,7 +600,7 @@ int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
   int32_t subLen = INT16_MAX;
   if (inputNum == 3) {
     GET_TYPED_DATA(subLen, int32_t, GET_PARAM_TYPE(&pInput[2]), pInput[2].columnData->pData);
-    if (subLen < 0) { //subLen cannot be negative
+    if (subLen < 0 || subLen > INT16_MAX) { //subLen cannot be negative
       return TSDB_CODE_FAILED;
     }
     subLen = (GET_PARAM_TYPE(pInput) == TSDB_DATA_TYPE_VARCHAR) ? subLen : subLen * TSDB_NCHAR_SIZE;
@@ -615,19 +609,16 @@ int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
   SColumnInfoData *pInputData  = pInput->columnData;
   SColumnInfoData *pOutputData = pOutput->columnData;
 
-  char *input  = pInputData->pData + pInputData->varmeta.offset[0];
-  char *output = NULL;
-
   int32_t outputLen = pInputData->varmeta.length * pInput->numOfRows;
   char *outputBuf = taosMemoryCalloc(outputLen, 1);
-  output = outputBuf;
+  char *output = outputBuf;
 
   for (int32_t i = 0; i < pInput->numOfRows; ++i) {
     if (colDataIsNull_s(pInputData, i)) {
       colDataAppendNULL(pOutputData, i);
       continue;
     }
-
+    char *input = colDataGetData(pInput[0].columnData, i);
     int32_t len = varDataLen(input);
     int32_t startPosBytes;
 
@@ -646,7 +637,6 @@ int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 
     varDataSetLen(output, resLen);
     colDataAppend(pOutputData, i , output, false);
-    input += varDataTLen(input);
     output += varDataTLen(output);
   }
 
@@ -659,27 +649,22 @@ int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   int16_t inputType  = pInput[0].columnData->info.type;
   int16_t outputType = pOutput[0].columnData->info.type;
-  if (outputType != TSDB_DATA_TYPE_BIGINT && outputType != TSDB_DATA_TYPE_UBIGINT &&
-      outputType != TSDB_DATA_TYPE_VARCHAR && outputType != TSDB_DATA_TYPE_NCHAR &&
-      outputType != TSDB_DATA_TYPE_TIMESTAMP) {
-    return TSDB_CODE_FAILED;
-  }
   int64_t outputLen = pOutput[0].columnData->info.bytes;
 
-  char *input = NULL;
+  if (IS_VAR_DATA_TYPE(outputType)) {
+    int32_t factor = (TSDB_DATA_TYPE_NCHAR == outputType) ? TSDB_NCHAR_SIZE : 1;
+    outputLen = outputLen * factor + VARSTR_HEADER_SIZE;
+  }
+
   char *outputBuf = taosMemoryCalloc(outputLen * pInput[0].numOfRows, 1);
   char *output = outputBuf;
-  if (IS_VAR_DATA_TYPE(inputType)) {
-    input = pInput[0].columnData->pData + pInput[0].columnData->varmeta.offset[0];
-  } else {
-    input = pInput[0].columnData->pData;
-  }
 
   for (int32_t i = 0; i < pInput[0].numOfRows; ++i) {
     if (colDataIsNull_s(pInput[0].columnData, i)) {
       colDataAppendNULL(pOutput->columnData, i);
       continue;
     }
+    char *input = colDataGetData(pInput[0].columnData, i);
 
     switch(outputType) {
       case TSDB_DATA_TYPE_BIGINT: {
@@ -736,7 +721,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
         } else if (inputType == TSDB_DATA_TYPE_BINARY) {
           int32_t len = sprintf(varDataVal(output), "%.*s", (int32_t)(outputLen - VARSTR_HEADER_SIZE), varDataVal(input));
           varDataSetLen(output, len);
-        } else if (inputType == TSDB_DATA_TYPE_BINARY || inputType == TSDB_DATA_TYPE_NCHAR) {
+        } else if (inputType == TSDB_DATA_TYPE_NCHAR) {
           //not support
           return TSDB_CODE_FAILED;
         } else {
@@ -789,11 +774,6 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
     }
 
     colDataAppend(pOutput->columnData, i, output, false);
-    if (IS_VAR_DATA_TYPE(inputType)) {
-      input  += varDataTLen(input);
-    } else {
-      input  += tDataTypes[inputType].bytes;
-    }
     if (IS_VAR_DATA_TYPE(outputType)) {
       output += varDataTLen(output);
     } else {
@@ -809,13 +789,13 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
 int32_t toISO8601Function(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
   int32_t type = GET_PARAM_TYPE(pInput);
 
-  char *input  = pInput[0].columnData->pData;
   for (int32_t i = 0; i < pInput[0].numOfRows; ++i) {
     if (colDataIsNull_s(pInput[0].columnData, i)) {
       colDataAppendNULL(pOutput->columnData, i);
       continue;
     }
 
+    char *input = colDataGetData(pInput[0].columnData, i);
     char fraction[20] = {0};
     bool hasFraction = false;
     NUM_TO_STRING(type, input, sizeof(fraction), fraction);
@@ -832,7 +812,8 @@ int32_t toISO8601Function(SScalarParam *pInput, int32_t inputNum, SScalarParam *
       } else if (tsDigits == TSDB_TIME_PRECISION_NANO_DIGITS) {
         timeVal = timeVal / (1000 * 1000 * 1000);
       } else {
-        assert(0);
+        colDataAppendNULL(pOutput->columnData, i);
+        continue;
       }
       hasFraction = true;
       memmove(fraction, fraction + TSDB_TIME_PRECISION_SEC_DIGITS, TSDB_TIME_PRECISION_SEC_DIGITS);
@@ -862,7 +843,6 @@ int32_t toISO8601Function(SScalarParam *pInput, int32_t inputNum, SScalarParam *
     varDataSetLen(buf, len);
 
     colDataAppend(pOutput->columnData, i, buf, false);
-    input   += tDataTypes[type].bytes;
   }
 
   pOutput->numOfRows = pInput->numOfRows;
@@ -874,12 +854,12 @@ int32_t toUnixtimestampFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
   int32_t type = GET_PARAM_TYPE(pInput);
   int32_t timePrec = GET_PARAM_PRECISON(pInput);
 
-  char *input = pInput[0].columnData->pData + pInput[0].columnData->varmeta.offset[0];
   for (int32_t i = 0; i < pInput[0].numOfRows; ++i) {
     if (colDataIsNull_s(pInput[0].columnData, i)) {
       colDataAppendNULL(pOutput->columnData, i);
       continue;
     }
+    char *input = colDataGetData(pInput[0].columnData, i);
 
     int64_t timeVal = 0;
     int32_t ret = convertStringToTimestamp(type, input, timePrec, &timeVal);
@@ -889,7 +869,6 @@ int32_t toUnixtimestampFunction(SScalarParam *pInput, int32_t inputNum, SScalarP
     }
 
     colDataAppend(pOutput->columnData, i, (char *)&timeVal, false);
-    input += varDataTLen(input);
   }
 
   pOutput->numOfRows = pInput->numOfRows;
@@ -907,19 +886,14 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
   int64_t factor = (timePrec == TSDB_TIME_PRECISION_MILLI) ? 1000 :
                    (timePrec == TSDB_TIME_PRECISION_MICRO ? 1000000 : 1000000000);
 
-  char *input = NULL;
-  if (IS_VAR_DATA_TYPE(type)) {
-    input = pInput[0].columnData->pData + pInput[0].columnData->varmeta.offset[0];
-  } else {
-    input = pInput[0].columnData->pData;
-  }
-
   for (int32_t i = 0; i < pInput[0].numOfRows; ++i) {
     if (colDataIsNull_s(pInput[0].columnData, i)) {
       colDataAppendNULL(pOutput->columnData, i);
       continue;
     }
 
+    char *input = colDataGetData(pInput[0].columnData, i);
+
     if (IS_VAR_DATA_TYPE(type)) { /* datetime format strings */
       int32_t ret = convertStringToTimestamp(type, input, TSDB_TIME_PRECISION_NANO, &timeVal);
       if (ret != TSDB_CODE_SUCCESS) {
@@ -969,7 +943,8 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
         } else if (tsDigits <= TSDB_TIME_PRECISION_SEC_DIGITS){
           timeVal = timeVal * factor;
         } else {
-          assert(0);
+          colDataAppendNULL(pOutput->columnData, i);
+          continue;
         }
         break;
       }
@@ -983,7 +958,8 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
         } else if (tsDigits <= TSDB_TIME_PRECISION_SEC_DIGITS) {
           timeVal = timeVal * factor;
         } else {
-          assert(0);
+          colDataAppendNULL(pOutput->columnData, i);
+          continue;
         }
         break;
       }
@@ -997,7 +973,8 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
         } else if (tsDigits <= TSDB_TIME_PRECISION_SEC_DIGITS) {
           timeVal = timeVal * factor / factor / 60 * 60 * factor;
         } else {
-          assert(0);
+          colDataAppendNULL(pOutput->columnData, i);
+          continue;
         }
         break;
       }
@@ -1011,7 +988,8 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
         } else if (tsDigits <= TSDB_TIME_PRECISION_SEC_DIGITS) {
           timeVal = timeVal * factor / factor / 3600 * 3600 * factor;
         } else {
-          assert(0);
+          colDataAppendNULL(pOutput->columnData, i);
+          continue;
         }
         break;
       }
@@ -1025,7 +1003,8 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
         } else if (tsDigits <= TSDB_TIME_PRECISION_SEC_DIGITS) {
           timeVal = timeVal * factor / factor / 86400* 86400 * factor;
         } else {
-          assert(0);
+          colDataAppendNULL(pOutput->columnData, i);
+          continue;
         }
         break;
       }
@@ -1039,7 +1018,8 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
         } else if (tsDigits <= TSDB_TIME_PRECISION_SEC_DIGITS) {
           timeVal = timeVal * factor / factor / 604800 * 604800* factor;
         } else {
-          assert(0);
+          colDataAppendNULL(pOutput->columnData, i);
+          continue;
         }
         break;
       }
@@ -1078,11 +1058,6 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara
     }
 
     colDataAppend(pOutput->columnData, i, (char *)&timeVal, false);
-    if (IS_VAR_DATA_TYPE(type)) {
-      input += varDataTLen(input);
-    } else {
-      input += tDataTypes[type].bytes;
-    }
   }
 
   pOutput->numOfRows = pInput->numOfRows;
@@ -1104,12 +1079,6 @@ int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
         type != TSDB_DATA_TYPE_BINARY && type != TSDB_DATA_TYPE_NCHAR) {
       return TSDB_CODE_FAILED;
     }
-
-    if (IS_VAR_DATA_TYPE(type)) {
-      input[k] = pInput[k].columnData->pData + pInput[k].columnData->varmeta.offset[0];
-    } else {
-      input[k] = pInput[k].columnData->pData;
-    }
   }
 
   for (int32_t i = 0; i < pInput[0].numOfRows; ++i) {
@@ -1119,6 +1088,9 @@ int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
         continue;
       }
 
+      int32_t rowIdx = (pInput[k].numOfRows == 1) ? 0 : i;
+      input[k] = colDataGetData(pInput[k].columnData, rowIdx);
+
       int32_t type = GET_PARAM_TYPE(&pInput[k]);
       if (IS_VAR_DATA_TYPE(type)) { /* datetime format strings */
         int32_t ret = convertStringToTimestamp(type, input[k], TSDB_TIME_PRECISION_NANO, &timeVal[k]);
@@ -1148,14 +1120,9 @@ int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p
           timeVal[k] = timeVal[k] * 1000;
         } else if (tsDigits == TSDB_TIME_PRECISION_NANO_DIGITS) {
           timeVal[k] = timeVal[k];
-        }
-      }
-
-      if (pInput[k].numOfRows != 1) {
-        if (IS_VAR_DATA_TYPE(type)) {
-          input[k] += varDataTLen(input[k]);
         } else {
-          input[k] += tDataTypes[type].bytes;
+          colDataAppendNULL(pOutput->columnData, i);
+          continue;
         }
       }
     }

source/libs/scheduler/src/scheduler.c

@@ -2749,4 +2749,15 @@ void schedulerDestroy(void) {
     taosCloseRef(schMgmt.jobRef);
     schMgmt.jobRef = 0;
   }
+
+  if (schMgmt.hbConnections) {
+    void   *pIter = taosHashIterate(schMgmt.hbConnections, NULL);
+    while (pIter != NULL) {
+      SSchHbTrans *hb = pIter;
+      schFreeRpcCtx(&hb->rpcCtx);
+      pIter = taosHashIterate(schMgmt.hbConnections, pIter);
+    }    
+    taosHashCleanup(schMgmt.hbConnections);
+    schMgmt.hbConnections = NULL;
+  }
 }

source/libs/sync/src/syncMain.c

@@ -930,3 +930,16 @@ static void syncFreeNode(void* param) {
 
   taosMemoryFree(pNode);
 }
+
+const char* syncStr(ESyncState state) {
+  switch (state) {
+    case TAOS_SYNC_STATE_FOLLOWER:
+      return "FOLLOWER";
+    case TAOS_SYNC_STATE_CANDIDATE:
+      return "CANDIDATE";
+    case TAOS_SYNC_STATE_LEADER:
+      return "LEADER";
+    default:
+      return "ERROR";
+  }
+}
\ No newline at end of file

source/libs/transport/src/transCli.c

@@ -129,6 +129,15 @@ static void transDestroyConnCtx(STransConnCtx* ctx);
 static SCliThrdObj* createThrdObj();
 static void         destroyThrdObj(SCliThrdObj* pThrd);
 
+static void cliWalkCb(uv_handle_t* handle, void* arg);
+
+#define CLI_RELEASE_UV(loop)        \
+  do {                              \
+    uv_walk(loop, cliWalkCb, NULL); \
+    uv_run(loop, UV_RUN_DEFAULT);   \
+    uv_loop_close(loop);            \
+  } while (0);
+
 // snprintf may cause performance problem
 #define CONN_CONSTRUCT_HASH_KEY(key, ip, port)          \
   do {                                                  \
@@ -212,8 +221,10 @@ static void         destroyThrdObj(SCliThrdObj* pThrd);
     }                                 \
   } while (0)
 
-#define CONN_NO_PERSIST_BY_APP(conn) (((conn)->status == ConnNormal || (conn)->status == ConnInPool) && T_REF_VAL_GET(conn) == 1)
-#define CONN_RELEASE_BY_SERVER(conn) (((conn)->status == ConnRelease || (conn)->status == ConnInPool) && T_REF_VAL_GET(conn) == 1)
+#define CONN_NO_PERSIST_BY_APP(conn) \
+  (((conn)->status == ConnNormal || (conn)->status == ConnInPool) && T_REF_VAL_GET(conn) == 1)
+#define CONN_RELEASE_BY_SERVER(conn) \
+  (((conn)->status == ConnRelease || (conn)->status == ConnInPool) && T_REF_VAL_GET(conn) == 1)
 
 #define REQUEST_NO_RESP(msg)         ((msg)->noResp == 1)
 #define REQUEST_PERSIS_HANDLE(msg)   ((msg)->persistHandle == 1)
@@ -288,8 +299,9 @@ void cliHandleResp(SCliConn* conn) {
     tDebug("%s cli conn %p ref by app", CONN_GET_INST_LABEL(conn), conn);
   }
 
-  tDebug("%s cli conn %p %s received from %s:%d, local info: %s:%d, msg size: %d", pTransInst->label, conn, TMSG_INFO(pHead->msgType),
-         taosInetNtoa(conn->addr.sin_addr), ntohs(conn->addr.sin_port), taosInetNtoa(conn->locaddr.sin_addr), ntohs(conn->locaddr.sin_port), transMsg.contLen);
+  tDebug("%s cli conn %p %s received from %s:%d, local info: %s:%d, msg size: %d", pTransInst->label, conn,
+         TMSG_INFO(pHead->msgType), taosInetNtoa(conn->addr.sin_addr), ntohs(conn->addr.sin_port),
+         taosInetNtoa(conn->locaddr.sin_addr), ntohs(conn->locaddr.sin_port), transMsg.contLen);
 
   conn->secured = pHead->secured;
 
@@ -355,10 +367,12 @@ void cliHandleExcept(SCliConn* pConn) {
 
     if (pMsg == NULL && !CONN_NO_PERSIST_BY_APP(pConn)) {
       transMsg.ahandle = transCtxDumpVal(&pConn->ctx, transMsg.msgType);
-      tDebug("%s cli conn %p construct ahandle %p by %s", CONN_GET_INST_LABEL(pConn), pConn, transMsg.ahandle, TMSG_INFO(transMsg.msgType));
+      tDebug("%s cli conn %p construct ahandle %p by %s", CONN_GET_INST_LABEL(pConn), pConn, transMsg.ahandle,
+             TMSG_INFO(transMsg.msgType));
       if (transMsg.ahandle == NULL) {
         transMsg.ahandle = transCtxDumpBrokenlinkVal(&pConn->ctx, (int32_t*)&(transMsg.msgType));
-        tDebug("%s cli conn %p construct ahandle %p due to brokenlink", CONN_GET_INST_LABEL(pConn), pConn, transMsg.ahandle);
+        tDebug("%s cli conn %p construct ahandle %p due to brokenlink", CONN_GET_INST_LABEL(pConn), pConn,
+               transMsg.ahandle);
       }
     } else {
       transMsg.ahandle = pCtx ? pCtx->ahandle : NULL;
@@ -631,8 +645,9 @@ void cliSend(SCliConn* pConn) {
   pHead->release = REQUEST_RELEASE_HANDLE(pCliMsg) ? 1 : 0;
 
   uv_buf_t wb = uv_buf_init((char*)pHead, msgLen);
-  tDebug("%s cli conn %p %s is send to %s:%d, local info %s:%d", CONN_GET_INST_LABEL(pConn), pConn, TMSG_INFO(pHead->msgType),
-         taosInetNtoa(pConn->addr.sin_addr), ntohs(pConn->addr.sin_port), taosInetNtoa(pConn->locaddr.sin_addr), ntohs(pConn->locaddr.sin_port));
+  tDebug("%s cli conn %p %s is send to %s:%d, local info %s:%d", CONN_GET_INST_LABEL(pConn), pConn,
+         TMSG_INFO(pHead->msgType), taosInetNtoa(pConn->addr.sin_addr), ntohs(pConn->addr.sin_port),
+         taosInetNtoa(pConn->locaddr.sin_addr), ntohs(pConn->locaddr.sin_port));
 
   if (pHead->persist == 1) {
     CONN_SET_PERSIST_BY_APP(pConn);
@@ -671,9 +686,11 @@ static void cliHandleQuit(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   destroyCmsg(pMsg);
   destroyConnPool(pThrd->pool);
   uv_timer_stop(&pThrd->timer);
+  uv_walk(pThrd->loop, cliWalkCb, NULL);
+
   pThrd->quit = true;
 
-  uv_stop(pThrd->loop);
+  // uv_stop(pThrd->loop);
 }
 static void cliHandleRelease(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   SCliConn* conn = pMsg->msg.handle;
@@ -786,7 +803,6 @@ static void* cliWorkThread(void* arg) {
   SCliThrdObj* pThrd = (SCliThrdObj*)arg;
   setThreadName("trans-cli-work");
   uv_run(pThrd->loop, UV_RUN_DEFAULT);
-
   return NULL;
 }
 
@@ -851,8 +867,8 @@ static void destroyThrdObj(SCliThrdObj* pThrd) {
   if (pThrd == NULL) {
     return;
   }
-  uv_stop(pThrd->loop);
   taosThreadJoin(pThrd->thread, NULL);
+  CLI_RELEASE_UV(pThrd->loop);
   taosThreadMutexDestroy(&pThrd->msgMtx);
   transDestroyAsyncPool(pThrd->asyncPool);
 
@@ -874,6 +890,11 @@ void cliSendQuit(SCliThrdObj* thrd) {
   msg->type = Quit;
   transSendAsync(thrd->asyncPool, &msg->q);
 }
+void cliWalkCb(uv_handle_t* handle, void* arg) {
+  if (!uv_is_closing(handle)) {
+    uv_close(handle, NULL);
+  }
+}
 
 int cliRBChoseIdx(STrans* pTransInst) {
   int64_t index = pTransInst->index;

source/libs/transport/src/transComm.c

@@ -195,7 +195,7 @@ SAsyncPool* transCreateAsyncPool(uv_loop_t* loop, int sz, void* arg, AsyncCB cb)
 void transDestroyAsyncPool(SAsyncPool* pool) {
   for (int i = 0; i < pool->nAsync; i++) {
     uv_async_t* async = &(pool->asyncs[i]);
-    uv_close((uv_handle_t*)async, NULL);
+    // uv_close((uv_handle_t*)async, NULL);
     SAsyncItem* item = async->data;
     taosThreadMutexDestroy(&item->mtx);
     taosMemoryFree(item);

tests/script/jenkins/basic.txt

@@ -55,7 +55,7 @@
 
 # ---- tmq
 ./test.sh -f tsim/tmq/basic.sim
-./test.sh -f tsim/tmq/basic1.sim
+#./test.sh -f tsim/tmq/basic1.sim
 #./test.sh -f tsim/tmq/oneTopic.sim
 #./test.sh -f tsim/tmq/multiTopic.sim
 

tests/script/tsim/db/alter_option.sim

@@ -66,7 +66,7 @@ print ============= create database
 #  | REPLICA value      [1 | 3]
 #  | WAL value          [1 | 2]
 
-sql create database db BLOCKS 7 CACHE 3 CACHELAST 3 COMP 0 DAYS 345600 FSYNC 1000 MAXROWS 8000 MINROWS 10 KEEP 1440000 PRECISION 'ns' QUORUM 1 REPLICA 3 TTL 7 WAL 2 VGROUPS 6 SINGLE_STABLE 1 STREAM_MODE 1
+sql create database db BLOCKS 7 CACHE 3 CACHELAST 3 COMP 0 DAYS 345600 FSYNC 1000 MAXROWS 8000 MINROWS 10 KEEP 1440000 PRECISION 'ns' REPLICA 3 TTL 7 WAL 2 VGROUPS 6 SINGLE_STABLE 1 STREAM_MODE 1
 sql show databases
 print rows: $rows
 print $data00 $data01 $data02 $data03 $data04 $data05 $data06 $data07 $data08 $data09
@@ -89,7 +89,7 @@ endi
 if $data4_db != 3 then  # replica
   return -1
 endi
-if $data5_db != 1 then  # quorum
+if $data5_db != nostrict then  # strict
   return -1
 endi
 if $data6_db != 345600 then  # days
@@ -156,25 +156,25 @@ sql_error alter database db replica 0
 #  return -1
 #endi
 
-print ============== modify quorum
-sql alter database db quorum 2
-sql show databases
-print quorum $data5_db
-if $data5_db != 2 then 
-  return -1
-endi
-sql alter database db quorum 1
-sql show databases
-print quorum $data5_db
-if $data5_db != 1 then 
-  return -1
-endi
+#print ============== modify quorum
+#sql alter database db quorum 2
+#sql show databases
+#print quorum $data5_db
+#if $data5_db != 2 then 
+#  return -1
+#endi
+#sql alter database db quorum 1
+#sql show databases
+#print quorum $data5_db
+#if $data5_db != 1 then 
+#  return -1
+#endi
 
-sql_error alter database db quorum -1
-sql_error alter database db quorum 0
-sql_error alter database db quorum 3
-sql_error alter database db quorum 4
-sql_error alter database db quorum 5
+#sql_error alter database db quorum -1
+#sql_error alter database db quorum 0
+#sql_error alter database db quorum 3
+#sql_error alter database db quorum 4
+#sql_error alter database db quorum 5
 
 #print ============== modify days
 sql_error alter database db days 480

tests/script/tsim/db/create_all_options.sim

@@ -115,7 +115,7 @@ if $data4_db != 1 then  # replica
   print expect 1, actual: $data4_db
   return -1
 endi
-if $data5_db != 1 then  # quorum
+if $data5_db != nostrict then  # strict
   return -1
 endi
 if $data6_db != 14400 then  # days
@@ -355,16 +355,16 @@ print ====> QUORUM value [1 | 2, default: 1]
 #endi
 #sql drop database db
 
-sql create database db QUORUM 1
-sql show databases
-print $data0_db $data1_db $data2_db $data3_db $data4_db $data5_db $data6_db $data7_db $data8_db $data9_db $data10_db $data11_db $data12_db $data13_db $data14_db $data15_db $data16_db $data17_db
-if $data5_db != 1 then
-  return -1
-endi
-sql drop database db
-sql_error create database db QUORUM 3
-sql_error create database db QUORUM 0
-sql_error create database db QUORUM -1
+#sql create database db QUORUM 1
+#sql show databases
+#print $data0_db $data1_db $data2_db $data3_db $data4_db $data5_db $data6_db $data7_db $data8_db $data9_db $data10_db $data11_db $data12_db $data13_db $data14_db $data15_db $data16_db $data17_db
+#if $data5_db != 1 then
+#  return -1
+#endi
+#sql drop database db
+#sql_error create database db QUORUM 3
+#sql_error create database db QUORUM 0
+#sql_error create database db QUORUM -1
 
 print ====> REPLICA value [1 | 3, default: 1]
 sql create database db REPLICA 3

tests/script/tsim/sync/oneReplica1VgElect.sim

@@ -203,7 +203,6 @@ if $data[0][4] == LEADER then
   $dnodeId = $data[0][3]
 elif $data[0][6] == LEADER then
   $dnodeId = $data[0][5]
-endi
 elif $data[0][8] == LEADER then
   $dnodeId = $data[0][7]
 else 

tests/script/tsim/sync/oneReplica1VgElectWithInsert.sim

@@ -212,7 +212,6 @@ if $data[0][4] == LEADER then
   $dnodeId = $data[0][3]
 elif $data[0][6] == LEADER then
   $dnodeId = $data[0][5]
-endi
 elif $data[0][8] == LEADER then
   $dnodeId = $data[0][7]
 else 

tests/script/tsim/sync/threeReplica1VgElect.sim

@@ -203,7 +203,6 @@ if $data[0][4] == LEADER then
   $dnodeId = $data[0][3]
 elif $data[0][6] == LEADER then
   $dnodeId = $data[0][5]
-endi
 elif $data[0][8] == LEADER then
   $dnodeId = $data[0][7]
 else 

tests/script/tsim/sync/threeReplica1VgElectWihtInsert.sim

@@ -212,7 +212,6 @@ if $data[0][4] == LEADER then
   $dnodeId = $data[0][3]
 elif $data[0][6] == LEADER then
   $dnodeId = $data[0][5]
-endi
 elif $data[0][8] == LEADER then
   $dnodeId = $data[0][7]
 else 

tools/shell/inc/shell.h

@@ -50,6 +50,8 @@ typedef struct SShellArguments {
   char  dir[TSDB_FILENAME_LEN];
   int   threadNum;
   int   check;
+  bool  status;
+  bool  verbose;
   char* commands;
   int   abort;
   int   port;
@@ -72,7 +74,6 @@ void read_history();
 void write_history();
 void source_file(TAOS* con, char* fptr);
 void source_dir(TAOS* con, SShellArguments* args);
-void shellCheck(TAOS* con, SShellArguments* args);
 void get_history_path(char* history);
 void shellCheck(TAOS* con, SShellArguments* args);
 void cleanup_handler(void* arg);