Merge branch '3.0' into cpwu/3.0

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/tglobal.h

@@ -32,7 +32,6 @@ extern char     tsLocalEp[];
 extern uint16_t tsServerPort;
 extern int32_t  tsVersion;
 extern int32_t  tsStatusInterval;
-extern bool     tsEnableTelemetryReporting;
 
 // common
 extern int32_t tsRpcTimer;
@@ -82,6 +81,12 @@ extern uint16_t tsMonitorPort;
 extern int32_t  tsMonitorMaxLogs;
 extern bool     tsMonitorComp;
 
+// telem
+extern bool     tsEnableTelem;
+extern int32_t  tsTelemInterval;
+extern char     tsTelemServer[];
+extern uint16_t tsTelemPort;
+
 // query buffer management
 extern int32_t tsQueryBufferSize;  // maximum allowed usage buffer size in MB for each data node during query processing
 extern int64_t tsQueryBufferSizeBytes;   // maximum allowed usage buffer size in byte for each data node

include/common/tmsg.h

@@ -269,6 +269,8 @@ typedef struct SSchema {
 #define SSCHMEA_BYTES(s) ((s)->bytes)
 #define SSCHMEA_NAME(s)  ((s)->name)
 
+STSchema* tdGetSTSChemaFromSSChema(SSchema** pSchema, int32_t nCols);
+
 typedef struct {
   char    name[TSDB_TABLE_FNAME_LEN];
   int8_t  igExists;
@@ -513,7 +515,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;
@@ -535,7 +537,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;
@@ -608,7 +610,7 @@ 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;
@@ -645,10 +647,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 tSerializeSCompactDbReq(void* buf, int32_t bufLen, SCompactDbReq* pReq);
-int32_t tDeserializeSSyncDbReq(void* buf, int32_t bufLen, SSyncDbReq* pReq);
+int32_t tDeserializeSCompactDbReq(void* buf, int32_t bufLen, SCompactDbReq* pReq);
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
@@ -658,6 +660,7 @@ typedef struct {
   int8_t  outputType;
   int32_t outputLen;
   int32_t bufSize;
+  int32_t codeLen;
   int64_t signature;
   char*   pComment;
   char*   pCode;
@@ -729,7 +732,7 @@ typedef struct {
 
 typedef struct {
   int32_t vgId;
-  int8_t  role;
+  int32_t syncState;
   int64_t numOfTables;
   int64_t numOfTimeSeries;
   int64_t totalStorage;
@@ -742,6 +745,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
@@ -816,7 +823,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;
@@ -825,7 +832,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);
@@ -836,11 +843,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];
@@ -1077,10 +1109,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;
+  int32_t statusCode;
-  char   name[TSDB_STEP_NAME_LEN];
+  char    details[1024];
-  char   desc[TSDB_STEP_DESC_LEN];
+} SServerStatusRsp;
-} SStartupReq;
+
+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,7 +229,8 @@ 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
 #endif

include/common/trow.h

@@ -219,7 +219,7 @@ static FORCE_INLINE void *tdKVRowColVal(STSRow *pRow, SKvRowIdx *pIdx) { return
 
 #define TD_ROW_OFFSET(p) ((p)->toffset);  // During ParseInsert when without STSchema, how to get the offset for STpRow?
 
-void                        tdMergeBitmap(uint8_t *srcBitmap, int32_t srcLen, uint8_t *dstBitmap);
+void                        tdMergeBitmap(uint8_t *srcBitmap, int32_t nBits, uint8_t *dstBitmap);
 static FORCE_INLINE void    tdRowCopy(void *dst, STSRow *row) { memcpy(dst, row, TD_ROW_LEN(row)); }
 static FORCE_INLINE int32_t tdSetBitmapValTypeI(void *pBitmap, int16_t colIdx, TDRowValT valType);
 static FORCE_INLINE int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx, TDRowValT valType);
@@ -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:
@@ -1107,11 +1107,11 @@ static FORCE_INLINE bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col
   if (TD_IS_TP_ROW(pIter->pRow)) {
     STColumn *pCol = NULL;
     STSchema *pSchema = pIter->pSchema;
-    while (pIter->colIdx <= pSchema->numOfCols) {
+    while (pIter->colIdx < pSchema->numOfCols) {
       pCol = &pSchema->columns[pIter->colIdx];  // 1st column of schema is primary TS key
       if (colId == pCol->colId) {
         break;
-      } else if (colId < pCol->colId) {
+      } else if (pCol->colId < colId) {
         ++pIter->colIdx;
         continue;
       } else {
@@ -1237,6 +1237,101 @@ static FORCE_INLINE int32_t dataColGetNEleLen(SDataCol *pDataCol, int32_t rows,
   return result;
 }
 
+static void tdSCellValPrint(SCellVal *pVal, int8_t colType) {
+  if (tdValTypeIsNull(pVal->valType)) {
+    printf("NULL ");
+    return;
+  } else if (tdValTypeIsNone(pVal->valType)) {
+    printf("NONE ");
+    return;
+  }
+  switch (colType) {
+    case TSDB_DATA_TYPE_BOOL:
+      printf("%s ", (*(int8_t *)pVal->val) == 0 ? "false" : "true");
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      printf("%" PRIi8 " ", *(int8_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      printf("%" PRIi16 " ", *(int16_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_INT:
+      printf("%" PRIi32 " ", *(int32_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+      printf("%" PRIi64 " ", *(int64_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      printf("%f ", *(float *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+      printf("%lf ", *(double *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_VARCHAR:
+      printf("VARCHAR ");
+      break;
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      printf("%" PRIi64 " ", *(int64_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_NCHAR:
+      printf("NCHAR ");
+      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      printf("%" PRIu8 " ", *(uint8_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      printf("%" PRIu16 " ", *(uint16_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      printf("%" PRIu32 " ", *(uint32_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      printf("%" PRIu64 " ", *(uint64_t *)pVal->val);
+      break;
+    case TSDB_DATA_TYPE_JSON:
+      printf("JSON ");
+      break;
+    case TSDB_DATA_TYPE_VARBINARY:
+      printf("VARBIN ");
+      break;
+    case TSDB_DATA_TYPE_DECIMAL:
+      printf("DECIMAL ");
+      break;
+    case TSDB_DATA_TYPE_BLOB:
+      printf("BLOB ");
+      break;
+    case TSDB_DATA_TYPE_MEDIUMBLOB:
+      printf("MedBLOB ");
+      break;
+    // case TSDB_DATA_TYPE_BINARY:
+    //   printf("BINARY ");
+    //   break;
+    case TSDB_DATA_TYPE_MAX:
+      printf("UNDEF ");
+      break;
+    default:
+      printf("UNDEF ");
+      break;
+  }
+}
+
+static void tdSRowPrint(STSRow *row, STSchema *pSchema) {
+  STSRowIter iter = {0};
+  tdSTSRowIterInit(&iter, pSchema);
+  tdSTSRowIterReset(&iter, row);
+  printf(">>>");
+  for (int i = 0; i < pSchema->numOfCols; ++i) {
+    STColumn *stCol = pSchema->columns + i;
+    SCellVal  sVal = {.valType = 255, .val = NULL};
+    if (!tdSTSRowIterNext(&iter, stCol->colId, stCol->type, &sVal)) {
+      break;
+    }
+    ASSERT(sVal.valType == 0 || sVal.valType == 1 || sVal.valType == 2);
+    tdSCellValPrint(&sVal, stCol->type);
+  }
+  printf("\n");
+}
+
 #ifdef TROW_ORIGIN_HZ
 typedef struct {
   uint32_t nRows;

include/common/ttokendef.h

@@ -148,94 +148,95 @@
 #define TK_VARIABLES                      130
 #define TK_BNODES                         131
 #define TK_SNODES                         132
-#define TK_LIKE                           133
+#define TK_CLUSTER                        133
-#define TK_INDEX                          134
+#define TK_LIKE                           134
-#define TK_FULLTEXT                       135
+#define TK_INDEX                          135
-#define TK_FUNCTION                       136
+#define TK_FULLTEXT                       136
-#define TK_INTERVAL                       137
+#define TK_FUNCTION                       137
-#define TK_TOPIC                          138
+#define TK_INTERVAL                       138
-#define TK_AS                             139
+#define TK_TOPIC                          139
-#define TK_DESC                           140
+#define TK_AS                             140
-#define TK_DESCRIBE                       141
+#define TK_DESC                           141
-#define TK_RESET                          142
+#define TK_DESCRIBE                       142
-#define TK_QUERY                          143
+#define TK_RESET                          143
-#define TK_EXPLAIN                        144
+#define TK_QUERY                          144
-#define TK_ANALYZE                        145
+#define TK_EXPLAIN                        145
-#define TK_VERBOSE                        146
+#define TK_ANALYZE                        146
-#define TK_NK_BOOL                        147
+#define TK_VERBOSE                        147
-#define TK_RATIO                          148
+#define TK_NK_BOOL                        148
-#define TK_COMPACT                        149
+#define TK_RATIO                          149
-#define TK_VNODES                         150
+#define TK_COMPACT                        150
-#define TK_IN                             151
+#define TK_VNODES                         151
-#define TK_OUTPUTTYPE                     152
+#define TK_IN                             152
-#define TK_AGGREGATE                      153
+#define TK_OUTPUTTYPE                     153
-#define TK_BUFSIZE                        154
+#define TK_AGGREGATE                      154
-#define TK_STREAM                         155
+#define TK_BUFSIZE                        155
-#define TK_INTO                           156
+#define TK_STREAM                         156
-#define TK_TRIGGER                        157
+#define TK_INTO                           157
-#define TK_AT_ONCE                        158
+#define TK_TRIGGER                        158
-#define TK_WINDOW_CLOSE                   159
+#define TK_AT_ONCE                        159
-#define TK_WATERMARK                      160
+#define TK_WINDOW_CLOSE                   160
-#define TK_KILL                           161
+#define TK_WATERMARK                      161
-#define TK_CONNECTION                     162
+#define TK_KILL                           162
-#define TK_MERGE                          163
+#define TK_CONNECTION                     163
-#define TK_VGROUP                         164
+#define TK_MERGE                          164
-#define TK_REDISTRIBUTE                   165
+#define TK_VGROUP                         165
-#define TK_SPLIT                          166
+#define TK_REDISTRIBUTE                   166
-#define TK_SYNCDB                         167
+#define TK_SPLIT                          167
-#define TK_NULL                           168
+#define TK_SYNCDB                         168
-#define TK_NK_QUESTION                    169
+#define TK_NULL                           169
-#define TK_NK_ARROW                       170
+#define TK_NK_QUESTION                    170
-#define TK_ROWTS                          171
+#define TK_NK_ARROW                       171
-#define TK_TBNAME                         172
+#define TK_ROWTS                          172
-#define TK_QSTARTTS                       173
+#define TK_TBNAME                         173
-#define TK_QENDTS                         174
+#define TK_QSTARTTS                       174
-#define TK_WSTARTTS                       175
+#define TK_QENDTS                         175
-#define TK_WENDTS                         176
+#define TK_WSTARTTS                       176
-#define TK_WDURATION                      177
+#define TK_WENDTS                         177
-#define TK_CAST                           178
+#define TK_WDURATION                      178
-#define TK_NOW                            179
+#define TK_CAST                           179
-#define TK_TODAY                          180
+#define TK_NOW                            180
-#define TK_TIMEZONE                       181
+#define TK_TODAY                          181
-#define TK_COUNT                          182
+#define TK_TIMEZONE                       182
-#define TK_FIRST                          183
+#define TK_COUNT                          183
-#define TK_LAST                           184
+#define TK_FIRST                          184
-#define TK_LAST_ROW                       185
+#define TK_LAST                           185
-#define TK_BETWEEN                        186
+#define TK_LAST_ROW                       186
-#define TK_IS                             187
+#define TK_BETWEEN                        187
-#define TK_NK_LT                          188
+#define TK_IS                             188
-#define TK_NK_GT                          189
+#define TK_NK_LT                          189
-#define TK_NK_LE                          190
+#define TK_NK_GT                          190
-#define TK_NK_GE                          191
+#define TK_NK_LE                          191
-#define TK_NK_NE                          192
+#define TK_NK_GE                          192
-#define TK_MATCH                          193
+#define TK_NK_NE                          193
-#define TK_NMATCH                         194
+#define TK_MATCH                          194
-#define TK_CONTAINS                       195
+#define TK_NMATCH                         195
-#define TK_JOIN                           196
+#define TK_CONTAINS                       196
-#define TK_INNER                          197
+#define TK_JOIN                           197
-#define TK_SELECT                         198
+#define TK_INNER                          198
-#define TK_DISTINCT                       199
+#define TK_SELECT                         199
-#define TK_WHERE                          200
+#define TK_DISTINCT                       200
-#define TK_PARTITION                      201
+#define TK_WHERE                          201
-#define TK_BY                             202
+#define TK_PARTITION                      202
-#define TK_SESSION                        203
+#define TK_BY                             203
-#define TK_STATE_WINDOW                   204
+#define TK_SESSION                        204
-#define TK_SLIDING                        205
+#define TK_STATE_WINDOW                   205
-#define TK_FILL                           206
+#define TK_SLIDING                        206
-#define TK_VALUE                          207
+#define TK_FILL                           207
-#define TK_NONE                           208
+#define TK_VALUE                          208
-#define TK_PREV                           209
+#define TK_NONE                           209
-#define TK_LINEAR                         210
+#define TK_PREV                           210
-#define TK_NEXT                           211
+#define TK_LINEAR                         211
-#define TK_GROUP                          212
+#define TK_NEXT                           212
-#define TK_HAVING                         213
+#define TK_GROUP                          213
-#define TK_ORDER                          214
+#define TK_HAVING                         214
-#define TK_SLIMIT                         215
+#define TK_ORDER                          215
-#define TK_SOFFSET                        216
+#define TK_SLIMIT                         216
-#define TK_LIMIT                          217
+#define TK_SOFFSET                        217
-#define TK_OFFSET                         218
+#define TK_LIMIT                          218
-#define TK_ASC                            219
+#define TK_OFFSET                         219
-#define TK_NULLS                          220
+#define TK_ASC                            220
+#define TK_NULLS                          221
 
 #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/function/function.h

@@ -295,19 +295,19 @@ typedef struct SPoint {
   void *  val;
 } SPoint;
 
-void taosFillSetStartInfo(struct SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey);
+//void taosFillSetStartInfo(struct SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey);
-void taosResetFillInfo(struct SFillInfo* pFillInfo, TSKEY startTimestamp);
+//void taosResetFillInfo(struct SFillInfo* pFillInfo, TSKEY startTimestamp);
-void taosFillSetInputDataBlock(struct SFillInfo* pFillInfo, const struct SSDataBlock* pInput);
+//void taosFillSetInputDataBlock(struct SFillInfo* pFillInfo, const struct SSDataBlock* pInput);
-struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, const int64_t* fillVal);
+//struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, const SValueNode* val);
-bool taosFillHasMoreResults(struct SFillInfo* pFillInfo);
+//bool taosFillHasMoreResults(struct SFillInfo* pFillInfo);
-
+//
-struct SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int32_t capacity, int32_t numOfCols,
+//struct SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int32_t capacity, int32_t numOfCols,
-                              int64_t slidingTime, int8_t slidingUnit, int8_t precision, int32_t fillType,
+//                                     SInterval* pInterval, int32_t fillType,
-                              struct SFillColInfo* pFillCol, const char* id);
+//                                     struct SFillColInfo* pCol, const char* id);
-
+//
-void* taosDestroyFillInfo(struct SFillInfo *pFillInfo);
+//void* taosDestroyFillInfo(struct SFillInfo *pFillInfo);
-int64_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, void** output, int32_t capacity);
+//int64_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, void** output, int32_t capacity);
-int64_t getFillInfoStart(struct SFillInfo *pFillInfo);
+//int64_t getFillInfoStart(struct SFillInfo *pFillInfo);
 
 int32_t taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* point1, SPoint* point2, int32_t inputType);
 

include/libs/function/functionMgt.h

@@ -110,7 +110,10 @@ typedef enum EFunctionType {
   FUNCTION_TYPE_QENDTS,
   FUNCTION_TYPE_WSTARTTS,
   FUNCTION_TYPE_WENDTS,
-  FUNCTION_TYPE_WDURATION
+  FUNCTION_TYPE_WDURATION,
+
+  // user defined funcion
+  FUNCTION_TYPE_UDF = 10000
 } EFunctionType;
 
 struct SqlFunctionCtx;
@@ -138,6 +141,7 @@ bool fmIsWindowClauseFunc(int32_t funcId);
 bool fmIsSpecialDataRequiredFunc(int32_t funcId);
 bool fmIsDynamicScanOptimizedFunc(int32_t funcId);
 bool fmIsMultiResFunc(int32_t funcId);
+bool fmIsUserDefinedFunc(int32_t funcId);
 
 typedef enum EFuncDataRequired {
   FUNC_DATA_REQUIRED_DATA_LOAD = 1,

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

@@ -295,6 +295,16 @@ typedef struct SDropStreamStmt {
   bool ignoreNotExists;
 } SDropStreamStmt;
 
+typedef struct SCreateFunctionStmt {
+  ENodeType type;
+  bool ignoreExists;
+  char funcName[TSDB_FUNC_NAME_LEN];
+  bool isAgg;
+  char libraryPath[PATH_MAX];
+  SDataType outputDt;
+  int32_t bufSize;
+} SCreateFunctionStmt;
+
 #ifdef __cplusplus
 }
 #endif

include/libs/nodes/nodes.h

@@ -134,6 +134,7 @@ typedef enum ENodeType {
   QUERY_NODE_SHOW_QNODES_STMT,
   QUERY_NODE_SHOW_SNODES_STMT,
   QUERY_NODE_SHOW_BNODES_STMT,
+  QUERY_NODE_SHOW_CLUSTER_STMT,
   QUERY_NODE_SHOW_DATABASES_STMT,
   QUERY_NODE_SHOW_FUNCTIONS_STMT,
   QUERY_NODE_SHOW_INDEXES_STMT,

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/tdef.h

@@ -239,6 +239,8 @@ typedef enum ELogicConditionType {
 #define TSDB_FUNC_BUF_SIZE       512
 #define TSDB_FUNC_TYPE_SCALAR    1
 #define TSDB_FUNC_TYPE_AGGREGATE 2
+#define TSDB_FUNC_SCRIPT_BIN_LIB 0
+#define TSDB_FUNC_SCRIPT_LUA     1
 #define TSDB_FUNC_MAX_RETRIEVE   1024
 
 #define TSDB_INDEX_NAME_LEN      65  // 64 + 1 '\0'
@@ -297,16 +299,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 +307,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,108 +320,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_MIN_TOTAL_BLOCKS     3
+#define TSDB_MAX_TOTAL_BLOCKS         10000
-#define TSDB_MAX_TOTAL_BLOCKS     10000
+#define TSDB_DEFAULT_TOTAL_BLOCKS     6
-#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_MIN_DAYS_PER_FILE     60  // unit minute
+#define TSDB_DEFAULT_DAYS_PER_FILE    (10 * 1440)
-#define TSDB_MAX_DAYS_PER_FILE     (3650 * 1440)
+#define TSDB_MIN_KEEP                 (1 * 1440)       // data in db to be reserved. unit minute
-#define TSDB_DEFAULT_DAYS_PER_FILE (10 * 1440)
+#define TSDB_MAX_KEEP                 (365000 * 1440)  // data in db to be reserved.
-
+#define TSDB_DEFAULT_KEEP             (3650 * 1440)    // ten years
-#define TSDB_MIN_KEEP     (1 * 1440)       // data in db to be reserved. unit minute
+#define TSDB_MIN_MINROWS_FBLOCK       10
-#define TSDB_MAX_KEEP     (365000 * 1440)  // data in db to be reserved.
+#define TSDB_MAX_MINROWS_FBLOCK       1000
-#define TSDB_DEFAULT_KEEP (3650 * 1440)    // ten years
+#define TSDB_DEFAULT_MINROWS_FBLOCK   100
-
+#define TSDB_MIN_MAXROWS_FBLOCK       200
-#define TSDB_MIN_MIN_ROW_FBLOCK     10
+#define TSDB_MAX_MAXROWS_FBLOCK       10000
-#define TSDB_MAX_MIN_ROW_FBLOCK     1000
+#define TSDB_DEFAULT_MAXROWS_FBLOCK   4096
-#define TSDB_DEFAULT_MIN_ROW_FBLOCK 100
+#define TSDB_MIN_COMMIT_TIME          30
-
+#define TSDB_MAX_COMMIT_TIME          40960
-#define TSDB_MIN_MAX_ROW_FBLOCK     200
+#define TSDB_DEFAULT_COMMIT_TIME      3600
-#define TSDB_MAX_MAX_ROW_FBLOCK     10000
+#define TSDB_MIN_FSYNC_PERIOD         0
-#define TSDB_DEFAULT_MAX_ROW_FBLOCK 4096
+#define TSDB_MAX_FSYNC_PERIOD         180000  // millisecond
-
+#define TSDB_DEFAULT_FSYNC_PERIOD     3000    // three second
-#define TSDB_MIN_COMMIT_TIME     30
+#define TSDB_MIN_DB_TTL               1
-#define TSDB_MAX_COMMIT_TIME     40960
+#define TSDB_DEFAULT_DB_TTL           1
-#define TSDB_DEFAULT_COMMIT_TIME 3600
+#define TSDB_MIN_WAL_LEVEL            1
-
+#define TSDB_MAX_WAL_LEVEL            2
-#define TSDB_MIN_FSYNC_PERIOD     0
+#define TSDB_DEFAULT_WAL_LEVEL        1
-#define TSDB_MAX_FSYNC_PERIOD     180000  // millisecond
+#define TSDB_MIN_PRECISION            TSDB_TIME_PRECISION_MILLI
-#define TSDB_DEFAULT_FSYNC_PERIOD 3000    // three second
+#define TSDB_MAX_PRECISION            TSDB_TIME_PRECISION_NANO
-
+#define TSDB_DEFAULT_PRECISION        TSDB_TIME_PRECISION_MILLI
-#define TSDB_MIN_WAL_LEVEL     1
+#define TSDB_MIN_COMP_LEVEL           0
-#define TSDB_MAX_WAL_LEVEL     2
+#define TSDB_MAX_COMP_LEVEL           2
-#define TSDB_DEFAULT_WAL_LEVEL 1
+#define TSDB_DEFAULT_COMP_LEVEL       2
-
+#define TSDB_MIN_DB_REPLICA           1
-#define TSDB_MIN_PRECISION     TSDB_TIME_PRECISION_MILLI
+#define TSDB_MAX_DB_REPLICA           3
-#define TSDB_MAX_PRECISION     TSDB_TIME_PRECISION_NANO
+#define TSDB_DEFAULT_DB_REPLICA       1
-#define TSDB_DEFAULT_PRECISION TSDB_TIME_PRECISION_MILLI
+#define TSDB_DB_STRICT_OFF            0
-
+#define TSDB_DB_STRICT_ON             1
-#define TSDB_MIN_COMP_LEVEL     0
+#define TSDB_DEFAULT_DB_STRICT        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_DB_STREAM_MODE_OPTION_OFF     0
-#define TSDB_DB_STREAM_MODE_OPTION_ON      1
-#define TSDB_DEFAULT_DB_STREAM_MODE_OPTION 0
-
-#define TSDB_DB_STRICT_OPTION_OFF     0
-#define TSDB_DB_STRICT_OPTION_ON      1
-#define TSDB_DEFAULT_DB_STRICT_OPTION 0
-
-#define TSDB_MAX_JOIN_TABLE_NUM 10
-#define TSDB_MAX_UNION_CLAUSE   5
-
 #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_MIN_DB_CACHE_LAST_ROW  0
+#define TSDB_MAX_DB_CACHE_LAST_ROW    3
-#define TSDB_MAX_DB_CACHE_LAST_ROW  3
+#define TSDB_DEFAULT_CACHE_LAST_ROW   0
-#define TSDB_DEFAULT_CACHE_LAST_ROW 0
+#define TSDB_DB_STREAM_MODE_OFF       0
-
+#define TSDB_DB_STREAM_MODE_ON        1
-#define TSDB_MIN_DB_STREAM_MODE     0
+#define TSDB_DEFAULT_DB_STREAM_MODE   0
-#define TSDB_MAX_DB_STREAM_MODE     1
+#define TSDB_DB_SINGLE_STABLE_ON     0
-#define TSDB_DEFAULT_DB_STREAM_MODE 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_MIN_DB_DELAY     1
+#define TSDB_MAX_DB_DELAY           10
-#define TSDB_MAX_DB_DELAY     10
+#define TSDB_DEFAULT_DB_DELAY       2
-#define TSDB_DEFAULT_DB_DELAY 2
+#define TSDB_MIN_EXPLAIN_RATIO      0
-
+#define TSDB_MAX_EXPLAIN_RATIO      1
-#define TSDB_DEFAULT_EXPLAIN_VERBOSE false
+#define TSDB_DEFAULT_EXPLAIN_RATIO  0.001
-
-#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/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/client/src/clientMsgHandler.c

@@ -209,9 +209,9 @@ int32_t processDropDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 }
 
 void initMsgHandleFp() {
-  handleRequestRspFp[TMSG_INDEX(TDMT_MND_CONNECT)]    = processConnectRsp;
+  handleRequestRspFp[TMSG_INDEX(TDMT_MND_CONNECT)] = processConnectRsp;
-  handleRequestRspFp[TMSG_INDEX(TDMT_MND_CREATE_DB)]  = processCreateDbRsp;
+  handleRequestRspFp[TMSG_INDEX(TDMT_MND_CREATE_DB)] = processCreateDbRsp;
-  handleRequestRspFp[TMSG_INDEX(TDMT_MND_USE_DB)]     = processUseDbRsp;
+  handleRequestRspFp[TMSG_INDEX(TDMT_MND_USE_DB)] = processUseDbRsp;
   handleRequestRspFp[TMSG_INDEX(TDMT_MND_CREATE_STB)] = processCreateTableRsp;
-  handleRequestRspFp[TMSG_INDEX(TDMT_MND_DROP_DB)]    = processDropDbRsp;
+  handleRequestRspFp[TMSG_INDEX(TDMT_MND_DROP_DB)] = processDropDbRsp;
 }

source/common/src/tglobal.c

@@ -30,7 +30,6 @@ char     tsLocalEp[TSDB_EP_LEN] = {0};  // Local End Point, hostname:port
 uint16_t tsServerPort = 6030;
 int32_t  tsVersion = 30000000;
 int32_t  tsStatusInterval = 1;  // second
-bool     tsEnableTelemetryReporting = false;
 
 // common
 int32_t tsRpcTimer = 300;
@@ -75,6 +74,12 @@ uint16_t tsMonitorPort = 6043;
 int32_t  tsMonitorMaxLogs = 100;
 bool     tsMonitorComp = false;
 
+// telem
+bool     tsEnableTelem = false;
+int32_t  tsTelemInterval = 86400;
+char     tsTelemServer[TSDB_FQDN_LEN] = "telemetry.taosdata.com";
+uint16_t tsTelemPort = 80;
+
 /*
  * denote if the server needs to compress response message at the application layer to client, including query rsp,
  * metricmeta rsp, and multi-meter query rsp message body. The client compress the submit message to server.
@@ -354,7 +359,6 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddDir(pCfg, "dataDir", tsDataDir, 0) != 0) return -1;
   if (cfgAddFloat(pCfg, "minimalDataDirGB", 2.0f, 0.001f, 10000000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxNumOfDistinctRes", tsMaxNumOfDistinctResults, 10 * 10000, 10000 * 10000, 0) != 0) return -1;
-  if (cfgAddBool(pCfg, "telemetryReporting", tsEnableTelemetryReporting, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxConnections", tsMaxConnections, 1, 100000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "maxShellConns", tsMaxShellConns, 10, 50000000, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "statusInterval", tsStatusInterval, 1, 30, 0) != 0) return -1;
@@ -430,12 +434,17 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   if (cfgAddInt32(pCfg, "numOfSnodeUniqueThreads", tsNumOfSnodeUniqueThreads, 1, 1024, 0) != 0) return -1;
 
   if (cfgAddBool(pCfg, "monitor", tsEnableMonitor, 0) != 0) return -1;
-  if (cfgAddInt32(pCfg, "monitorInterval", tsMonitorInterval, 1, 360000, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "monitorInterval", tsMonitorInterval, 1, 200000, 0) != 0) return -1;
   if (cfgAddString(pCfg, "monitorFqdn", tsMonitorFqdn, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "monitorPort", tsMonitorPort, 1, 65056, 0) != 0) return -1;
   if (cfgAddInt32(pCfg, "monitorMaxLogs", tsMonitorMaxLogs, 1, 1000000, 0) != 0) return -1;
   if (cfgAddBool(pCfg, "monitorComp", tsMonitorComp, 0) != 0) return -1;
 
+  if (cfgAddBool(pCfg, "telemetryReporting", tsEnableTelem, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "telemetryInterval", tsTelemInterval, 1, 200000, 0) != 0) return -1;
+  if (cfgAddString(pCfg, "telemetryServer", tsTelemServer, 0) != 0) return -1;
+  if (cfgAddInt32(pCfg, "telemetryPort", tsTelemPort, 1, 65056, 0) != 0) return -1;
+
   return 0;
 }
 
@@ -528,7 +537,6 @@ static void taosSetSystemCfg(SConfig *pCfg) {
 static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsDataSpace.reserved = cfgGetItem(pCfg, "minimalDataDirGB")->fval;
   tsMaxNumOfDistinctResults = cfgGetItem(pCfg, "maxNumOfDistinctRes")->i32;
-  tsEnableTelemetryReporting = cfgGetItem(pCfg, "telemetryReporting")->bval;
   tsMaxConnections = cfgGetItem(pCfg, "maxConnections")->i32;
   tsMaxShellConns = cfgGetItem(pCfg, "maxShellConns")->i32;
   tsStatusInterval = cfgGetItem(pCfg, "statusInterval")->i32;
@@ -572,6 +580,11 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   tsMonitorMaxLogs = cfgGetItem(pCfg, "monitorMaxLogs")->i32;
   tsMonitorComp = cfgGetItem(pCfg, "monitorComp")->bval;
 
+  tsEnableTelem = cfgGetItem(pCfg, "telemetryReporting")->bval;
+  tsTelemInterval = cfgGetItem(pCfg, "telemetryInterval")->i32;
+  tstrncpy(tsTelemServer, cfgGetItem(pCfg, "telemetryServer")->str, TSDB_FQDN_LEN);
+  tsTelemPort = (uint16_t)cfgGetItem(pCfg, "telemetryPort")->i32;
+
   if (tsQueryBufferSize >= 0) {
     tsQueryBufferSizeBytes = tsQueryBufferSize * 1048576UL;
   }

source/common/src/tmsg.c

@@ -1027,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;
@@ -1078,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;
@@ -1515,6 +1515,7 @@ int32_t tSerializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pReq
   if (tEncodeI8(&encoder, pReq->outputType) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->outputLen) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->bufSize) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->codeLen) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->signature) < 0) return -1;
 
   int32_t codeSize = 0;
@@ -1554,6 +1555,7 @@ int32_t tDeserializeSCreateFuncReq(void *buf, int32_t bufLen, SCreateFuncReq *pR
   if (tDecodeI8(&decoder, &pReq->outputType) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->outputLen) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->bufSize) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->codeLen) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->signature) < 0) return -1;
 
   int32_t codeSize = 0;
@@ -1760,7 +1762,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;
@@ -1803,7 +1805,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;
@@ -1851,7 +1853,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);
@@ -1873,7 +1875,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);
@@ -2030,7 +2032,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);
 
@@ -2043,7 +2045,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);
 
@@ -2231,7 +2233,7 @@ 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;
@@ -2270,7 +2272,7 @@ 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;
@@ -2880,7 +2882,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;
@@ -2931,7 +2933,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;
@@ -3003,6 +3005,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);
@@ -3148,6 +3231,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;
@@ -3537,3 +3648,27 @@ void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {
   taosMemoryFreeClear(pReq->sql);
   taosMemoryFreeClear(pReq->ast);
 }
+
+STSchema *tdGetSTSChemaFromSSChema(SSchema **pSchema, int32_t nCols) {
+  STSchemaBuilder schemaBuilder = {0};
+  if (tdInitTSchemaBuilder(&schemaBuilder, 0) < 0) {
+    return NULL;
+  }
+
+  for (int i = 0; i < nCols; i++) {
+    SSchema *schema = *pSchema + i;
+    if (tdAddColToSchema(&schemaBuilder, schema->type, schema->flags, schema->colId, schema->bytes) < 0) {
+      tdDestroyTSchemaBuilder(&schemaBuilder);
+      return NULL;
+    }
+  }
+
+  STSchema *pNSchema = tdGetSchemaFromBuilder(&schemaBuilder);
+  if (pNSchema == NULL) {
+    tdDestroyTSchemaBuilder(&schemaBuilder);
+    return NULL;
+  }
+
+  tdDestroyTSchemaBuilder(&schemaBuilder);
+  return pNSchema;
+}

source/common/src/tmsgcb.c

@@ -40,4 +40,8 @@ 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);
 }

source/common/src/trow.c

@@ -24,9 +24,8 @@ const uint8_t tdVTypeByte[2][3] = {{
                                    },
                                    {
                                        // 1 bit
-                                       TD_VTYPE_NORM_BYTE_I,
+                                       TD_VTYPE_NORM_BYTE_I, TD_VTYPE_NULL_BYTE_I,
-                                       TD_VTYPE_NULL_BYTE_I,
+                                       TD_VTYPE_NULL_BYTE_I,  // padding
-                                       TD_VTYPE_NULL_BYTE_I, // padding
                                    }
 
 };
@@ -224,17 +223,40 @@ static uint8_t tdGetMergedBitmapByte(uint8_t byte) {
  * @brief Merge bitmap from 2 bits to 1 bits, and the memory buffer should be guaranteed by the invoker.
  *
  * @param srcBitmap
- * @param srcLen
+ * @param nBits
  * @param dstBitmap
  */
-void tdMergeBitmap(uint8_t *srcBitmap, int32_t srcLen, uint8_t *dstBitmap) {
+void tdMergeBitmap(uint8_t *srcBitmap, int32_t nBits, uint8_t *dstBitmap) {
   int32_t i = 0, j = 0;
+  int32_t nBytes = TD_BITMAP_BYTES(nBits);
+  int32_t nStrictBytes = nBits / 4;
+  int32_t nPartialBits = nBits - nStrictBytes * 4;
 
-  if (srcLen > 0) {
+  switch (nPartialBits) {
+    case 0:
+      // NOTHING TODO
+      break;
+    case 1: {
+      void *lastByte = POINTER_SHIFT(srcBitmap, nStrictBytes);
+      *(uint8_t *)lastByte &= 0xC0;
+    } break;
+    case 2: {
+      void *lastByte = POINTER_SHIFT(srcBitmap, nStrictBytes);
+      *(uint8_t *)lastByte &= 0xF0;
+    } break;
+    case 3: {
+      void *lastByte = POINTER_SHIFT(srcBitmap, nStrictBytes);
+      *(uint8_t *)lastByte &= 0xFC;
+    } break;
+    default:
+      ASSERT(0);
+  }
+
+  if (nBytes > 0) {
     dstBitmap[j] = (tdGetMergedBitmapByte(srcBitmap[i]) << 4);
   }
 
-  while ((++i) < srcLen) {
+  while ((++i) < nBytes) {
     if ((i & 1) == 0) {
       dstBitmap[j] = (tdGetMergedBitmapByte(srcBitmap[i]) << 4);
     } else {
@@ -381,17 +403,18 @@ STSRow *tdRowDup(STSRow *row) {
 }
 
 /**
- * @brief 
+ * @brief
- * 
+ *
- * @param pCol 
+ * @param pCol
- * @param valType 
+ * @param valType
- * @param val 
+ * @param val
- * @param numOfRows 
+ * @param numOfRows
- * @param maxPoints 
+ * @param maxPoints
  * @param bitmapMode  default is 0(2 bits), otherwise 1(1 bit)
- * @return int 
+ * @return int
  */
-int tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int numOfRows, int maxPoints, int8_t bitmapMode) {
+int tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int numOfRows, int maxPoints,
+                         int8_t bitmapMode) {
   TASSERT(pCol != NULL);
 
   // Assume that the columns not specified during insert/upsert mean None.
@@ -426,7 +449,7 @@ int tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int
     pCol->len += pCol->bytes;
   }
 #ifdef TD_SUPPORT_BITMAP
-    tdSetBitmapValType(pCol->pBitmap, numOfRows, valType, bitmapMode);
+  tdSetBitmapValType(pCol->pBitmap, numOfRows, valType, bitmapMode);
 #endif
   return 0;
 }
@@ -537,7 +560,8 @@ int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCol
   return TSDB_CODE_SUCCESS;
 }
 
-int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *pOffset, bool forceSetNull, TDRowVerT maxVer) {
+int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *pOffset, bool forceSetNull,
+                    TDRowVerT maxVer) {
   ASSERT(rowsToMerge > 0 && rowsToMerge <= source->numOfRows);
   ASSERT(target->numOfCols == source->numOfCols);
   int offset = 0;
@@ -558,7 +582,8 @@ int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *
           if (tdGetColDataOfRow(&sVal, source->cols + j, i + (*pOffset), source->bitmapMode) < 0) {
             TASSERT(0);
           }
-          tdAppendValToDataCol(target->cols + j, sVal.valType, sVal.val, target->numOfRows, target->maxPoints, target->bitmapMode);
+          tdAppendValToDataCol(target->cols + j, sVal.valType, sVal.val, target->numOfRows, target->maxPoints,
+                               target->bitmapMode);
         }
       }
       ++target->numOfRows;
@@ -605,7 +630,8 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
           if (tdGetColDataOfRow(&sVal, src1->cols + i, *iter1, src1->bitmapMode) < 0) {
             TASSERT(0);
           }
-          tdAppendValToDataCol(&(target->cols[i]), sVal.valType, sVal.val, target->numOfRows, target->maxPoints, target->bitmapMode);
+          tdAppendValToDataCol(&(target->cols[i]), sVal.valType, sVal.val, target->numOfRows, target->maxPoints,
+                               target->bitmapMode);
         }
       }
 
@@ -621,12 +647,14 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
             TASSERT(0);
           }
           if (src2->cols[i].len > 0 && !tdValTypeIsNull(sVal.valType)) {
-            tdAppendValToDataCol(&(target->cols[i]), sVal.valType, sVal.val, target->numOfRows, target->maxPoints, target->bitmapMode);
+            tdAppendValToDataCol(&(target->cols[i]), sVal.valType, sVal.val, target->numOfRows, target->maxPoints,
+                                 target->bitmapMode);
           } else if (!forceSetNull && key1 == key2 && src1->cols[i].len > 0) {
             if (tdGetColDataOfRow(&sVal, src1->cols + i, *iter1, src1->bitmapMode) < 0) {
               TASSERT(0);
             }
-            tdAppendValToDataCol(&(target->cols[i]), sVal.valType, sVal.val, target->numOfRows, target->maxPoints, target->bitmapMode);
+            tdAppendValToDataCol(&(target->cols[i]), sVal.valType, sVal.val, target->numOfRows, target->maxPoints,
+                                 target->bitmapMode);
           } else if (target->cols[i].len > 0) {
             dataColSetNullAt(&target->cols[i], target->numOfRows, true, target->bitmapMode);
           }

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->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};
+  SMonVloadInfo vinfo = {0};
-  dmGetVnodeLoads(pDnode, &info);
+  dmGetVnodeLoads(pDnode, &vinfo);
-  req.pVloads = info.pVloads;
+  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) {
+  if (msgType == TDMT_DND_SERVER_STATUS) {
-    dTrace("network test req will be processed, handle:%p, app:%p", pMsg->handle, pMsg->ahandle);
+    dTrace("server status req will be processed, handle:%p, app:%p", pMsg->handle, pMsg->ahandle);
-    dmProcessStartupReq(pDnode, pMsg);
+    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) {
+void dmReportStartupByWrapper(SMgmtWrapper *pWrapper, const char *pName, const char *pDesc) {
-  memcpy(pStartup, &pDnode->startup, sizeof(SStartupReq));
+  dmReportStartup(pWrapper->pDnode, pName, pDesc);
-  pStartup->finished = (pDnode->status == DND_STAT_RUNNING);
 }
 
-void dmProcessStartupReq(SDnode *pDnode, SRpcMsg *pReq) {
+static void dmGetServerStatus(SDnode *pDnode, SServerStatusRsp *pStatus) {
-  dDebug("startup req is received");
+  pStatus->details[0] = 0;
-  SStartupReq *pStartup = rpcMallocCont(sizeof(SStartupReq));
-  dmGetStartup(pDnode, pStartup);
 
-  dDebug("startup req is sent, step:%s desc:%s finished:%d", pStartup->name, pStartup->desc, pStartup->finished);
+  if (pDnode->status == DND_STAT_INIT) {
-  SRpcMsg rpcRsp = {
+    pStatus->statusCode = TSDB_SRV_STATUS_NETWORK_OK;
-      .handle = pReq->handle, .pCont = pStartup, .contLen = sizeof(SStartupReq), .ahandle = pReq->ahandle};
+    snprintf(pStatus->details, sizeof(pStatus->details), "%s: %s", pDnode->startup.name, pDnode->startup.desc);
-  rpcSendResponse(&rpcRsp);
+  } 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);
+  SMonVloadInfo vloads = {0};
-  vmInfo->vstat.totalVnodes = pMgmt->state.totalVnodes;
+  vmGetVnodeLoads(pWrapper, &vloads);
-  vmInfo->vstat.masterNum = pMgmt->state.masterNum;
+  if (vloads.pVloads == NULL) return;
-  vmInfo->vstat.numOfSelectReqs = pMgmt->state.numOfSelectReqs - pMgmt->lastState.numOfSelectReqs;
+
-  vmInfo->vstat.numOfInsertReqs = pMgmt->state.numOfInsertReqs - pMgmt->lastState.numOfInsertReqs;
+  int32_t totalVnodes = 0;
-  vmInfo->vstat.numOfInsertSuccessReqs = pMgmt->state.numOfInsertSuccessReqs - pMgmt->lastState.numOfInsertSuccessReqs;
+  int32_t masterNum = 0;
-  vmInfo->vstat.numOfBatchInsertReqs = pMgmt->state.numOfBatchInsertReqs - pMgmt->lastState.numOfBatchInsertReqs;
+  int64_t numOfSelectReqs = 0;
-  vmInfo->vstat.numOfBatchInsertSuccessReqs =
+  int64_t numOfInsertReqs = 0;
-      pMgmt->state.numOfBatchInsertSuccessReqs - pMgmt->lastState.numOfBatchInsertSuccessReqs;
+  int64_t numOfInsertSuccessReqs = 0;
-  pMgmt->lastState = pMgmt->state;
+  int64_t numOfBatchInsertReqs = 0;
-  taosWUnLockLatch(&pMgmt->latch);
+  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_SUBMIT, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY, vmProcessQueryMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_CONTINUE, vmProcessQueryMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_FETCH_RSP, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_TABLE, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_UPDATE_TAG_VAL, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_UPDATE_TAG_VAL, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TABLE_META, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TABLE_META, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TABLES_META, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TABLES_META, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CONSUME, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CONSUME, vmProcessQueryMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_QUERY, (NodeMsgFp)vmProcessQueryMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_QUERY, vmProcessQueryMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CONNECT, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CONNECT, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_DISCONNECT, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_DISCONNECT, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_RES_READY, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_RES_READY, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASKS_STATUS, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_TASK, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TASK, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_STB, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_ALTER_STB, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_STB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_STB, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_TABLE, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TABLE, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_TABLE, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CREATE_SMA, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CANCEL_SMA, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_DROP_SMA, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CONN, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_REB, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_REB, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CANCEL_CONN, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_CANCEL_CONN, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_MQ_SET_CUR, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_CONSUME, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_CONSUME, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_DEPLOY, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_QUERY_HEARTBEAT, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_PIPE_EXEC, (NodeMsgFp)vmProcessFetchMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_PIPE_EXEC, vmProcessFetchMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_MERGE_EXEC, (NodeMsgFp)vmProcessMergeMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_MERGE_EXEC, vmProcessMergeMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_WRITE_EXEC, (NodeMsgFp)vmProcessWriteMsg, DEFAULT_HANDLE);
+  dmSetMsgHandle(pWrapper, TDMT_VND_TASK_WRITE_EXEC, vmProcessWriteMsg, DEFAULT_HANDLE);
-  dmSetMsgHandle(pWrapper, TDMT_VND_STREAM_TRIGGER, (NodeMsgFp)vmProcessFetchMsg, 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;
+  pInfo->pVloads = taosArrayInit(pMgmt->state.totalVnodes, sizeof(SVnodeLoad));
-  int32_t masterNum = 0;
+  if (pInfo->pVloads == NULL) return;
-  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;
 
   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);
+    taosArrayPush(pInfo->pVloads, &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++;
-
     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);
 }

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;

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 {
@@ -82,7 +67,6 @@ typedef struct {
 } SProfileMgmt;
 
 typedef struct {
-  bool     enable;
   SRWLatch lock;
   char     email[TSDB_FQDN_LEN];
 } STelemMgmt;
@@ -129,7 +113,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

@@ -22,14 +22,13 @@
 extern "C" {
 #endif
 
-int32_t     mndInitMnode(SMnode *pMnode);
+int32_t    mndInitMnode(SMnode *pMnode);
-void        mndCleanupMnode(SMnode *pMnode);
+void       mndCleanupMnode(SMnode *pMnode);
-SMnodeObj  *mndAcquireMnode(SMnode *pMnode, int32_t mnodeId);
+SMnodeObj *mndAcquireMnode(SMnode *pMnode, int32_t mnodeId);
-void        mndReleaseMnode(SMnode *pMnode, SMnodeObj *pObj);
+void       mndReleaseMnode(SMnode *pMnode, SMnodeObj *pObj);
-bool        mndIsMnode(SMnode *pMnode, int32_t dnodeId);
+bool       mndIsMnode(SMnode *pMnode, int32_t dnodeId);
-void        mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet);
+void       mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet);
-void        mndUpdateMnodeRole(SMnode *pMnode);
+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/mndDb.c

@@ -18,14 +18,14 @@
 #include "mndAuth.h"
 #include "mndDnode.h"
 #include "mndShow.h"
+#include "mndSma.h"
 #include "mndStb.h"
 #include "mndTrans.h"
 #include "mndUser.h"
 #include "mndVgroup.h"
-#include "mndSma.h"
 
-#define TSDB_DB_VER_NUMBER   1
+#define DB_VER_NUMBER   1
-#define TSDB_DB_RESERVE_SIZE 64
+#define DB_RESERVE_SIZE 64
 
 static SSdbRaw *mndDbActionEncode(SDbObj *pDb);
 static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw);
@@ -36,9 +36,8 @@ static int32_t  mndProcessCreateDbReq(SNodeMsg *pReq);
 static int32_t  mndProcessAlterDbReq(SNodeMsg *pReq);
 static int32_t  mndProcessDropDbReq(SNodeMsg *pReq);
 static int32_t  mndProcessUseDbReq(SNodeMsg *pReq);
-static int32_t  mndProcessSyncDbReq(SNodeMsg *pReq);
 static int32_t  mndProcessCompactDbReq(SNodeMsg *pReq);
-static int32_t  mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rowsCapacity);
+static int32_t  mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity);
 static void     mndCancelGetNextDb(SMnode *pMnode, void *pIter);
 static int32_t  mndProcessGetDbCfgReq(SNodeMsg *pReq);
 static int32_t  mndProcessGetIndexReq(SNodeMsg *pReq);
@@ -56,7 +55,6 @@ int32_t mndInitDb(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);
   mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbReq);
   mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);
-  mndSetMsgHandle(pMnode, TDMT_MND_SYNC_DB, mndProcessSyncDbReq);
   mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);
   mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);
   mndSetMsgHandle(pMnode, TDMT_MND_GET_INDEX, mndProcessGetIndexReq);
@@ -72,54 +70,57 @@ void mndCleanupDb(SMnode *pMnode) {}
 static SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, TSDB_DB_VER_NUMBER,
+  int32_t  size = sizeof(SDbObj) + pDb->cfg.numOfRetensions * sizeof(SRetention) + DB_RESERVE_SIZE;
-                              sizeof(SDbObj) + pDb->cfg.numOfRetensions * sizeof(SRetention) + TSDB_DB_RESERVE_SIZE);
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, DB_VER_NUMBER, size);
-  if (pRaw == NULL) goto DB_ENCODE_OVER;
+  if (pRaw == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_SET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, DB_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, _OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, DB_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, _OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, DB_ENCODE_OVER)
+  SDB_SET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pDb->createdTime, DB_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pDb->createdTime, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pDb->updateTime, DB_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pDb->updateTime, _OVER)
-  SDB_SET_INT64(pRaw, dataPos, pDb->uid, DB_ENCODE_OVER)
+  SDB_SET_INT64(pRaw, dataPos, pDb->uid, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfgVersion, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfgVersion, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->vgVersion, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->vgVersion, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pDb->hashMethod, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfVgroups, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfVgroups, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheBlockSize, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheBlockSize, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.totalBlocks, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.totalBlocks, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysPerFile, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysPerFile, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep0, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep0, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep1, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep1, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep2, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep2, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.minRows, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.minRows, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxRows, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxRows, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.commitTime, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.commitTime, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.fsyncPeriod, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.fsyncPeriod, DB_ENCODE_OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.ttl, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel, DB_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.precision, DB_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.precision, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compression, DB_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compression, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.replications, DB_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.replications, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.quorum, DB_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.strict, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.update, DB_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.update, _OVER)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLastRow, DB_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLastRow, _OVER)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfRetensions, DB_ENCODE_OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.streamMode, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.singleSTable, _OVER)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.hashMethod, _OVER)
+  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfRetensions, _OVER)
   for (int32_t i = 0; i < pDb->cfg.numOfRetensions; ++i) {
     TASSERT(taosArrayGetSize(pDb->cfg.pRetensions) == pDb->cfg.numOfRetensions);
     SRetention *pRetension = taosArrayGet(pDb->cfg.pRetensions, i);
-    SDB_SET_INT32(pRaw, dataPos, pRetension->freq, DB_ENCODE_OVER)
+    SDB_SET_INT32(pRaw, dataPos, pRetension->freq, _OVER)
-    SDB_SET_INT32(pRaw, dataPos, pRetension->keep, DB_ENCODE_OVER)
+    SDB_SET_INT32(pRaw, dataPos, pRetension->keep, _OVER)
-    SDB_SET_INT8(pRaw, dataPos, pRetension->freqUnit, DB_ENCODE_OVER)
+    SDB_SET_INT8(pRaw, dataPos, pRetension->freqUnit, _OVER)
-    SDB_SET_INT8(pRaw, dataPos, pRetension->keepUnit, DB_ENCODE_OVER)
+    SDB_SET_INT8(pRaw, dataPos, pRetension->keepUnit, _OVER)
   }
 
-  SDB_SET_RESERVE(pRaw, dataPos, TSDB_DB_RESERVE_SIZE, DB_ENCODE_OVER)
+  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)
-  SDB_SET_DATALEN(pRaw, dataPos, DB_ENCODE_OVER)
+  SDB_SET_DATALEN(pRaw, dataPos, _OVER)
 
   terrno = 0;
 
-DB_ENCODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("db:%s, failed to encode to raw:%p since %s", pDb->name, pRaw, terrstr());
     sdbFreeRaw(pRaw);
@@ -134,68 +135,71 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int8_t sver = 0;
-  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto DB_DECODE_OVER;
+  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;
 
-  if (sver != TSDB_DB_VER_NUMBER) {
+  if (sver != DB_VER_NUMBER) {
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
-    goto DB_DECODE_OVER;
+    goto _OVER;
   }
 
   SSdbRow *pRow = sdbAllocRow(sizeof(SDbObj));
-  if (pRow == NULL) goto DB_DECODE_OVER;
+  if (pRow == NULL) goto _OVER;
 
   SDbObj *pDb = sdbGetRowObj(pRow);
-  if (pDb == NULL) goto DB_DECODE_OVER;
+  if (pDb == NULL) goto _OVER;
 
   int32_t dataPos = 0;
-  SDB_GET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, DB_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, _OVER)
-  SDB_GET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, DB_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, _OVER)
-  SDB_GET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, DB_DECODE_OVER)
+  SDB_GET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pDb->createdTime, DB_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pDb->createdTime, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pDb->updateTime, DB_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pDb->updateTime, _OVER)
-  SDB_GET_INT64(pRaw, dataPos, &pDb->uid, DB_DECODE_OVER)
+  SDB_GET_INT64(pRaw, dataPos, &pDb->uid, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfgVersion, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfgVersion, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->vgVersion, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->vgVersion, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pDb->hashMethod, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfVgroups, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfVgroups, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.cacheBlockSize, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.cacheBlockSize, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.totalBlocks, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.totalBlocks, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysPerFile, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysPerFile, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep0, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep0, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep1, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep1, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep2, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep2, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.minRows, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.minRows, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.maxRows, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.maxRows, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.commitTime, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.commitTime, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.fsyncPeriod, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.fsyncPeriod, DB_DECODE_OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.ttl, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.walLevel, DB_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.walLevel, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.precision, DB_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.precision, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compression, DB_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compression, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.replications, DB_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.replications, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.quorum, DB_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.strict, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.update, DB_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.update, _OVER)
-  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.cacheLastRow, DB_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.cacheLastRow, _OVER)
-  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfRetensions, DB_DECODE_OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.streamMode, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.singleSTable, _OVER)
+  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.hashMethod, _OVER)
+  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfRetensions, _OVER)
   if (pDb->cfg.numOfRetensions > 0) {
     pDb->cfg.pRetensions = taosArrayInit(pDb->cfg.numOfRetensions, sizeof(SRetention));
-    if (pDb->cfg.pRetensions == NULL) goto DB_DECODE_OVER;
+    if (pDb->cfg.pRetensions == NULL) goto _OVER;
     for (int32_t i = 0; i < pDb->cfg.numOfRetensions; ++i) {
       SRetention retension = {0};
-      SDB_GET_INT32(pRaw, dataPos, &retension.freq, DB_DECODE_OVER)
+      SDB_GET_INT32(pRaw, dataPos, &retension.freq, _OVER)
-      SDB_GET_INT32(pRaw, dataPos, &retension.keep, DB_DECODE_OVER)
+      SDB_GET_INT32(pRaw, dataPos, &retension.keep, _OVER)
-      SDB_GET_INT8(pRaw, dataPos, &retension.freqUnit, DB_DECODE_OVER)
+      SDB_GET_INT8(pRaw, dataPos, &retension.freqUnit, _OVER)
-      SDB_GET_INT8(pRaw, dataPos, &retension.keepUnit, DB_DECODE_OVER)
+      SDB_GET_INT8(pRaw, dataPos, &retension.keepUnit, _OVER)
       if (taosArrayPush(pDb->cfg.pRetensions, &retension) == NULL) {
-        goto DB_DECODE_OVER;
+        goto _OVER;
       }
     }
   }
 
-  SDB_GET_RESERVE(pRaw, dataPos, TSDB_DB_RESERVE_SIZE, DB_DECODE_OVER)
+  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)
 
   terrno = 0;
 
-DB_DECODE_OVER:
+_OVER:
   if (terrno != 0) {
     mError("db:%s, failed to decode from raw:%p since %s", pDb->name, pRaw, terrstr());
     taosMemoryFreeClear(pRow);
@@ -244,7 +248,7 @@ void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {
   sdbRelease(pSdb, pDb);
 }
 
-static int32_t mndCheckDbName(char *dbName, SUserObj *pUser) {
+static int32_t mndCheckDbName(const char *dbName, SUserObj *pUser) {
   char *pos = strstr(dbName, TS_PATH_DELIMITER);
   if (pos == NULL) {
     terrno = TSDB_CODE_MND_INVALID_DB;
@@ -271,23 +275,24 @@ static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
   if (pCfg->daysToKeep0 < pCfg->daysPerFile) return -1;
   if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return -1;
   if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return -1;
-  if (pCfg->minRows < TSDB_MIN_MIN_ROW_FBLOCK || pCfg->minRows > TSDB_MAX_MIN_ROW_FBLOCK) return -1;
+  if (pCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return -1;
-  if (pCfg->maxRows < TSDB_MIN_MAX_ROW_FBLOCK || pCfg->maxRows > TSDB_MAX_MAX_ROW_FBLOCK) return -1;
+  if (pCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return -1;
   if (pCfg->minRows > pCfg->maxRows) return -1;
   if (pCfg->commitTime < TSDB_MIN_COMMIT_TIME || pCfg->commitTime > TSDB_MAX_COMMIT_TIME) return -1;
   if (pCfg->fsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->fsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return -1;
-  if (pCfg->ttl < TSDB_MIN_DB_TTL_OPTION && pCfg->ttl != TSDB_DEFAULT_DB_TTL_OPTION) return -1;
+  if (pCfg->ttl < TSDB_MIN_DB_TTL) return -1;
   if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) return -1;
   if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) return -1;
   if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) return -1;
-  if (pCfg->replications < TSDB_MIN_DB_REPLICA_OPTION || pCfg->replications > TSDB_MAX_DB_REPLICA_OPTION) return -1;
+  if (pCfg->replications < TSDB_MIN_DB_REPLICA || pCfg->replications > TSDB_MAX_DB_REPLICA) return -1;
   if (pCfg->replications > mndGetDnodeSize(pMnode)) return -1;
-  if (pCfg->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCfg->quorum > TSDB_MAX_DB_QUORUM_OPTION) return -1;
+  if (pCfg->strict < TSDB_DB_STRICT_OFF || pCfg->strict > TSDB_DB_STRICT_ON) return -1;
-  if (pCfg->quorum > pCfg->replications) return -1;
+  if (pCfg->strict > pCfg->replications) return -1;
   if (pCfg->update < TSDB_MIN_DB_UPDATE || pCfg->update > TSDB_MAX_DB_UPDATE) return -1;
   if (pCfg->cacheLastRow < TSDB_MIN_DB_CACHE_LAST_ROW || pCfg->cacheLastRow > TSDB_MAX_DB_CACHE_LAST_ROW) return -1;
-  if (pCfg->streamMode < TSDB_MIN_DB_STREAM_MODE || pCfg->streamMode > TSDB_MAX_DB_STREAM_MODE) return -1;
+  if (pCfg->streamMode < TSDB_DB_STREAM_MODE_OFF || pCfg->streamMode > TSDB_DB_STREAM_MODE_ON) return -1;
-  if (pCfg->singleSTable < TSDB_MIN_DB_SINGLE_STABLE_OPTION || pCfg->streamMode > TSDB_MAX_DB_SINGLE_STABLE_OPTION) return -1;
+  if (pCfg->singleSTable < TSDB_DB_SINGLE_STABLE_ON || pCfg->streamMode > TSDB_DB_SINGLE_STABLE_OFF) return -1;
+  if (pCfg->hashMethod != 1) return -1;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -299,20 +304,20 @@ static void mndSetDefaultDbCfg(SDbCfg *pCfg) {
   if (pCfg->daysToKeep0 < 0) pCfg->daysToKeep0 = TSDB_DEFAULT_KEEP;
   if (pCfg->daysToKeep1 < 0) pCfg->daysToKeep1 = pCfg->daysToKeep0;
   if (pCfg->daysToKeep2 < 0) pCfg->daysToKeep2 = pCfg->daysToKeep1;
-  if (pCfg->minRows < 0) pCfg->minRows = TSDB_DEFAULT_MIN_ROW_FBLOCK;
+  if (pCfg->minRows < 0) pCfg->minRows = TSDB_DEFAULT_MINROWS_FBLOCK;
-  if (pCfg->maxRows < 0) pCfg->maxRows = TSDB_DEFAULT_MAX_ROW_FBLOCK;
+  if (pCfg->maxRows < 0) pCfg->maxRows = TSDB_DEFAULT_MAXROWS_FBLOCK;
   if (pCfg->commitTime < 0) pCfg->commitTime = TSDB_DEFAULT_COMMIT_TIME;
   if (pCfg->fsyncPeriod < 0) pCfg->fsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD;
-  if (pCfg->ttl < 0) pCfg->ttl = TSDB_DEFAULT_DB_TTL_OPTION;
+  if (pCfg->ttl < 0) pCfg->ttl = TSDB_DEFAULT_DB_TTL;
   if (pCfg->walLevel < 0) pCfg->walLevel = TSDB_DEFAULT_WAL_LEVEL;
   if (pCfg->precision < 0) pCfg->precision = TSDB_DEFAULT_PRECISION;
   if (pCfg->compression < 0) pCfg->compression = TSDB_DEFAULT_COMP_LEVEL;
-  if (pCfg->replications < 0) pCfg->replications = TSDB_DEFAULT_DB_REPLICA_OPTION;
+  if (pCfg->replications < 0) pCfg->replications = TSDB_DEFAULT_DB_REPLICA;
-  if (pCfg->quorum < 0) pCfg->quorum = TSDB_DEFAULT_DB_QUORUM_OPTION;
+  if (pCfg->strict < 0) pCfg->strict = TSDB_DEFAULT_DB_STRICT;
-  if (pCfg->update < 0) pCfg->update = TSDB_DEFAULT_DB_UPDATE_OPTION;
+  if (pCfg->update < 0) pCfg->update = TSDB_DEFAULT_DB_UPDATE;
   if (pCfg->cacheLastRow < 0) pCfg->cacheLastRow = TSDB_DEFAULT_CACHE_LAST_ROW;
   if (pCfg->streamMode < 0) pCfg->streamMode = TSDB_DEFAULT_DB_STREAM_MODE;
-  if (pCfg->singleSTable < 0) pCfg->singleSTable = TSDB_DEFAULT_DB_SINGLE_STABLE_OPTION;
+  if (pCfg->singleSTable < 0) pCfg->singleSTable = TSDB_DEFAULT_DB_SINGLE_STABLE;
   if (pCfg->numOfRetensions < 0) pCfg->numOfRetensions = 0;
 }
 
@@ -435,7 +440,6 @@ static int32_t mndCreateDb(SMnode *pMnode, SNodeMsg *pReq, SCreateDbReq *pCreate
   dbObj.uid = mndGenerateUid(dbObj.name, TSDB_DB_FNAME_LEN);
   dbObj.cfgVersion = 1;
   dbObj.vgVersion = 1;
-  dbObj.hashMethod = 1;
   memcpy(dbObj.createUser, pUser->user, TSDB_USER_LEN);
   dbObj.cfg = (SDbCfg){
       .numOfVgroups = pCreate->numOfVgroups,
@@ -454,11 +458,12 @@ static int32_t mndCreateDb(SMnode *pMnode, SNodeMsg *pReq, SCreateDbReq *pCreate
       .precision = pCreate->precision,
       .compression = pCreate->compression,
       .replications = pCreate->replications,
-      .quorum = pCreate->quorum,
+      .strict = pCreate->strict,
       .update = pCreate->update,
       .cacheLastRow = pCreate->cacheLastRow,
       .streamMode = pCreate->streamMode,
       .singleSTable = pCreate->singleSTable,
+      .hashMethod = 1,
   };
 
   dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;
@@ -486,21 +491,21 @@ static int32_t mndCreateDb(SMnode *pMnode, SNodeMsg *pReq, SCreateDbReq *pCreate
 
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_DB, &pReq->rpcMsg);
-  if (pTrans == NULL) goto CREATE_DB_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create db:%s", pTrans->id, pCreate->db);
 
   mndTransSetDbInfo(pTrans, &dbObj);
-  if (mndSetCreateDbRedoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto CREATE_DB_OVER;
+  if (mndSetCreateDbRedoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto CREATE_DB_OVER;
+  if (mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto CREATE_DB_OVER;
+  if (mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndSetCreateDbRedoActions(pMnode, pTrans, &dbObj, pVgroups) != 0) goto CREATE_DB_OVER;
+  if (mndSetCreateDbRedoActions(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndSetCreateDbUndoActions(pMnode, pTrans, &dbObj, pVgroups) != 0) goto CREATE_DB_OVER;
+  if (mndSetCreateDbUndoActions(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto CREATE_DB_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-CREATE_DB_OVER:
+_OVER:
   taosMemoryFree(pVgroups);
   mndTransDrop(pTrans);
   return code;
@@ -515,7 +520,7 @@ static int32_t mndProcessCreateDbReq(SNodeMsg *pReq) {
 
   if (tDeserializeSCreateDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &createReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto CREATE_DB_OVER;
+    goto _OVER;
   }
 
   mDebug("db:%s, start to create, vgroups:%d", createReq.db, createReq.numOfVgroups);
@@ -525,28 +530,28 @@ static int32_t mndProcessCreateDbReq(SNodeMsg *pReq) {
     if (createReq.ignoreExist) {
       mDebug("db:%s, already exist, ignore exist is set", createReq.db);
       code = 0;
-      goto CREATE_DB_OVER;
+      goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_DB_ALREADY_EXIST;
-      goto CREATE_DB_OVER;
+      goto _OVER;
     }
   } else if (terrno != TSDB_CODE_MND_DB_NOT_EXIST) {
-    goto CREATE_DB_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
-    goto CREATE_DB_OVER;
+    goto _OVER;
   }
 
   if (mndCheckCreateDbAuth(pUser) != 0) {
-    goto CREATE_DB_OVER;
+    goto _OVER;
   }
 
   code = mndCreateDb(pMnode, pReq, &createReq, pUser);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-CREATE_DB_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("db:%s, failed to create since %s", createReq.db, terrstr());
   }
@@ -591,8 +596,8 @@ static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
     terrno = 0;
   }
 
-  if (pAlter->quorum >= 0 && pAlter->quorum != pDb->cfg.quorum) {
+  if (pAlter->strict >= 0 && pAlter->strict != pDb->cfg.strict) {
-    pDb->cfg.quorum = pAlter->quorum;
+    pDb->cfg.strict = pAlter->strict;
     terrno = 0;
   }
 
@@ -601,10 +606,15 @@ static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
     terrno = 0;
   }
 
+  if (pAlter->replications >= 0 && pAlter->replications != pDb->cfg.replications) {
+    pDb->cfg.replications = pAlter->replications;
+    terrno = 0;
+  }
+
   return terrno;
 }
 
-static int32_t mndSetUpdateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
+static int32_t mndSetAlterDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
   SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);
   if (pRedoRaw == NULL) return -1;
   if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
@@ -613,7 +623,7 @@ static int32_t mndSetUpdateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pO
   return 0;
 }
 
-static int32_t mndSetUpdateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
+static int32_t mndSetAlterDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
   SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);
   if (pCommitRaw == NULL) return -1;
   if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
@@ -622,7 +632,65 @@ static int32_t mndSetUpdateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *
   return 0;
 }
 
-static int32_t mndBuildUpdateVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
+void *mndBuildAlterVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen) {
+  SAlterVnodeReq alterReq = {0};
+  alterReq.vgVersion = pVgroup->version;
+  alterReq.totalBlocks = pDb->cfg.totalBlocks;
+  alterReq.daysToKeep0 = pDb->cfg.daysToKeep0;
+  alterReq.daysToKeep1 = pDb->cfg.daysToKeep1;
+  alterReq.daysToKeep2 = pDb->cfg.daysToKeep2;
+  alterReq.walLevel = pDb->cfg.walLevel;
+  alterReq.strict = pDb->cfg.strict;
+  alterReq.cacheLastRow = pDb->cfg.cacheLastRow;
+  alterReq.replica = pVgroup->replica;
+  alterReq.selfIndex = -1;
+
+  for (int32_t v = 0; v < pVgroup->replica; ++v) {
+    SReplica  *pReplica = &alterReq.replicas[v];
+    SVnodeGid *pVgid = &pVgroup->vnodeGid[v];
+    SDnodeObj *pVgidDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
+    if (pVgidDnode == NULL) {
+      return NULL;
+    }
+
+    pReplica->id = pVgidDnode->id;
+    pReplica->port = pVgidDnode->port;
+    memcpy(pReplica->fqdn, pVgidDnode->fqdn, TSDB_FQDN_LEN);
+    mndReleaseDnode(pMnode, pVgidDnode);
+
+    if (pDnode->id == pVgid->dnodeId) {
+      alterReq.selfIndex = v;
+    }
+  }
+
+  if (alterReq.selfIndex == -1) {
+    terrno = TSDB_CODE_MND_APP_ERROR;
+    return NULL;
+  }
+
+  int32_t contLen = tSerializeSAlterVnodeReq(NULL, 0, &alterReq);
+  if (contLen < 0) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+  contLen += +sizeof(SMsgHead);
+
+  void *pReq = taosMemoryMalloc(contLen);
+  if (pReq == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  SMsgHead *pHead = pReq;
+  pHead->contLen = htonl(contLen);
+  pHead->vgId = htonl(pVgroup->vgId);
+
+  tSerializeSAlterVnodeReq((char *)pReq + sizeof(SMsgHead), contLen, &alterReq);
+  *pContLen = contLen;
+  return pReq;
+}
+
+static int32_t mndBuilAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
   for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
     STransAction action = {0};
     SVnodeGid   *pVgid = pVgroup->vnodeGid + vn;
@@ -633,12 +701,12 @@ static int32_t mndBuildUpdateVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
     mndReleaseDnode(pMnode, pDnode);
 
     int32_t contLen = 0;
-    void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen);
+    void   *pReq = mndBuildAlterVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen);
     if (pReq == NULL) return -1;
 
     action.pCont = pReq;
     action.contLen = contLen;
-    action.msgType = TDMT_DND_ALTER_VNODE;
+    action.msgType = TDMT_VND_ALTER_VNODE;
     if (mndTransAppendRedoAction(pTrans, &action) != 0) {
       taosMemoryFree(pReq);
       return -1;
@@ -648,7 +716,7 @@ static int32_t mndBuildUpdateVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
   return 0;
 }
 
-static int32_t mndSetUpdateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
+static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
 
@@ -658,7 +726,7 @@ static int32_t mndSetUpdateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     if (pIter == NULL) break;
 
     if (pVgroup->dbUid == pNew->uid) {
-      if (mndBuildUpdateVgroupAction(pMnode, pTrans, pNew, pVgroup) != 0) {
+      if (mndBuilAlterVgroupAction(pMnode, pTrans, pNew, pVgroup) != 0) {
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pVgroup);
         return -1;
@@ -671,17 +739,17 @@ static int32_t mndSetUpdateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
   return 0;
 }
 
-static int32_t mndUpdateDb(SMnode *pMnode, SNodeMsg *pReq, SDbObj *pOld, SDbObj *pNew) {
+static int32_t mndAlterDb(SMnode *pMnode, SNodeMsg *pReq, SDbObj *pOld, SDbObj *pNew) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_ALTER_DB, &pReq->rpcMsg);
   if (pTrans == NULL) goto UPDATE_DB_OVER;
 
-  mDebug("trans:%d, used to update db:%s", pTrans->id, pOld->name);
+  mDebug("trans:%d, used to alter db:%s", pTrans->id, pOld->name);
 
   mndTransSetDbInfo(pTrans, pOld);
-  if (mndSetUpdateDbRedoLogs(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
+  if (mndSetAlterDbRedoLogs(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
-  if (mndSetUpdateDbCommitLogs(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
+  if (mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
-  if (mndSetUpdateDbRedoActions(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
+  if (mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew) != 0) goto UPDATE_DB_OVER;
   if (mndTransPrepare(pMnode, pTrans) != 0) goto UPDATE_DB_OVER;
 
   code = 0;
@@ -716,7 +784,7 @@ static int32_t mndProcessAlterDbReq(SNodeMsg *pReq) {
     goto ALTER_DB_OVER;
   }
 
-  if (mndCheckAlterDropCompactSyncDbAuth(pUser, pDb) != 0) {
+  if (mndCheckAlterDropCompactDbAuth(pUser, pDb) != 0) {
     goto ALTER_DB_OVER;
   }
 
@@ -730,7 +798,7 @@ static int32_t mndProcessAlterDbReq(SNodeMsg *pReq) {
 
   dbObj.cfgVersion++;
   dbObj.updateTime = taosGetTimestampMs();
-  code = mndUpdateDb(pMnode, pReq, pDb, &dbObj);
+  code = mndAlterDb(pMnode, pReq, pDb, &dbObj);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
 ALTER_DB_OVER:
@@ -745,11 +813,11 @@ ALTER_DB_OVER:
 }
 
 static int32_t mndProcessGetDbCfgReq(SNodeMsg *pReq) {
-  SMnode     *pMnode = pReq->pNode;
+  SMnode   *pMnode = pReq->pNode;
-  int32_t     code = -1;
+  int32_t   code = -1;
-  SDbObj     *pDb = NULL;
+  SDbObj   *pDb = NULL;
-  SDbCfgReq   cfgReq = {0};
+  SDbCfgReq cfgReq = {0};
-  SDbCfgRsp   cfgRsp = {0};
+  SDbCfgRsp cfgRsp = {0};
 
   if (tDeserializeSDbCfgReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &cfgReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
@@ -762,29 +830,27 @@ static int32_t mndProcessGetDbCfgReq(SNodeMsg *pReq) {
     goto GET_DB_CFG_OVER;
   }
 
-  cfgRsp.numOfVgroups    = pDb->cfg.numOfVgroups;
+  cfgRsp.numOfVgroups = pDb->cfg.numOfVgroups;
-  cfgRsp.cacheBlockSize  = pDb->cfg.cacheBlockSize;
+  cfgRsp.cacheBlockSize = pDb->cfg.cacheBlockSize;
-  cfgRsp.totalBlocks     = pDb->cfg.totalBlocks;
+  cfgRsp.totalBlocks = pDb->cfg.totalBlocks;
-  cfgRsp.daysPerFile     = pDb->cfg.daysPerFile;
+  cfgRsp.daysPerFile = pDb->cfg.daysPerFile;
-  cfgRsp.daysToKeep0     = pDb->cfg.daysToKeep0;
+  cfgRsp.daysToKeep0 = pDb->cfg.daysToKeep0;
-  cfgRsp.daysToKeep1     = pDb->cfg.daysToKeep1;
+  cfgRsp.daysToKeep1 = pDb->cfg.daysToKeep1;
-  cfgRsp.daysToKeep2     = pDb->cfg.daysToKeep2;
+  cfgRsp.daysToKeep2 = pDb->cfg.daysToKeep2;
-  cfgRsp.minRows         = pDb->cfg.minRows;
+  cfgRsp.minRows = pDb->cfg.minRows;
-  cfgRsp.maxRows         = pDb->cfg.maxRows;
+  cfgRsp.maxRows = pDb->cfg.maxRows;
-  cfgRsp.commitTime      = pDb->cfg.commitTime;
+  cfgRsp.commitTime = pDb->cfg.commitTime;
-  cfgRsp.fsyncPeriod     = pDb->cfg.fsyncPeriod;
+  cfgRsp.fsyncPeriod = pDb->cfg.fsyncPeriod;
-  cfgRsp.ttl             = pDb->cfg.ttl;
+  cfgRsp.ttl = pDb->cfg.ttl;
-  cfgRsp.walLevel        = pDb->cfg.walLevel;
+  cfgRsp.walLevel = pDb->cfg.walLevel;
-  cfgRsp.precision       = pDb->cfg.precision;
+  cfgRsp.precision = pDb->cfg.precision;
-  cfgRsp.compression     = pDb->cfg.compression;
+  cfgRsp.compression = pDb->cfg.compression;
-  cfgRsp.replications    = pDb->cfg.replications;
+  cfgRsp.replications = pDb->cfg.replications;
-  cfgRsp.quorum          = pDb->cfg.quorum;
+  cfgRsp.strict = pDb->cfg.strict;
-  cfgRsp.update          = pDb->cfg.update;
+  cfgRsp.update = pDb->cfg.update;
-  cfgRsp.cacheLastRow    = pDb->cfg.cacheLastRow;
+  cfgRsp.cacheLastRow = pDb->cfg.cacheLastRow;
-  cfgRsp.streamMode      = pDb->cfg.streamMode;
+  cfgRsp.streamMode = pDb->cfg.streamMode;
-  cfgRsp.singleSTable    = pDb->cfg.singleSTable;
+  cfgRsp.singleSTable = pDb->cfg.singleSTable;
-  cfgRsp.numOfRetensions = pDb->cfg.numOfRetensions;
-  cfgRsp.pRetensions     = pDb->cfg.pRetensions;
 
   int32_t contLen = tSerializeSDbCfgRsp(NULL, 0, &cfgRsp);
   void   *pRsp = rpcMallocCont(contLen);
@@ -812,7 +878,6 @@ GET_DB_CFG_OVER:
   return code;
 }
 
-
 static int32_t mndSetDropDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
   SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);
   if (pRedoRaw == NULL) return -1;
@@ -949,25 +1014,25 @@ static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bo
 static int32_t mndDropDb(SMnode *pMnode, SNodeMsg *pReq, SDbObj *pDb) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_TYPE_DROP_DB, &pReq->rpcMsg);
-  if (pTrans == NULL) goto DROP_DB_OVER;
+  if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop db:%s", pTrans->id, pDb->name);
   mndTransSetDbInfo(pTrans, pDb);
 
-  if (mndSetDropDbRedoLogs(pMnode, pTrans, pDb) != 0) goto DROP_DB_OVER;
+  if (mndSetDropDbRedoLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
-  if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) goto DROP_DB_OVER;
+  if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
-  if (mndSetDropDbRedoActions(pMnode, pTrans, pDb) != 0) goto DROP_DB_OVER;
+  if (mndSetDropDbRedoActions(pMnode, pTrans, pDb) != 0) goto _OVER;
 
   int32_t rspLen = 0;
   void   *pRsp = NULL;
-  if (mndBuildDropDbRsp(pDb, &rspLen, &pRsp, false) < 0) goto DROP_DB_OVER;
+  if (mndBuildDropDbRsp(pDb, &rspLen, &pRsp, false) < 0) goto _OVER;
   mndTransSetRpcRsp(pTrans, pRsp, rspLen);
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_DB_OVER;
+  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
 
   code = 0;
 
-DROP_DB_OVER:
+_OVER:
   mndTransDrop(pTrans);
   return code;
 }
@@ -981,7 +1046,7 @@ static int32_t mndProcessDropDbReq(SNodeMsg *pReq) {
 
   if (tDeserializeSDropDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &dropReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto DROP_DB_OVER;
+    goto _OVER;
   }
 
   mDebug("db:%s, start to drop", dropReq.db);
@@ -990,26 +1055,26 @@ static int32_t mndProcessDropDbReq(SNodeMsg *pReq) {
   if (pDb == NULL) {
     if (dropReq.ignoreNotExists) {
       code = mndBuildDropDbRsp(pDb, &pReq->rspLen, &pReq->pRsp, true);
-      goto DROP_DB_OVER;
+      goto _OVER;
     } else {
       terrno = TSDB_CODE_MND_DB_NOT_EXIST;
-      goto DROP_DB_OVER;
+      goto _OVER;
     }
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
-    goto DROP_DB_OVER;
+    goto _OVER;
   }
 
-  if (mndCheckAlterDropCompactSyncDbAuth(pUser, pDb) != 0) {
+  if (mndCheckAlterDropCompactDbAuth(pUser, pDb) != 0) {
-    goto DROP_DB_OVER;
+    goto _OVER;
   }
 
   code = mndDropDb(pMnode, pReq, pDb);
   if (code == 0) code = TSDB_CODE_MND_ACTION_IN_PROGRESS;
 
-DROP_DB_OVER:
+_OVER:
   if (code != 0 && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
     mError("db:%s, failed to drop since %s", dropReq.db, terrstr());
   }
@@ -1104,7 +1169,7 @@ int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUs
   pRsp->uid = pDb->uid;
   pRsp->vgVersion = pDb->vgVersion;
   pRsp->vgNum = taosArrayGetSize(pRsp->pVgroupInfos);
-  pRsp->hashMethod = pDb->hashMethod;
+  pRsp->hashMethod = pDb->cfg.hashMethod;
   return 0;
 }
 
@@ -1247,7 +1312,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
     usedbRsp.uid = pDb->uid;
     usedbRsp.vgVersion = pDb->vgVersion;
     usedbRsp.vgNum = (int32_t)taosArrayGetSize(usedbRsp.pVgroupInfos);
-    usedbRsp.hashMethod = pDb->hashMethod;
+    usedbRsp.hashMethod = pDb->cfg.hashMethod;
 
     taosArrayPush(batchUseRsp.pArray, &usedbRsp);
     mndReleaseDb(pMnode, pDb);
@@ -1269,47 +1334,6 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
   return 0;
 }
 
-static int32_t mndProcessSyncDbReq(SNodeMsg *pReq) {
-  SMnode    *pMnode = pReq->pNode;
-  int32_t    code = -1;
-  SDbObj    *pDb = NULL;
-  SUserObj  *pUser = NULL;
-  SSyncDbReq syncReq = {0};
-
-  if (tDeserializeSSyncDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &syncReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto SYNC_DB_OVER;
-  }
-
-  mDebug("db:%s, start to sync", syncReq.db);
-
-  pDb = mndAcquireDb(pMnode, syncReq.db);
-  if (pDb == NULL) {
-    goto SYNC_DB_OVER;
-  }
-
-  pUser = mndAcquireUser(pMnode, pReq->user);
-  if (pUser == NULL) {
-    goto SYNC_DB_OVER;
-  }
-
-  if (mndCheckAlterDropCompactSyncDbAuth(pUser, pDb) != 0) {
-    goto SYNC_DB_OVER;
-  }
-
-  // code = mndSyncDb();
-
-SYNC_DB_OVER:
-  if (code != 0) {
-    mError("db:%s, failed to process sync db req since %s", syncReq.db, terrstr());
-  }
-
-  mndReleaseDb(pMnode, pDb);
-  mndReleaseUser(pMnode, pUser);
-
-  return code;
-}
-
 static int32_t mndProcessCompactDbReq(SNodeMsg *pReq) {
   SMnode       *pMnode = pReq->pNode;
   int32_t       code = -1;
@@ -1317,30 +1341,30 @@ static int32_t mndProcessCompactDbReq(SNodeMsg *pReq) {
   SUserObj     *pUser = NULL;
   SCompactDbReq compactReq = {0};
 
-  if (tDeserializeSSyncDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &compactReq) != 0) {
+  if (tDeserializeSCompactDbReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &compactReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    goto SYNC_DB_OVER;
+    goto _OVER;
   }
 
   mDebug("db:%s, start to sync", compactReq.db);
 
   pDb = mndAcquireDb(pMnode, compactReq.db);
   if (pDb == NULL) {
-    goto SYNC_DB_OVER;
+    goto _OVER;
   }
 
   pUser = mndAcquireUser(pMnode, pReq->user);
   if (pUser == NULL) {
-    goto SYNC_DB_OVER;
+    goto _OVER;
   }
 
-  if (mndCheckAlterDropCompactSyncDbAuth(pUser, pDb) != 0) {
+  if (mndCheckAlterDropCompactDbAuth(pUser, pDb) != 0) {
-    goto SYNC_DB_OVER;
+    goto _OVER;
   }
 
-  // code = mndSyncDb();
+  // code = mndCompactDb();
 
-SYNC_DB_OVER:
+_OVER:
   if (code != 0) {
     mError("db:%s, failed to process compact db req since %s", compactReq.db, terrstr());
   }
@@ -1351,27 +1375,23 @@ SYNC_DB_OVER:
   return code;
 }
 
-char *mndGetDbStr(char *src) {
+const char *mndGetDbStr(const char *src) {
   char *pos = strstr(src, TS_PATH_DELIMITER);
   if (pos != NULL) ++pos;
-
+  if (pos == NULL) return src;
-  if (pos == NULL) {
-    return src;
-  }
-
   return pos;
 }
 
-static void dumpDbInfoData(SSDataBlock* pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows, int64_t numOfTables, bool sysDb) {
+static void dumpDbInfoData(SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows, int64_t numOfTables,
+                           bool sysDb) {
   int32_t cols = 0;
 
-  char* buf = taosMemoryMalloc(pShow->bytes[cols]);
+  char       *buf = taosMemoryMalloc(pShow->bytes[cols]);
-  char *name = mndGetDbStr(pDb->name);
+  const char *name = mndGetDbStr(pDb->name);
   if (name != NULL) {
     STR_WITH_MAXSIZE_TO_VARSTR(buf, name, pShow->bytes[cols]);
   } else {
-//    STR_TO_VARSTR(pWrite, "NULL");
+    STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", pShow->bytes[cols]);
-    ASSERT(0);
   }
 
   char *status = "ready";
@@ -1379,8 +1399,8 @@ static void dumpDbInfoData(SSDataBlock* pBlock, SDbObj *pDb, SShowObj *pShow, in
   STR_WITH_SIZE_TO_VARSTR(b, status, strlen(status));
 
   if (sysDb) {
-    for(int32_t i = 0; i < pShow->numOfColumns; ++i) {
+    for (int32_t i = 0; i < pShow->numOfColumns; ++i) {
-      SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);
+      SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, i);
       if (i == 0) {
         colDataAppend(pColInfo, rows, buf, false);
       } else if (i == 3) {
@@ -1408,8 +1428,11 @@ static void dumpDbInfoData(SSDataBlock* pBlock, SDbObj *pDb, SShowObj *pShow, in
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.replications, false);
 
+    const char *src = pDb->cfg.strict ? "strict" : "nostrict";
+    char        b[9 + VARSTR_HEADER_SIZE] = {0};
+    STR_WITH_SIZE_TO_VARSTR(b, src, strlen(src));
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.quorum, false);
+    colDataAppend(pColInfo, rows, (const char *)b, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     colDataAppend(pColInfo, rows, (const char *)&pDb->cfg.daysPerFile, false);
@@ -1488,7 +1511,6 @@ static void dumpDbInfoData(SSDataBlock* pBlock, SDbObj *pDb, SShowObj *pShow, in
 
   //  pWrite = getDataPosition(data, pShow, cols, rows, rowCapacity);
   //  *(int8_t *)pWrite = pDb->cfg.update;
-
 }
 
 static void setInformationSchemaDbCfg(SDbObj *pDbObj) {
@@ -1497,19 +1519,19 @@ static void setInformationSchemaDbCfg(SDbObj *pDbObj) {
 
   pDbObj->createdTime = 0;
   pDbObj->cfg.numOfVgroups = 0;
-  pDbObj->cfg.quorum = 1;
+  pDbObj->cfg.strict = 1;
   pDbObj->cfg.replications = 1;
   pDbObj->cfg.update = 1;
   pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;
 }
 
-static void setPerfSchemaDbCfg(SDbObj* pDbObj) {
+static void setPerfSchemaDbCfg(SDbObj *pDbObj) {
   ASSERT(pDbObj != NULL);
   strncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));
 
   pDbObj->createdTime = 0;
   pDbObj->cfg.numOfVgroups = 0;
-  pDbObj->cfg.quorum = 1;
+  pDbObj->cfg.strict = 1;
   pDbObj->cfg.replications = 1;
   pDbObj->cfg.update = 1;
   pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;
@@ -1523,7 +1545,7 @@ static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, v
   return true;
 }
 
-static int32_t mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock* pBlock, int32_t rowsCapacity) {
+static int32_t mndRetrieveDbs(SNodeMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
   SMnode *pMnode = pReq->pNode;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
@@ -1571,10 +1593,10 @@ static void mndCancelGetNextDb(SMnode *pMnode, void *pIter) {
 
 static int32_t mndProcessGetIndexReq(SNodeMsg *pReq) {
   SUserIndexReq indexReq = {0};
-  SMnode      *pMnode = pReq->pNode;
+  SMnode       *pMnode = pReq->pNode;
-  int32_t      code = -1;
+  int32_t       code = -1;
   SUserIndexRsp rsp = {0};
-  bool exist = false;
+  bool          exist = false;
 
   if (tDeserializeSUserIndexReq(pReq->rpcMsg.pCont, pReq->rpcMsg.contLen, &indexReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
@@ -1587,7 +1609,7 @@ static int32_t mndProcessGetIndexReq(SNodeMsg *pReq) {
   }
 
   if (!exist) {
-    //TODO GET INDEX FROM FULLTEXT
+    // TODO GET INDEX FROM FULLTEXT
     code = -1;
     terrno = TSDB_CODE_MND_DB_INDEX_NOT_EXIST;
   } else {
@@ -1598,9 +1620,9 @@ static int32_t mndProcessGetIndexReq(SNodeMsg *pReq) {
       code = -1;
       goto _OVER;
     }
-    
+
     tSerializeSUserIndexRsp(pRsp, contLen, &rsp);
-    
+
     pReq->pRsp = pRsp;
     pReq->rspLen = contLen;
 
@@ -1614,4 +1636,3 @@ _OVER:
 
   return code;
 }
-

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/mndFunc.c

@@ -77,7 +77,9 @@ static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) {
   SDB_SET_INT64(pRaw, dataPos, pFunc->signature, _OVER)
   SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, _OVER)
   SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, _OVER)
-  SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER)
+  if (pFunc->commentSize > 0) {
+    SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER)
+  }
   SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER)
   SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER)
   SDB_SET_DATALEN(pRaw, dataPos, _OVER);
@@ -125,13 +127,18 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, _OVER)
   SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, _OVER)
 
-  pFunc->pComment = taosMemoryCalloc(1, pFunc->commentSize);
+  if (pFunc->commentSize > 0) {
-  pFunc->pCode = taosMemoryCalloc(1, pFunc->codeSize);
+    pFunc->pComment = taosMemoryCalloc(1, pFunc->commentSize);
-  if (pFunc->pComment == NULL || pFunc->pCode == NULL) {
+    if (pFunc->pComment == NULL) {
-    goto _OVER;
+      goto _OVER;
+    }
+    SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER)
   }
 
-  SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, _OVER)
+  pFunc->pCode = taosMemoryCalloc(1, pFunc->codeSize);
+  if (pFunc->pCode == NULL) {
+    goto _OVER;
+  }
   SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, _OVER)
   SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, _OVER)
 
@@ -192,16 +199,20 @@ static int32_t mndCreateFunc(SMnode *pMnode, SNodeMsg *pReq, SCreateFuncReq *pCr
   func.outputLen = pCreate->outputLen;
   func.bufSize = pCreate->bufSize;
   func.signature = pCreate->signature;
-  func.commentSize = strlen(pCreate->pComment) + 1;
+  if (NULL != pCreate->pComment) {
-  func.codeSize = strlen(pCreate->pCode) + 1;
+    func.commentSize = strlen(pCreate->pComment) + 1;
-  func.pComment = taosMemoryMalloc(func.commentSize);
+    func.pComment = taosMemoryMalloc(func.commentSize);
+  }
+  func.codeSize = pCreate->codeLen;
   func.pCode = taosMemoryMalloc(func.codeSize);
   if (func.pCode == NULL || func.pCode == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
 
-  memcpy(func.pComment, pCreate->pComment, func.commentSize);
+  if (func.commentSize > 0) {
+    memcpy(func.pComment, pCreate->pComment, func.commentSize);
+  }
   memcpy(func.pCode, pCreate->pCode, func.codeSize);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_TYPE_CREATE_FUNC, &pReq->rpcMsg);
@@ -293,16 +304,6 @@ static int32_t mndProcessCreateFuncReq(SNodeMsg *pReq) {
     goto _OVER;
   }
 
-  if (createReq.pComment == NULL) {
-    terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT;
-    goto _OVER;
-  }
-
-  if (createReq.pComment[0] == 0) {
-    terrno = TSDB_CODE_MND_INVALID_FUNC_COMMENT;
-    goto _OVER;
-  }
-
   if (createReq.pCode == NULL) {
     terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
     goto _OVER;
@@ -440,14 +441,20 @@ static int32_t mndProcessRetrieveFuncReq(SNodeMsg *pReq) {
     funcInfo.signature = pFunc->signature;
     funcInfo.commentSize = pFunc->commentSize;
     funcInfo.codeSize = pFunc->codeSize;
-    funcInfo.pCode = taosMemoryCalloc(1, sizeof(funcInfo.codeSize));
+    funcInfo.pCode = taosMemoryCalloc(1, funcInfo.codeSize);
-    funcInfo.pComment = taosMemoryCalloc(1, sizeof(funcInfo.commentSize));
+    if (funcInfo.pCode == NULL) {
-    if (funcInfo.pCode == NULL || funcInfo.pComment == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       goto RETRIEVE_FUNC_OVER;
     }
-    memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
     memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize);
+    if (funcInfo.commentSize > 0) {
+      funcInfo.pComment = taosMemoryCalloc(1, funcInfo.commentSize);
+      if (funcInfo.pComment == NULL) {
+        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        goto RETRIEVE_FUNC_OVER;
+      }
+      memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
+    }
     taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo);
     mndReleaseFunc(pMnode, pFunc);
   }

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/mndTelem.c

@@ -21,23 +21,66 @@
 #include "thttp.h"
 #include "tjson.h"
 
-#define TELEMETRY_SERVER "telemetry.taosdata.com"
+typedef struct {
-#define TELEMETRY_PORT   80
+  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);
+  }
+
+  pStat->numOfChildTable = 100;
+  pStat->numOfColumn = 200;
+  pStat->totalPoints = 300;
+  pStat->totalStorage = 400;
+  pStat->compStorage = 500;
+}
 
 static void mndBuildRuntimeInfo(SMnode* pMnode, SJson* pJson) {
-  SMnodeLoad load = {0};
+  SMnodeStat mstat = {0};
-  mndGetLoad(pMnode, &load);
+  mndGetStat(pMnode, &mstat);
 
-  tjsonAddDoubleToObject(pJson, "numOfDnode", load.numOfDnode);
+  tjsonAddDoubleToObject(pJson, "numOfDnode", mstat.numOfDnode);
-  tjsonAddDoubleToObject(pJson, "numOfMnode", load.numOfMnode);
+  tjsonAddDoubleToObject(pJson, "numOfMnode", mstat.numOfMnode);
-  tjsonAddDoubleToObject(pJson, "numOfVgroup", load.numOfVgroup);
+  tjsonAddDoubleToObject(pJson, "numOfVgroup", mstat.numOfVgroup);
-  tjsonAddDoubleToObject(pJson, "numOfDatabase", load.numOfDatabase);
+  tjsonAddDoubleToObject(pJson, "numOfDatabase", mstat.numOfDatabase);
-  tjsonAddDoubleToObject(pJson, "numOfSuperTable", load.numOfSuperTable);
+  tjsonAddDoubleToObject(pJson, "numOfSuperTable", mstat.numOfSuperTable);
-  tjsonAddDoubleToObject(pJson, "numOfChildTable", load.numOfChildTable);
+  tjsonAddDoubleToObject(pJson, "numOfChildTable", mstat.numOfChildTable);
-  tjsonAddDoubleToObject(pJson, "numOfColumn", load.numOfColumn);
+  tjsonAddDoubleToObject(pJson, "numOfColumn", mstat.numOfColumn);
-  tjsonAddDoubleToObject(pJson, "numOfPoint", load.totalPoints);
+  tjsonAddDoubleToObject(pJson, "numOfPoint", mstat.totalPoints);
-  tjsonAddDoubleToObject(pJson, "totalStorage", load.totalStorage);
+  tjsonAddDoubleToObject(pJson, "totalStorage", mstat.totalStorage);
-  tjsonAddDoubleToObject(pJson, "compStorage", load.compStorage);
+  tjsonAddDoubleToObject(pJson, "compStorage", mstat.compStorage);
 }
 
 static char* mndBuildTelemetryReport(SMnode* pMnode) {
@@ -82,12 +125,14 @@ static char* mndBuildTelemetryReport(SMnode* pMnode) {
 static int32_t mndProcessTelemTimer(SNodeMsg* pReq) {
   SMnode*     pMnode = pReq->pNode;
   STelemMgmt* pMgmt = &pMnode->telemMgmt;
-  if (!pMgmt->enable) return 0;
+  if (!tsEnableTelem) return 0;
 
   taosWLockLatch(&pMgmt->lock);
   char* pCont = mndBuildTelemetryReport(pMnode);
   if (pCont != NULL) {
-    taosSendHttpReport(TELEMETRY_SERVER, TELEMETRY_PORT, pCont, strlen(pCont), HTTP_FLAT);
+    if (taosSendHttpReport(tsTelemServer, tsTelemPort, pCont, strlen(pCont), HTTP_FLAT) != 0) {
+      mError("failed to send telemetry msg");
+    }
     taosMemoryFree(pCont);
   }
   taosWUnLockLatch(&pMgmt->lock);
@@ -98,7 +143,6 @@ int32_t mndInitTelem(SMnode* pMnode) {
   STelemMgmt* pMgmt = &pMnode->telemMgmt;
 
   taosInitRWLatch(&pMgmt->lock);
-  pMgmt->enable = tsEnableTelemetryReporting;
   taosGetEmail(pMgmt->email, sizeof(pMgmt->email));
   mndSetMsgHandle(pMnode, TDMT_MND_TELEM_TIMER, mndProcessTelemTimer);
 

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_VND_COMPACT_VNODE_RSP, mndProcessCompactVnodeRsp);
-  mndSetMsgHandle(pMnode, TDMT_DND_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

@@ -45,7 +45,6 @@
 
 #define MQ_TIMER_MS    3000
 #define TRNAS_TIMER_MS 6000
-#define TELEM_TIMER_MS 86400000
 
 static void *mndBuildTimerMsg(int32_t *pContLen) {
   SMTimerReq timerReq = {0};
@@ -97,7 +96,7 @@ static void mndPullupTelem(void *param, void *tmrId) {
     tmsgPutToQueue(&pMnode->msgCb, READ_QUEUE, &rpcMsg);
   }
 
-  taosTmrReset(mndPullupTelem, TELEM_TIMER_MS, pMnode, pMnode->timer, &pMnode->telemTimer);
+  taosTmrReset(mndPullupTelem, tsTelemInterval * 1000, pMnode, pMnode->timer, &pMnode->telemTimer);
 }
 
 static int32_t mndInitTimer(SMnode *pMnode) {
@@ -117,7 +116,8 @@ static int32_t mndInitTimer(SMnode *pMnode) {
     return -1;
   }
 
-  if (taosTmrReset(mndPullupTelem, 60000, pMnode, pMnode->timer, &pMnode->telemTimer)) {
+  int32_t interval = tsTelemInterval < 10 ? tsTelemInterval : 10;
+  if (taosTmrReset(mndPullupTelem, interval * 1000, pMnode, pMnode->timer, &pMnode->telemTimer)) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
@@ -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;
+}

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/func/func.cpp

@@ -32,6 +32,7 @@ void MndTestFunc::SetCode(SCreateFuncReq* pReq, const char* pCode) {
   int32_t len = strlen(pCode);
   pReq->pCode = (char*)taosMemoryCalloc(1, len + 1);
   strcpy(pReq->pCode, pCode);
+  pReq->codeLen = len;
 }
 
 void MndTestFunc::SetComment(SCreateFuncReq* pReq, const char* pComment) {
@@ -60,21 +61,6 @@ TEST_F(MndTestFunc, 02_Create_Func) {
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_NAME);
   }
 
-  {
-    SCreateFuncReq createReq = {0};
-    strcpy(createReq.name, "f1");
-    SetCode(&createReq, "code1");
-
-    int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
-    void*   pReq = rpcMallocCont(contLen);
-    tSerializeSCreateFuncReq(pReq, contLen, &createReq);
-    tFreeSCreateFuncReq(&createReq);
-
-    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
-    ASSERT_NE(pRsp, nullptr);
-    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT);
-  }
-
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
@@ -90,22 +76,6 @@ TEST_F(MndTestFunc, 02_Create_Func) {
     ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_CODE);
   }
 
-  {
-    SCreateFuncReq createReq = {0};
-    strcpy(createReq.name, "f1");
-    SetCode(&createReq, "code1");
-    SetComment(&createReq, "");
-
-    int32_t contLen = tSerializeSCreateFuncReq(NULL, 0, &createReq);
-    void*   pReq = rpcMallocCont(contLen);
-    tSerializeSCreateFuncReq(pReq, contLen, &createReq);
-    tFreeSCreateFuncReq(&createReq);
-
-    SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_FUNC, pReq, contLen);
-    ASSERT_NE(pRsp, nullptr);
-    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_FUNC_COMMENT);
-  }
-
   {
     SCreateFuncReq createReq = {0};
     strcpy(createReq.name, "f1");
@@ -329,7 +299,6 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
     EXPECT_EQ(pFuncInfo->bufSize, 6);
     EXPECT_EQ(pFuncInfo->signature, 18);
     EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1);
-    EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1);
 
     EXPECT_STREQ("comment2", pFuncInfo->pComment);
     EXPECT_STREQ("code2", pFuncInfo->pCode);
@@ -368,7 +337,6 @@ TEST_F(MndTestFunc, 03_Retrieve_Func) {
       EXPECT_EQ(pFuncInfo->bufSize, 6);
       EXPECT_EQ(pFuncInfo->signature, 18);
       EXPECT_EQ(pFuncInfo->commentSize, strlen("comment2") + 1);
-      EXPECT_EQ(pFuncInfo->codeSize, strlen("code2") + 1);
       EXPECT_STREQ("comment2", pFuncInfo->pComment);
       EXPECT_STREQ("code2", pFuncInfo->pCode);
     }

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/tsdbCommit.c

@@ -1350,7 +1350,7 @@ int tsdbWriteBlockImpl(STsdb *pRepo, STable *pTable, SDFile *pDFile, SDFile *pDF
       if (tBitmaps > 0) {
         bptr = POINTER_SHIFT(pBlockData, lsize + flen);
         if (isSuper && !tdDataColsIsBitmapI(pDataCols)) {
-          tdMergeBitmap((uint8_t *)pDataCol->pBitmap, nBitmaps, (uint8_t *)pDataCol->pBitmap);
+          tdMergeBitmap((uint8_t *)pDataCol->pBitmap, rowsToWrite, (uint8_t *)pDataCol->pBitmap);
         }
         tBitmapsLen =
             tsCompressTinyint((char *)pDataCol->pBitmap, tBitmaps, tBitmaps, bptr, tBitmaps + COMP_OVERFLOW_BYTES,

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 "
+          "vgId:%d invalid minRowsPerFileBlock configuration! minRowsPerFileBlock %d TSDB_MIN_MINROWS_FBLOCK %d "
-          "TSDB_MAX_MIN_ROW_FBLOCK %d",
+          "TSDB_MAX_MINROWS_FBLOCK %d",
-          pCfg->tsdbId, pCfg->minRowsPerFileBlock, TSDB_MIN_MIN_ROW_FBLOCK, TSDB_MAX_MIN_ROW_FBLOCK);
+          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 "
+          "vgId:%d invalid maxRowsPerFileBlock configuration! maxRowsPerFileBlock %d TSDB_MIN_MAXROWS_FBLOCK %d "
-          "TSDB_MAX_MAX_ROW_FBLOCK %d",
+          "TSDB_MAX_MAXROWS_FBLOCK %d",
-          pCfg->tsdbId, pCfg->maxRowsPerFileBlock, TSDB_MIN_MIN_ROW_FBLOCK, TSDB_MAX_MIN_ROW_FBLOCK);
+          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

@@ -652,7 +652,7 @@ static bool initTableMemIterator(STsdbReadHandle* pHandle, STableCheckInfo* pChe
   STbData** pMem = NULL;
   STbData** pIMem = NULL;
 
-  TSKEY tLastKey = 0;  /// keyToTkey(pCheckInfo->lastKey);
+  TSKEY tLastKey = keyToTkey(pCheckInfo->lastKey);
   if (pHandle->pTsdb->mem != NULL) {
     pMem = taosHashGet(pHandle->pTsdb->mem->pHashIdx, &pCheckInfo->tableId, sizeof(pCheckInfo->tableId));
     if (pMem != NULL) {

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

@@ -305,7 +305,7 @@ int tsdbLoadBlockDataCols(SReadH *pReadh, SBlock *pBlock, SBlockInfo *pBlkInfo,
       SDataCol *pDataCol = pReadh->pDCols[0]->cols + i;
       if (pDataCol->bitmap) {
         ASSERT(pDataCol->colId != PRIMARYKEY_TIMESTAMP_COL_ID);
-        tdMergeBitmap(pDataCol->pBitmap, TD_BITMAP_BYTES(pReadh->pDCols[0]->numOfRows), pDataCol->pBitmap);
+        tdMergeBitmap(pDataCol->pBitmap, pReadh->pDCols[0]->numOfRows, pDataCol->pBitmap);
         tdDataColsSetBitmapI(pReadh->pDCols[0]);
       }
     }

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

@@ -427,6 +427,7 @@ typedef struct STableIntervalOperatorInfo {
   EOPTR_EXEC_MODEL   execModel;          // operator execution model [batch model|stream model]
   SArray*            pUpdatedWindow;     // updated time window due to the input data block from the downstream operator.
   STimeWindowAggSupp twAggSup;
+  struct SFillInfo*  pFillInfo;          // fill info
 } STableIntervalOperatorInfo;
 
 typedef struct SAggOperatorInfo {
@@ -467,7 +468,6 @@ typedef struct SFillOperatorInfo {
   SSDataBlock*      existNewGroupBlock;
   bool              multigroupResult;
   SInterval         intervalInfo;
-  int32_t           capacity;
 } SFillOperatorInfo;
 
 typedef struct {
@@ -609,7 +609,7 @@ int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t
 int32_t initAggInfo(SOptrBasicInfo* pBasicInfo, SAggSupporter* pAggSup, SExprInfo* pExprInfo, int32_t numOfCols,
                     SSDataBlock* pResultBlock, size_t keyBufSize, const char* pkey);
 void    initResultSizeInfo(SOperatorInfo* pOperator, int32_t numOfRows);
-void    toSDatablock(SSDataBlock* pBlock, int32_t rowCapacity, SGroupResInfo* pGroupResInfo, SExprInfo* pExprInfo,
+void    doBuildResultDatablock(SSDataBlock* pBlock, int32_t rowCapacity, SGroupResInfo* pGroupResInfo, SExprInfo* pExprInfo,
                      SDiskbasedBuf* pBuf, int32_t* rowCellOffset);
 void    finalizeMultiTupleQueryResult(SqlFunctionCtx* pCtx, int32_t numOfOutput, SDiskbasedBuf* pBuf,
                                       SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset);
@@ -621,7 +621,7 @@ void    doDestroyBasicInfo(SOptrBasicInfo* pInfo, int32_t numOfOutput);
 int32_t setSDataBlockFromFetchRsp(SSDataBlock* pRes, SLoadRemoteDataInfo* pLoadInfo, int32_t numOfRows, char* pData,
                                   int32_t compLen, int32_t numOfOutput, int64_t startTs, uint64_t* total,
                                   SArray* pColList);
-void getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key, int64_t keyFirst, int64_t keyLast, STimeWindow* win);
+void    getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key, STimeWindow* win);
 
 void    doSetOperatorCompleted(SOperatorInfo* pOperator);
 void    doFilter(const SNode* pFilterNode, SSDataBlock* pBlock);
@@ -645,8 +645,7 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataB
                                               SExecTaskInfo* pTaskInfo, bool showRewrite, int32_t accountId);
 SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,
                                           SSDataBlock* pResBlock, SInterval* pInterval, int32_t primaryTsSlotId,
-                                          STimeWindowAggSupp *pTwAggSupp, const STableGroupInfo* pTableGroupInfo,
+                                          STimeWindowAggSupp *pTwAggSupp, const STableGroupInfo* pTableGroupInfo, SExecTaskInfo* pTaskInfo);
-                                          SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,
                                             SSDataBlock* pResBlock, int64_t gap, STimeWindowAggSupp *pTwAggSupp, SExecTaskInfo* pTaskInfo);
 SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,

source/libs/executor/inc/tfill.h

@@ -22,15 +22,18 @@ extern "C" {
 
 #include "os.h"
 #include "taosdef.h"
+#include "tcommon.h"
 
 struct SSDataBlock;
 
 typedef struct SFillColInfo {
-  STColumn col;             // column info
+//  STColumn col;             // column info
+  SResSchema col;
   int16_t  functionId;      // sql function id
   int16_t  flag;            // column flag: TAG COLUMN|NORMAL COLUMN
   int16_t  tagIndex;        // index of current tag in SFillTagColInfo array list
-  union {int64_t i; double d;} fillVal;
+  int32_t  offset;
+  union {int64_t i; double d;} val;
 } SFillColInfo;
 
 typedef struct {
@@ -57,7 +60,6 @@ typedef struct SFillInfo {
   char *    nextValues;           // next row of data
   char**    pData;                // original result data block involved in filling data
   int32_t   alloc;                // data buffer size in rows
-  int8_t    precision;            // time resoluation
 
   SFillColInfo* pFillCol;         // column info for fill operations
   SFillTagColInfo* pTags;         // tags value for filling gap
@@ -67,7 +69,19 @@ typedef struct SFillInfo {
 int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, int64_t ekey, int32_t maxNumOfRows);
 
 
+void taosFillSetStartInfo(struct SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey);
+void taosResetFillInfo(struct SFillInfo* pFillInfo, TSKEY startTimestamp);
+void taosFillSetInputDataBlock(struct SFillInfo* pFillInfo, const struct SSDataBlock* pInput);
+struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, const struct SValueNode* val);
+bool taosFillHasMoreResults(struct SFillInfo* pFillInfo);
 
+SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int32_t capacity, int32_t numOfCols,
+                                     SInterval* pInterval, int32_t fillType,
+                                     struct SFillColInfo* pCol, const char* id);
+
+void* taosDestroyFillInfo(struct SFillInfo *pFillInfo);
+int64_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, void** output, int32_t capacity);
+int64_t getFillInfoStart(struct SFillInfo *pFillInfo);
 
 
 #ifdef __cplusplus

source/libs/executor/src/executorimpl.c

@@ -14,11 +14,12 @@
  */
 
 #include "filter.h"
-#include "functionMgt.h"
 #include "function.h"
+#include "functionMgt.h"
+#include "os.h"
 #include "querynodes.h"
 #include "tname.h"
-#include "os.h"
+#include "tfill.h"
 
 #include "tdatablock.h"
 #include "tglobal.h"
@@ -514,13 +515,12 @@ static SResultRow* doSetResultOutBufByKey_rv(SDiskbasedBuf* pResultBuf, SResultR
   return pResult;
 }
 
-static void getInitialStartTimeWindow(SInterval* pInterval, int32_t precision, TSKEY ts, STimeWindow* w, TSKEY ekey,
+static void getInitialStartTimeWindow(SInterval* pInterval, int32_t precision, TSKEY ts, STimeWindow* w, bool ascQuery) {
-                                      bool ascQuery) {
   if (ascQuery) {
-    getAlignQueryTimeWindow(pInterval, precision, ts, ts, ekey, w);
+    getAlignQueryTimeWindow(pInterval, precision, ts, w);
   } else {
     // the start position of the first time window in the endpoint that spreads beyond the queried last timestamp
-    getAlignQueryTimeWindow(pInterval, precision, ts, ekey, ts, w);
+    getAlignQueryTimeWindow(pInterval, precision, ts, w);
 
     int64_t key = w->skey;
     while (key < ts) {  // moving towards end
@@ -540,7 +540,7 @@ static STimeWindow getActiveTimeWindow(SDiskbasedBuf * pBuf, SResultRowInfo* pRe
   STimeWindow w = {0};
 
   if (pResultRowInfo->cur.pageId == -1) {  // the first window, from the previous stored value
-    getInitialStartTimeWindow(pInterval, precision, ts, &w, win->ekey, true);
+    getInitialStartTimeWindow(pInterval, precision, ts, &w, true);
     w.ekey = taosTimeAdd(w.skey, pInterval->interval, pInterval->intervalUnit, precision) - 1;
   } else {
     w = getResultRowByPos(pBuf, &pResultRowInfo->cur)->win;
@@ -2015,20 +2015,16 @@ static bool isCachedLastQuery(STaskAttr* pQueryAttr) {
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 // todo refactor : return window
-void getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key, int64_t keyFirst, int64_t keyLast,
+void getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key, STimeWindow* win) {
-                             STimeWindow* win) {
-  ASSERT(key >= keyFirst && key <= keyLast);
   win->skey = taosTimeTruncate(key, pInterval, precision);
 
   /*
    * if the realSkey > INT64_MAX - pInterval->interval, the query duration between
    * realSkey and realEkey must be less than one interval.Therefore, no need to adjust the query ranges.
    */
-  if (keyFirst > (INT64_MAX - pInterval->interval)) {
+  win->ekey = taosTimeAdd(win->skey, pInterval->interval, pInterval->intervalUnit, precision) - 1;
-    assert(keyLast - keyFirst < pInterval->interval);
+  if (win->ekey < win->skey) {
     win->ekey = INT64_MAX;
-  } else {
-    win->ekey = taosTimeAdd(win->skey, pInterval->interval, pInterval->intervalUnit, precision) - 1;
   }
 }
 
@@ -3176,10 +3172,12 @@ int32_t doCopyToSDataBlock(SSDataBlock* pBlock, int32_t rowCapacity, SExprInfo*
 
   // qDebug("QInfo:0x%"PRIx64" copy data to query buf completed", GET_TASKID(pRuntimeEnv));
   pBlock->info.rows = numOfResult;
+  blockDataUpdateTsWindow(pBlock);
+
   return 0;
 }
 
-void toSDatablock(SSDataBlock* pBlock, int32_t rowCapacity, SGroupResInfo* pGroupResInfo, SExprInfo* pExprInfo, SDiskbasedBuf* pBuf,
+void doBuildResultDatablock(SSDataBlock* pBlock, int32_t rowCapacity, SGroupResInfo* pGroupResInfo, SExprInfo* pExprInfo, SDiskbasedBuf* pBuf,
                   int32_t* rowCellOffset) {
   assert(pGroupResInfo->currentGroup <= pGroupResInfo->totalGroup);
 
@@ -4813,7 +4811,7 @@ static SSDataBlock* getAggregateResult(SOperatorInfo* pOperator, bool* newgroup)
   }
 
   blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
-  toSDatablock(pInfo->pRes, pOperator->resultInfo.capacity, &pAggInfo->groupResInfo, pOperator->pExpr, pAggInfo->aggSup.pResultBuf, pInfo->rowCellInfoOffset);
+  doBuildResultDatablock(pInfo->pRes, pOperator->resultInfo.capacity, &pAggInfo->groupResInfo, pOperator->pExpr, pAggInfo->aggSup.pResultBuf, pInfo->rowCellInfoOffset);
   if (pInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pAggInfo->groupResInfo)) {
     doSetOperatorCompleted(pOperator);
   }
@@ -5126,6 +5124,8 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator, bool* newgro
     return NULL;
   }
 
+  SSDataBlock* pBlock = pInfo->binfo.pRes;
+
   if (pInfo->execModel == OPTR_EXEC_MODEL_STREAM) {
     return pOperator->getStreamResFn(pOperator, newgroup);
   } else {
@@ -5134,15 +5134,15 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator, bool* newgro
       return NULL;
     }
 
-    blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+    blockDataEnsureCapacity(pBlock, pOperator->resultInfo.capacity);
-    toSDatablock(pInfo->binfo.pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr,
+    doBuildResultDatablock(pBlock, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr,
-                 pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
+                           pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
 
-    if (pInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
+    if (pBlock->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
       doSetOperatorCompleted(pOperator);
     }
 
-    return pInfo->binfo.pRes->info.rows == 0 ? NULL : pInfo->binfo.pRes;
+    return pBlock->info.rows == 0 ? NULL : pBlock;
   }
 }
 
@@ -5155,7 +5155,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo *pOperator, bool* newgroup
   }
 
   if (pOperator->status == OP_RES_TO_RETURN) {
-    toSDatablock(pInfo->binfo.pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
+    doBuildResultDatablock(pInfo->binfo.pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
     if (pInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
       pOperator->status = OP_EXEC_DONE;
     }
@@ -5190,7 +5190,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo *pOperator, bool* newgroup
 
   initMultiResInfoFromArrayList(&pInfo->groupResInfo, pUpdated);
   blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
-  toSDatablock(pInfo->binfo.pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
+  doBuildResultDatablock(pInfo->binfo.pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
 
   ASSERT(pInfo->binfo.pRes->info.rows > 0);
   pOperator->status = OP_RES_TO_RETURN;
@@ -5205,7 +5205,7 @@ static SSDataBlock* doAllIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) {
 
   STimeSliceOperatorInfo* pSliceInfo = pOperator->info;
   if (pOperator->status == OP_RES_TO_RETURN) {
-    //    toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes);
+    //    doBuildResultDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes);
     if (pSliceInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pSliceInfo->groupResInfo)) {
       doSetOperatorCompleted(pOperator);
     }
@@ -5238,7 +5238,7 @@ static SSDataBlock* doAllIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) {
   finalizeQueryResult(pSliceInfo->binfo.pCtx, pOperator->numOfOutput);
 
   initGroupResInfo(&pSliceInfo->groupResInfo, &pSliceInfo->binfo.resultRowInfo);
-  //  toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pSliceInfo->pRes);
+  //  doBuildResultDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pSliceInfo->pRes);
 
   if (pSliceInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pSliceInfo->groupResInfo)) {
     pOperator->status = OP_EXEC_DONE;
@@ -5292,7 +5292,7 @@ static SSDataBlock* doSTableIntervalAgg(SOperatorInfo* pOperator, bool* newgroup
   OPTR_SET_OPENED(pOperator);
 
   blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
-  toSDatablock(pInfo->binfo.pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr,
+  doBuildResultDatablock(pInfo->binfo.pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr,
                pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
 
   if (pInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
@@ -5383,7 +5383,7 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator, bool* newgroup) {
   SOptrBasicInfo* pBInfo    = &pInfo->binfo;
 
   if (pOperator->status == OP_RES_TO_RETURN) {
-    toSDatablock(pBInfo->pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pBInfo->rowCellInfoOffset);
+    doBuildResultDatablock(pBInfo->pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pBInfo->rowCellInfoOffset);
     if (pBInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
       doSetOperatorCompleted(pOperator);
       return NULL;
@@ -5415,7 +5415,7 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator, bool* newgroup) {
 
   initGroupResInfo(&pInfo->groupResInfo, &pBInfo->resultRowInfo);
   blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
-  toSDatablock(pBInfo->pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pBInfo->rowCellInfoOffset);
+  doBuildResultDatablock(pBInfo->pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pBInfo->rowCellInfoOffset);
   if (pBInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
     doSetOperatorCompleted(pOperator);
   }
@@ -5432,7 +5432,7 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator, bool* newgroup)
   SOptrBasicInfo*          pBInfo = &pInfo->binfo;
 
   if (pOperator->status == OP_RES_TO_RETURN) {
-    toSDatablock(pBInfo->pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pBInfo->rowCellInfoOffset);
+    doBuildResultDatablock(pBInfo->pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pBInfo->rowCellInfoOffset);
     if (pBInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
       doSetOperatorCompleted(pOperator);
       return NULL;
@@ -5464,7 +5464,7 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator, bool* newgroup)
 
   initGroupResInfo(&pInfo->groupResInfo, &pBInfo->resultRowInfo);
   blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
-  toSDatablock(pBInfo->pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pBInfo->rowCellInfoOffset);
+  doBuildResultDatablock(pBInfo->pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pBInfo->rowCellInfoOffset);
   if (pBInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
     doSetOperatorCompleted(pOperator);
   }
@@ -5509,14 +5509,16 @@ static SSDataBlock* doFill(SOperatorInfo* pOperator, bool* newgroup) {
   SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
 
   SResultInfo* pResultInfo = &pOperator->resultInfo;
-  blockDataCleanup(pInfo->pRes);
+  SSDataBlock* pResBlock = pInfo->pRes;
+
+  blockDataCleanup(pResBlock);
   if (pOperator->status == OP_EXEC_DONE) {
     return NULL;
   }
 
   doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, newgroup, pTaskInfo);
-  if (pInfo->pRes->info.rows > pResultInfo->threshold || (!pInfo->multigroupResult && pInfo->pRes->info.rows > 0)) {
+  if (pResBlock->info.rows > pResultInfo->threshold || (!pInfo->multigroupResult && pResBlock->info.rows > 0)) {
-    return pInfo->pRes;
+    return pResBlock;
   }
 
   SOperatorInfo* pDownstream = pOperator->pDownstream[0];
@@ -5551,25 +5553,25 @@ static SSDataBlock* doFill(SOperatorInfo* pOperator, bool* newgroup) {
       }
     }
 
-    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pInfo->capacity, pInfo->p);
+    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pResBlock, pOperator->resultInfo.capacity, pInfo->p);
 
     // current group has no more result to return
-    if (pInfo->pRes->info.rows > 0) {
+    if (pResBlock->info.rows > 0) {
       // 1. The result in current group not reach the threshold of output result, continue
       // 2. If multiple group results existing in one SSDataBlock is not allowed, return immediately
-      if (pInfo->pRes->info.rows > pResultInfo->threshold || pBlock == NULL || (!pInfo->multigroupResult)) {
+      if (pResBlock->info.rows > pResultInfo->threshold || pBlock == NULL || (!pInfo->multigroupResult)) {
-        return pInfo->pRes;
+        return pResBlock;
       }
 
       doHandleRemainBlockFromNewGroup(pInfo, pResultInfo, newgroup, pTaskInfo);
-      if (pInfo->pRes->info.rows > pOperator->resultInfo.threshold || pBlock == NULL) {
+      if (pResBlock->info.rows > pOperator->resultInfo.threshold || pBlock == NULL) {
-        return pInfo->pRes;
+        return pResBlock;
       }
     } else if (pInfo->existNewGroupBlock) {  // try next group
       assert(pBlock != NULL);
       doHandleRemainBlockForNewGroupImpl(pInfo, pResultInfo, newgroup, pTaskInfo);
-      if (pInfo->pRes->info.rows > pResultInfo->threshold) {
+      if (pResBlock->info.rows > pResultInfo->threshold) {
-        return pInfo->pRes;
+        return pResBlock;
       }
     } else {
       return NULL;
@@ -5615,7 +5617,7 @@ int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t n
   _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY);
 
   pAggSup->resultRowSize       = getResultRowSize(pCtx, numOfOutput);
-  pAggSup->keyBuf              = taosMemoryCalloc(1, keyBufSize);
+  pAggSup->keyBuf              = taosMemoryCalloc(1, keyBufSize + POINTER_BYTES + sizeof(int64_t));
   pAggSup->pResultRowHashTable = taosHashInit(10, hashFn, true, HASH_NO_LOCK);
   pAggSup->pResultRowListSet   = taosHashInit(100, hashFn, false, HASH_NO_LOCK);
   pAggSup->pResultRowArrayList = taosArrayInit(10, sizeof(SResultRowCell));
@@ -5878,8 +5880,7 @@ _error:
 
 SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols,
                                           SSDataBlock* pResBlock, SInterval* pInterval, int32_t primaryTsSlotId,
-                                          STimeWindowAggSupp *pTwAggSupp, const STableGroupInfo* pTableGroupInfo,
+                                          STimeWindowAggSupp* pTwAggSupp, const STableGroupInfo* pTableGroupInfo, SExecTaskInfo* pTaskInfo) {
-                                          SExecTaskInfo* pTaskInfo) {
   STableIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableIntervalOperatorInfo));
   SOperatorInfo*              pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pInfo == NULL || pOperator == NULL) {
@@ -5890,10 +5891,8 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo*
   pInfo->interval       = *pInterval;
   pInfo->execModel      = pTaskInfo->execModel;
   pInfo->win            = pTaskInfo->window;
-  pInfo->win.skey       = 0;
-  pInfo->win.ekey       = INT64_MAX;
-  pInfo->primaryTsIndex = primaryTsSlotId;
   pInfo->twAggSup       = *pTwAggSupp;
+  pInfo->primaryTsIndex = primaryTsSlotId;
 
   int32_t numOfRows = 4096;
   size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
@@ -6063,18 +6062,14 @@ _error:
 
 static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t numOfCols, int64_t* fillVal,
                             STimeWindow win, int32_t capacity, const char* id, SInterval* pInterval, int32_t fillType) {
-  struct SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, (int64_t*)fillVal);
+  SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, NULL);
-
-  TSKEY sk = TMIN(win.skey, win.ekey);
-  TSKEY ek = TMAX(win.skey, win.ekey);
 
   // TODO set correct time precision
   STimeWindow w = TSWINDOW_INITIALIZER;
-  getAlignQueryTimeWindow(pInterval, TSDB_TIME_PRECISION_MILLI, win.skey, sk, ek, &w);
+  getAlignQueryTimeWindow(pInterval, TSDB_TIME_PRECISION_MILLI, win.skey, &w);
 
   int32_t order = TSDB_ORDER_ASC;
-  pInfo->pFillInfo = taosCreateFillInfo(order, w.skey, 0, capacity, numOfCols, pInterval->sliding,
+  pInfo->pFillInfo = taosCreateFillInfo(order, w.skey, 0, capacity, numOfCols, pInterval, fillType, pColInfo, id);
-                                        pInterval->slidingUnit, (int8_t)pInterval->precision, fillType, pColInfo, id);
 
   pInfo->p = taosMemoryCalloc(numOfCols, POINTER_BYTES);
 
@@ -6095,23 +6090,37 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExp
   pInfo->multigroupResult = multigroupResult;
   pInfo->intervalInfo = *pInterval;
 
+  int32_t type = TSDB_FILL_NONE;
+  switch (fillType) {
+    case FILL_MODE_PREV: type = TSDB_FILL_PREV;break;
+    case FILL_MODE_NONE: type = TSDB_FILL_NONE;break;
+    case FILL_MODE_NULL: type = TSDB_FILL_NULL;break;
+    case FILL_MODE_NEXT: type = TSDB_FILL_NEXT;break;
+    case FILL_MODE_VALUE: type = TSDB_FILL_SET_VALUE;break;
+    case FILL_MODE_LINEAR: type = TSDB_FILL_LINEAR;break;
+    default:
+      type = TSDB_FILL_NONE;
+  }
+
   SResultInfo* pResultInfo = &pOperator->resultInfo;
-  int32_t      code = initFillInfo(pInfo, pExpr, numOfCols, (int64_t*)fillVal, pTaskInfo->window, pResultInfo->capacity,
+  initResultSizeInfo(pOperator, 4096);
-                                   pTaskInfo->id.str, pInterval, fillType);
+
+  int32_t code = initFillInfo(pInfo, pExpr, numOfCols, (int64_t*)fillVal, pTaskInfo->window, pResultInfo->capacity,
+                              pTaskInfo->id.str, pInterval, type);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
   }
 
-  pOperator->name = "FillOperator";
+  pOperator->name         = "FillOperator";
   pOperator->blockingOptr = false;
-  pOperator->status = OP_NOT_OPENED;
+  pOperator->status       = OP_NOT_OPENED;
   //  pOperator->operatorType = OP_Fill;
-  pOperator->pExpr = pExpr;
+  pOperator->pExpr        = pExpr;
-  pOperator->numOfOutput = numOfCols;
+  pOperator->numOfOutput  = numOfCols;
-  pOperator->info = pInfo;
+  pOperator->info         = pInfo;
-  pOperator->_openFn = operatorDummyOpenFn;
+  pOperator->_openFn      = operatorDummyOpenFn;
-  pOperator->getNextFn = doFill;
+  pOperator->getNextFn    = doFill;
-  pOperator->pTaskInfo = pTaskInfo;
+  pOperator->pTaskInfo    = pTaskInfo;
 
   pOperator->closeFn = destroySFillOperatorInfo;
 
@@ -6582,6 +6591,11 @@ SOperatorInfo* createOperatorTree(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo
 
     int32_t primaryTsSlotId = ((SColumnNode*) pIntervalPhyNode->window.pTspk)->slotId;
     pOptr = createIntervalOperatorInfo(ops[0], pExprInfo, num, pResBlock, &interval, primaryTsSlotId, &as, pTableGroupInfo, pTaskInfo);
+
+    if (pIntervalPhyNode->pFill != NULL) {
+      pOptr = createFillOperatorInfo(pOptr, pExprInfo, num, &interval, pResBlock, pIntervalPhyNode->pFill->mode, NULL, false, pTaskInfo);
+    }
+
   } else if (QUERY_NODE_PHYSICAL_PLAN_SORT == type) {
     SSortPhysiNode* pSortPhyNode = (SSortPhysiNode*)pPhyNode;
 

source/libs/executor/src/groupoperator.c

@@ -265,7 +265,7 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator, bool* newgrou
   SSDataBlock* pRes = pInfo->binfo.pRes;
 
   if (pOperator->status == OP_RES_TO_RETURN) {
-    toSDatablock(pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
+    doBuildResultDatablock(pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
     if (pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) {
       pOperator->status = OP_EXEC_DONE;
     }
@@ -311,7 +311,7 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator, bool* newgrou
   initGroupResInfo(&pInfo->groupResInfo, &pInfo->binfo.resultRowInfo);
 
   while(1) {
-    toSDatablock(pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
+    doBuildResultDatablock(pRes, pOperator->resultInfo.capacity, &pInfo->groupResInfo, pOperator->pExpr, pInfo->aggSup.pResultBuf, pInfo->binfo.rowCellInfoOffset);
     doFilter(pInfo->pCondition, pRes);
 
     bool hasRemain = hasRemainDataInCurrentGroup(&pInfo->groupResInfo);

source/libs/executor/src/scanoperator.c

@@ -129,7 +129,7 @@ static bool overlapWithTimeWindow(SInterval* pInterval, SDataBlockInfo* pBlockIn
 //  TSKEY ek = MAX(pQueryAttr->window.skey, pQueryAttr->window.ekey);
 
   if (true) {
-    getAlignQueryTimeWindow(pInterval, pInterval->precision, pBlockInfo->window.skey, sk, ek, &w);
+    getAlignQueryTimeWindow(pInterval, pInterval->precision, pBlockInfo->window.skey, &w);
     assert(w.ekey >= pBlockInfo->window.skey);
 
     if (w.ekey < pBlockInfo->window.ekey) {
@@ -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;
+  int32_t numRowSteps = TSDB_DEFAULT_MAXROWS_FBLOCK / TSDB_BLOCK_DIST_STEP_ROWS;
-  if (TSDB_DEFAULT_MAX_ROW_FBLOCK % TSDB_BLOCK_DIST_STEP_ROWS != 0) {
+  if (TSDB_DEFAULT_MAXROWS_FBLOCK % TSDB_BLOCK_DIST_STEP_ROWS != 0) {
     ++numRowSteps;
   }
 

source/libs/executor/src/tfill.c

@@ -13,17 +13,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <function.h>
+#include "function.h"
 #include "os.h"
+#include "querynodes.h"
 
 #include "taosdef.h"
 #include "tmsg.h"
 #include "ttypes.h"
 
 #include "tfill.h"
-#include "thash.h"
 #include "function.h"
 #include "tcommon.h"
+#include "thash.h"
 #include "ttime.h"
 
 #define FILL_IS_ASC_FILL(_f) ((_f)->order == TSDB_ORDER_ASC)
@@ -41,7 +42,7 @@ static void setTagsValue(SFillInfo* pFillInfo, void** data, int32_t genRows) {
     assert(pCol->tagIndex >= 0 && pCol->tagIndex < pFillInfo->numOfTags);
     SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
 
-    assert (pTag->col.colId == pCol->col.colId);
+//    assert (pTag->col.colId == pCol->col.colId);
     assignVal(val1, pTag->tagVal, pCol->col.bytes, pCol->col.type);
   }
 }
@@ -80,7 +81,7 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, void** data, char** srcData
         }
 
         char* output = elePtrAt(data[i], pCol->col.bytes, index);
-        assignVal(output, p + pCol->col.offset, pCol->col.bytes, pCol->col.type);
+//        assignVal(output, p + pCol->offset, pCol->col.bytes, pCol->col.type);
       }
     } else {  // no prev value yet, set the value for NULL
       setNullValueForRow(pFillInfo, data, pFillInfo->numOfCols, index);
@@ -96,7 +97,7 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, void** data, char** srcData
         }
 
         char* output = elePtrAt(data[i], pCol->col.bytes, index);
-        assignVal(output, p + pCol->col.offset, pCol->col.bytes, pCol->col.type);
+//        assignVal(output, p + pCol->offset, pCol->col.bytes, pCol->col.type);
       }
     } else { // no prev value yet, set the value for NULL
       setNullValueForRow(pFillInfo, data, pFillInfo->numOfCols, index);
@@ -119,7 +120,7 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, void** data, char** srcData
           continue;
         }
 
-        point1 = (SPoint){.key = *(TSKEY*)(prev), .val = prev + pCol->col.offset};
+        point1 = (SPoint){.key = *(TSKEY*)(prev), .val = prev + pCol->offset};
         point2 = (SPoint){.key = ts, .val = srcData[i] + pFillInfo->index * bytes};
         point  = (SPoint){.key = pFillInfo->currentKey, .val = val1};
         taosGetLinearInterpolationVal(&point, type, &point1, &point2, type);
@@ -135,12 +136,13 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, void** data, char** srcData
       }
 
       char* val1 = elePtrAt(data[i], pCol->col.bytes, index);
-      assignVal(val1, (char*)&pCol->fillVal.i, pCol->col.bytes, pCol->col.type);
+      assignVal(val1, (char*)&pCol->val, pCol->col.bytes, pCol->col.type);
     }
   }
 
   setTagsValue(pFillInfo, data, index);
-  pFillInfo->currentKey = taosTimeAdd(pFillInfo->currentKey, pFillInfo->interval.sliding * step, pFillInfo->interval.slidingUnit, pFillInfo->precision);
+  pFillInfo->currentKey = taosTimeAdd(pFillInfo->currentKey, pFillInfo->interval.sliding * step, pFillInfo->interval.slidingUnit,
+      pFillInfo->interval.precision);
   pFillInfo->numOfCurrent++;
 }
 
@@ -152,7 +154,7 @@ static void initBeforeAfterDataBuf(SFillInfo* pFillInfo, char** next) {
   *next = taosMemoryCalloc(1, pFillInfo->rowSize);
   for (int i = 1; i < pFillInfo->numOfCols; i++) {
     SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-    setNull(*next + pCol->col.offset, pCol->col.type, pCol->col.bytes);
+    setNull(*next + pCol->offset, pCol->col.type, pCol->col.bytes);
   }
 }
 
@@ -160,7 +162,7 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, char** srcData, char* bu
   int32_t rowIndex = pFillInfo->index;
   for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
     SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-    memcpy(buf + pCol->col.offset, srcData[i] + rowIndex * pCol->col.bytes, pCol->col.bytes);
+    memcpy(buf + pCol->offset, srcData[i] + rowIndex * pCol->col.bytes, pCol->col.bytes);
   }
 }
 
@@ -227,21 +229,21 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, void** data, int32_t outputR
         if (i == 0 || (pCol->functionId != FUNCTION_COUNT && !isNull(src, pCol->col.type)) ||
             (pCol->functionId == FUNCTION_COUNT && GET_INT64_VAL(src) != 0)) {
           assignVal(output, src, pCol->col.bytes, pCol->col.type);
-          memcpy(*prev + pCol->col.offset, src, pCol->col.bytes);
+          memcpy(*prev + pCol->offset, src, pCol->col.bytes);
         } else {  // i > 0 and data is null , do interpolation
           if (pFillInfo->type == TSDB_FILL_PREV) {
-            assignVal(output, *prev + pCol->col.offset, pCol->col.bytes, pCol->col.type);
+            assignVal(output, *prev + pCol->offset, pCol->col.bytes, pCol->col.type);
           } else if (pFillInfo->type == TSDB_FILL_LINEAR) {
             assignVal(output, src, pCol->col.bytes, pCol->col.type);
-            memcpy(*prev + pCol->col.offset, src, pCol->col.bytes);
+            memcpy(*prev + pCol->offset, src, pCol->col.bytes);
           } else if (pFillInfo->type == TSDB_FILL_NEXT) {
             if (*next) {
-              assignVal(output, *next + pCol->col.offset, pCol->col.bytes, pCol->col.type);
+              assignVal(output, *next + pCol->offset, pCol->col.bytes, pCol->col.type);
             } else {
               setNull(output, pCol->col.type, pCol->col.bytes);
             }
           } else {
-            assignVal(output, (char*)&pCol->fillVal.i, pCol->col.bytes, pCol->col.type);
+            assignVal(output, (char*)&pCol->val, pCol->col.bytes, pCol->col.type);
           }
         }
       }
@@ -250,7 +252,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, void** data, int32_t outputR
       setTagsValue(pFillInfo, data, pFillInfo->numOfCurrent);
 
       pFillInfo->currentKey = taosTimeAdd(pFillInfo->currentKey, pFillInfo->interval.sliding * step,
-                                          pFillInfo->interval.slidingUnit, pFillInfo->precision);
+                                          pFillInfo->interval.slidingUnit, pFillInfo->interval.precision);
       pFillInfo->index += 1;
       pFillInfo->numOfCurrent += 1;
     }
@@ -301,7 +303,7 @@ static int32_t setTagColumnInfo(SFillInfo* pFillInfo, int32_t numOfCols, int32_t
       bool exists = false;
       int32_t index = -1;
       for (int32_t j = 0; j < k; ++j) {
-        if (pFillInfo->pTags[j].col.colId == pColInfo->col.colId) {
+        if (pFillInfo->pTags[j].col.colId == pColInfo->col.slotId) {
           exists = true;
           index = j;
           break;
@@ -310,7 +312,7 @@ static int32_t setTagColumnInfo(SFillInfo* pFillInfo, int32_t numOfCols, int32_t
 
       if (!exists) {
         SSchema* pSchema = &pFillInfo->pTags[k].col;
-        pSchema->colId = pColInfo->col.colId;
+        pSchema->colId = pColInfo->col.slotId;
         pSchema->type  = pColInfo->col.type;
         pSchema->bytes = pColInfo->col.bytes;
 
@@ -341,30 +343,40 @@ static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) {
 }
 
 struct SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int32_t capacity, int32_t numOfCols,
-                            int64_t slidingTime, int8_t slidingUnit, int8_t precision, int32_t fillType,
+                            SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, const char* id) {
-                            struct SFillColInfo* pCol, const char* id) {
   if (fillType == TSDB_FILL_NONE) {
     return NULL;
   }
 
   SFillInfo* pFillInfo = taosMemoryCalloc(1, sizeof(SFillInfo));
+  if (pFillInfo == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
   taosResetFillInfo(pFillInfo, skey);
 
-  pFillInfo->order     = order;
+  pFillInfo->order = order;
+
+  switch(fillType) {
+    case FILL_MODE_NONE:   pFillInfo->type = TSDB_FILL_NONE;  break;
+    case FILL_MODE_PREV:   pFillInfo->type = TSDB_FILL_PREV;  break;
+    case FILL_MODE_NULL:   pFillInfo->type = TSDB_FILL_NULL;  break;
+    case FILL_MODE_LINEAR: pFillInfo->type = TSDB_FILL_LINEAR;break;
+    case FILL_MODE_NEXT:   pFillInfo->type = TSDB_FILL_NEXT;  break;
+    default:
+      terrno = TSDB_CODE_INVALID_PARA;
+      return NULL;
+  }
+
   pFillInfo->type      = fillType;
   pFillInfo->pFillCol  = pCol;
   pFillInfo->numOfTags = numOfTags;
   pFillInfo->numOfCols = numOfCols;
-  pFillInfo->precision = precision;
   pFillInfo->alloc     = capacity;
   pFillInfo->id        = id;
-
+  pFillInfo->interval  = *pInterval;
-  pFillInfo->interval.interval     = slidingTime;
+  pFillInfo->pData     = taosMemoryMalloc(POINTER_BYTES * numOfCols);
-  pFillInfo->interval.intervalUnit = slidingUnit;
-  pFillInfo->interval.sliding      = slidingTime;
-  pFillInfo->interval.slidingUnit  = slidingUnit;
-
-  pFillInfo->pData = taosMemoryMalloc(POINTER_BYTES * numOfCols);
 
 //  if (numOfTags > 0) {
     pFillInfo->pTags = taosMemoryCalloc(numOfCols, sizeof(SFillTagColInfo));
@@ -375,7 +387,6 @@ struct SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTag
 
   pFillInfo->rowSize = setTagColumnInfo(pFillInfo, pFillInfo->numOfCols, pFillInfo->alloc);
   assert(pFillInfo->rowSize > 0);
-
   return pFillInfo;
 }
 
@@ -417,7 +428,7 @@ void taosFillSetStartInfo(SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey)
 
   pFillInfo->end = endKey;
   if (!FILL_IS_ASC_FILL(pFillInfo)) {
-    pFillInfo->end = taosTimeTruncate(endKey, &pFillInfo->interval, pFillInfo->precision);
+    pFillInfo->end = taosTimeTruncate(endKey, &pFillInfo->interval, pFillInfo->interval.precision);
   }
 
   pFillInfo->index     = 0;
@@ -433,7 +444,7 @@ void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput)
 
     if (TSDB_COL_IS_TAG(pCol->flag)) {  // copy the tag value to tag value buffer
       SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
-      assert (pTag->col.colId == pCol->col.colId);
+      assert (pTag->col.colId == pCol->col.slotId);
       memcpy(pTag->tagVal, pColData->pData, pCol->col.bytes);  // TODO not memcpy??
     }
   }
@@ -460,7 +471,7 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma
 
   TSKEY ekey1 = ekey;
   if (!FILL_IS_ASC_FILL(pFillInfo)) {
-    pFillInfo->end = taosTimeTruncate(ekey, &pFillInfo->interval, pFillInfo->precision);
+    pFillInfo->end = taosTimeTruncate(ekey, &pFillInfo->interval, pFillInfo->interval.precision);
   }
 
   int64_t numOfRes = -1;
@@ -471,7 +482,7 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma
       pFillInfo->currentKey,
       pFillInfo->interval.sliding,
       pFillInfo->interval.slidingUnit,
-      pFillInfo->precision);
+      pFillInfo->interval.precision);
     numOfRes += 1;
     assert(numOfRes >= numOfRows);
   } else { // reach the end of data
@@ -484,7 +495,7 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma
       pFillInfo->currentKey,
       pFillInfo->interval.sliding,
       pFillInfo->interval.slidingUnit,
-      pFillInfo->precision);
+      pFillInfo->interval.precision);
     numOfRes += 1;
   }
 
@@ -527,7 +538,7 @@ int64_t getFillInfoStart(struct SFillInfo *pFillInfo) {
   return pFillInfo->start;
 }
 
-struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, const int64_t* fillVal) {
+struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, const struct SValueNode* val) {
   int32_t offset = 0;
 
   struct SFillColInfo* pFillCol = taosMemoryCalloc(numOfOutput, sizeof(SFillColInfo));
@@ -538,14 +549,15 @@ struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, co
   for(int32_t i = 0; i < numOfOutput; ++i) {
     SExprInfo* pExprInfo   = &pExpr[i];
 
-    pFillCol[i].col.bytes  = pExprInfo->base.resSchema.bytes;
+    pFillCol[i].col        = pExprInfo->base.resSchema;
-    pFillCol[i].col.type   = (int8_t)pExprInfo->base.resSchema.type;
+    pFillCol[i].offset     = offset;
-    pFillCol[i].col.offset = offset;
-    pFillCol[i].col.colId  = pExprInfo->base.resSchema.slotId;
     pFillCol[i].tagIndex   = -2;
-    pFillCol[i].flag       = pExprInfo->base.pParam[0].pCol->flag;    // always be the normal column for table query
+
+    if (pExprInfo->base.numOfParams > 0) {
+      pFillCol[i].flag = pExprInfo->base.pParam[0].pCol->flag;    // always be the normal column for table query
+    }
 //    pFillCol[i].functionId = pExprInfo->pExpr->_function.functionId;
-    pFillCol[i].fillVal.i  = fillVal[i];
+//    pFillCol[i].val.d      = *val;
 
     offset += pExprInfo->base.resSchema.bytes;
   }

source/libs/function/CMakeLists.txt

@@ -14,7 +14,7 @@ target_include_directories(
 
 target_link_libraries(
     function
-    PRIVATE os util common nodes scalar
+    PRIVATE os util common nodes scalar catalog qcom transport
     PUBLIC uv_a
 )
 

source/libs/function/inc/builtins.h

@@ -20,26 +20,7 @@
 extern "C" {
 #endif
 
-#include "functionMgt.h"
+#include "functionMgtInt.h"
-
-#define FUNCTION_NAME_MAX_LENGTH 32
-
-#define FUNC_MGT_FUNC_CLASSIFICATION_MASK(n)    (1 << n)
-
-#define FUNC_MGT_AGG_FUNC               FUNC_MGT_FUNC_CLASSIFICATION_MASK(0)
-#define FUNC_MGT_SCALAR_FUNC            FUNC_MGT_FUNC_CLASSIFICATION_MASK(1)
-#define FUNC_MGT_NONSTANDARD_SQL_FUNC   FUNC_MGT_FUNC_CLASSIFICATION_MASK(2)
-#define FUNC_MGT_STRING_FUNC            FUNC_MGT_FUNC_CLASSIFICATION_MASK(3)
-#define FUNC_MGT_DATETIME_FUNC          FUNC_MGT_FUNC_CLASSIFICATION_MASK(4)
-#define FUNC_MGT_TIMELINE_FUNC          FUNC_MGT_FUNC_CLASSIFICATION_MASK(5)
-#define FUNC_MGT_TIMEORDER_FUNC         FUNC_MGT_FUNC_CLASSIFICATION_MASK(6)
-#define FUNC_MGT_PSEUDO_COLUMN_FUNC     FUNC_MGT_FUNC_CLASSIFICATION_MASK(7)
-#define FUNC_MGT_WINDOW_PC_FUNC         FUNC_MGT_FUNC_CLASSIFICATION_MASK(8)
-#define FUNC_MGT_SPECIAL_DATA_REQUIRED  FUNC_MGT_FUNC_CLASSIFICATION_MASK(9)
-#define FUNC_MGT_DYNAMIC_SCAN_OPTIMIZED FUNC_MGT_FUNC_CLASSIFICATION_MASK(10)
-#define FUNC_MGT_MULTI_RES_FUNC         FUNC_MGT_FUNC_CLASSIFICATION_MASK(11)
-
-#define FUNC_MGT_TEST_MASK(val, mask) (((val) & (mask)) != 0)
 
 typedef int32_t (*FTranslateFunc)(SFunctionNode* pFunc, char* pErrBuf, int32_t len);
 typedef EFuncDataRequired (*FFuncDataRequired)(SFunctionNode* pFunc, STimeWindow* pTimeWindow);

source/libs/function/inc/functionMgtInt.h

@@ -21,9 +21,29 @@ extern "C" {
 #endif
 
 #include "functionMgt.h"
-// #include "builtins.h"
 
+#define FUNCTION_NAME_MAX_LENGTH 32
 
+#define FUNC_MGT_FUNC_CLASSIFICATION_MASK(n)    (1 << n)
+
+#define FUNC_MGT_AGG_FUNC               FUNC_MGT_FUNC_CLASSIFICATION_MASK(0)
+#define FUNC_MGT_SCALAR_FUNC            FUNC_MGT_FUNC_CLASSIFICATION_MASK(1)
+#define FUNC_MGT_NONSTANDARD_SQL_FUNC   FUNC_MGT_FUNC_CLASSIFICATION_MASK(2)
+#define FUNC_MGT_STRING_FUNC            FUNC_MGT_FUNC_CLASSIFICATION_MASK(3)
+#define FUNC_MGT_DATETIME_FUNC          FUNC_MGT_FUNC_CLASSIFICATION_MASK(4)
+#define FUNC_MGT_TIMELINE_FUNC          FUNC_MGT_FUNC_CLASSIFICATION_MASK(5)
+#define FUNC_MGT_TIMEORDER_FUNC         FUNC_MGT_FUNC_CLASSIFICATION_MASK(6)
+#define FUNC_MGT_PSEUDO_COLUMN_FUNC     FUNC_MGT_FUNC_CLASSIFICATION_MASK(7)
+#define FUNC_MGT_WINDOW_PC_FUNC         FUNC_MGT_FUNC_CLASSIFICATION_MASK(8)
+#define FUNC_MGT_SPECIAL_DATA_REQUIRED  FUNC_MGT_FUNC_CLASSIFICATION_MASK(9)
+#define FUNC_MGT_DYNAMIC_SCAN_OPTIMIZED FUNC_MGT_FUNC_CLASSIFICATION_MASK(10)
+#define FUNC_MGT_MULTI_RES_FUNC         FUNC_MGT_FUNC_CLASSIFICATION_MASK(11)
+
+#define FUNC_MGT_TEST_MASK(val, mask) (((val) & (mask)) != 0)
+
+#define FUNC_UDF_ID_START_OFFSET_VAL 5000
+
+extern const int funcMgtUdfNum;
 
 #ifdef __cplusplus
 }

source/libs/function/src/builtins.c

@@ -32,7 +32,7 @@ static int32_t invaildFuncParaNumErrMsg(char* pErrBuf, int32_t len, const char*
 }
 
 static int32_t invaildFuncParaTypeErrMsg(char* pErrBuf, int32_t len, const char* pFuncName) {
-  return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_PARA_TYPE, "Invalid datatypes : %s", pFuncName);
+  return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_PARA_TYPE, "Invalid parameter data type : %s", pFuncName);
 }
 
 static int32_t invaildFuncParaValueErrMsg(char* pErrBuf, int32_t len, const char* pFuncName) {
@@ -327,6 +327,10 @@ static int32_t translateCast(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
       para2Type != TSDB_DATA_TYPE_TIMESTAMP) {
     return invaildFuncParaTypeErrMsg(pErrBuf, len, pFunc->functionName);
   }
+  if ((para2Type == TSDB_DATA_TYPE_TIMESTAMP && IS_VAR_DATA_TYPE(para1Type)) ||
+      (para2Type == TSDB_DATA_TYPE_BINARY && para1Type == TSDB_DATA_TYPE_NCHAR)) {
+    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);

source/libs/function/src/functionMgt.c

@@ -20,16 +20,22 @@
 #include "taoserror.h"
 #include "thash.h"
 #include "builtins.h"
+#include "catalog.h"
 
 typedef struct SFuncMgtService {
   SHashObj* pFuncNameHashTable;
+  SArray* pUdfTable; // SUdfInfo
 } SFuncMgtService;
 
+typedef struct SUdfInfo {
+  SDataType outputDt;
+} SUdfInfo;
+
 static SFuncMgtService gFunMgtService;
 static TdThreadOnce functionHashTableInit = PTHREAD_ONCE_INIT;
 static int32_t initFunctionCode = 0;
 
-static void doInitFunctionHashTable() {
+static void doInitFunctionTable() {
   gFunMgtService.pFuncNameHashTable = taosHashInit(funcMgtBuiltinsNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   if (NULL == gFunMgtService.pFuncNameHashTable) {
     initFunctionCode = TSDB_CODE_FAILED;
@@ -42,6 +48,8 @@ static void doInitFunctionHashTable() {
       return;
     }
   }
+
+  gFunMgtService.pUdfTable = NULL;
 }
 
 static bool isSpecificClassifyFunc(int32_t funcId, uint64_t classification) {
@@ -51,25 +59,56 @@ static bool isSpecificClassifyFunc(int32_t funcId, uint64_t classification) {
   return FUNC_MGT_TEST_MASK(funcMgtBuiltins[funcId].classification, classification);
 }
 
+static int32_t getUdfId(const char* pFuncName) {
+  // todo: udf by call catalog
+  if (1) {
+    return -1;
+  }
+  if (NULL == gFunMgtService.pUdfTable) {
+    gFunMgtService.pUdfTable = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SUdfInfo));
+  }
+  SUdfInfo info = {0}; //todo
+  taosArrayPush(gFunMgtService.pUdfTable, &info);
+  return taosArrayGetSize(gFunMgtService.pUdfTable) + FUNC_UDF_ID_START_OFFSET_VAL;
+}
+
+static int32_t getFuncId(const char* pFuncName) {
+  void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, pFuncName, strlen(pFuncName));
+  if (NULL == pVal) {
+    return getUdfId(pFuncName);
+  }
+  return *(int32_t*)pVal;
+}
+
+static int32_t getUdfResultType(SFunctionNode* pFunc) {
+  SUdfInfo* pUdf = taosArrayGet(gFunMgtService.pUdfTable, pFunc->funcId - FUNC_UDF_ID_START_OFFSET_VAL - 1);
+  pFunc->node.resType = pUdf->outputDt;
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t fmFuncMgtInit() {
-  taosThreadOnce(&functionHashTableInit, doInitFunctionHashTable);
+  taosThreadOnce(&functionHashTableInit, doInitFunctionTable);
   return initFunctionCode;
 }
 
 int32_t fmGetFuncInfo(const char* pFuncName, int32_t* pFuncId, int32_t* pFuncType) {
-  void* pVal = taosHashGet(gFunMgtService.pFuncNameHashTable, pFuncName, strlen(pFuncName));
+  *pFuncId = getFuncId(pFuncName);
-  if (NULL == pVal) {
+  if (*pFuncId < 0) {
     return TSDB_CODE_FAILED;
   }
-  *pFuncId = *(int32_t*)pVal;
+  if (fmIsUserDefinedFunc(*pFuncId)) {
-  if (*pFuncId < 0 || *pFuncId >= funcMgtBuiltinsNum) {
+    *pFuncType = FUNCTION_TYPE_UDF;
-    return TSDB_CODE_FAILED;
+  } else {
+    *pFuncType = funcMgtBuiltins[*pFuncId].type;
   }
-  *pFuncType = funcMgtBuiltins[*pFuncId].type;
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t fmGetFuncResultType(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
+  if (fmIsUserDefinedFunc(pFunc->funcId)) {
+    return getUdfResultType(pFunc);
+  }
+
   if (pFunc->funcId < 0 || pFunc->funcId >= funcMgtBuiltinsNum) {
     return TSDB_CODE_FAILED;
   }
@@ -77,7 +116,7 @@ int32_t fmGetFuncResultType(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
 }
 
 EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow) {
-  if (pFunc->funcId < 0 || pFunc->funcId >= funcMgtBuiltinsNum) {
+  if (fmIsUserDefinedFunc(pFunc->funcId) || pFunc->funcId < 0 || pFunc->funcId >= funcMgtBuiltinsNum) {
     return FUNC_DATA_REQUIRED_DATA_LOAD;
   }
   if (NULL == funcMgtBuiltins[pFunc->funcId].dataRequiredFunc) {
@@ -87,7 +126,7 @@ EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWin
 }
 
 int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {
-  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
+  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
     return TSDB_CODE_FAILED;
   }
   pFpSet->getEnv = funcMgtBuiltins[funcId].getEnvFunc;
@@ -98,7 +137,7 @@ int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet) {
 }
 
 int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet) {
-  if (funcId < 0 || funcId >= funcMgtBuiltinsNum) {
+  if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
     return TSDB_CODE_FAILED;
   }
   pFpSet->process = funcMgtBuiltins[funcId].sprocessFunc;
@@ -142,6 +181,10 @@ bool fmIsMultiResFunc(int32_t funcId) {
   return isSpecificClassifyFunc(funcId, FUNC_MGT_MULTI_RES_FUNC);
 }
 
+bool fmIsUserDefinedFunc(int32_t funcId) {
+  return funcId > FUNC_UDF_ID_START_OFFSET_VAL;
+}
+
 void fmFuncMgtDestroy() {
   void* m = gFunMgtService.pFuncNameHashTable;
   if (m != NULL && atomic_val_compare_exchange_ptr((void**)&gFunMgtService.pFuncNameHashTable, m, 0) == m) {

source/libs/function/src/taggfunction.c

@@ -19,14 +19,14 @@
 #include "thash.h"
 #include "ttypes.h"
 
+//#include "tfill.h"
 #include "function.h"
 #include "taggfunction.h"
-#include "tfill.h"
-#include "thistogram.h"
-#include "ttszip.h"
-#include "tpercentile.h"
 #include "tbuffer.h"
 #include "tcompression.h"
+#include "thistogram.h"
+#include "tpercentile.h"
+#include "ttszip.h"
 //#include "queryLog.h"
 #include "tdatablock.h"
 #include "tudf.h"
@@ -3608,7 +3608,7 @@ static void interp_function_impl(SqlFunctionCtx *pCtx) {
           if (isNull((char *)&pCtx->start.val, srcType) || isNull((char *)&pCtx->end.val, srcType)) {
             setNull(pCtx->pOutput, srcType, pCtx->inputBytes);
           } else {
-            taosGetLinearInterpolationVal(&point, pCtx->resDataInfo.type, &point1, &point2, TSDB_DATA_TYPE_DOUBLE);
+//            taosGetLinearInterpolationVal(&point, pCtx->resDataInfo.type, &point1, &point2, TSDB_DATA_TYPE_DOUBLE);
           }
         } else {
           setNull(pCtx->pOutput, srcType, pCtx->inputBytes);
@@ -3681,7 +3681,7 @@ static void interp_function_impl(SqlFunctionCtx *pCtx) {
           if (isNull(start, srcType) || isNull(end, srcType)) {
             setNull(pCtx->pOutput, srcType, pCtx->inputBytes);
           } else {
-            taosGetLinearInterpolationVal(&point, pCtx->resDataInfo.type, &point1, &point2, srcType);
+//            taosGetLinearInterpolationVal(&point, pCtx->resDataInfo.type, &point1, &point2, srcType);
           }
         } else {
           setNull(pCtx->pOutput, srcType, pCtx->inputBytes);
@@ -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;
+    int32_t maxSteps = TSDB_MAX_MAXROWS_FBLOCK/TSDB_BLOCK_DIST_STEP_ROWS;
-    if (TSDB_MAX_MAX_ROW_FBLOCK % TSDB_BLOCK_DIST_STEP_ROWS != 0) {
+    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;
+}

source/libs/nodes/src/nodesUtilFuncs.c

@@ -149,7 +149,9 @@ SNodeptr nodesMakeNode(ENodeType type) {
     case QUERY_NODE_RESET_QUERY_CACHE_STMT:
       return makeNode(type, sizeof(SNode));
     case QUERY_NODE_COMPACT_STMT:
+      break;
     case QUERY_NODE_CREATE_FUNCTION_STMT:
+      return makeNode(type, sizeof(SCreateFunctionStmt));
     case QUERY_NODE_DROP_FUNCTION_STMT:
       break;
     case QUERY_NODE_CREATE_STREAM_STMT:
@@ -167,6 +169,7 @@ SNodeptr nodesMakeNode(ENodeType type) {
     case QUERY_NODE_SHOW_QNODES_STMT:
     case QUERY_NODE_SHOW_SNODES_STMT:
     case QUERY_NODE_SHOW_BNODES_STMT:
+    case QUERY_NODE_SHOW_CLUSTER_STMT:
     case QUERY_NODE_SHOW_DATABASES_STMT:
     case QUERY_NODE_SHOW_FUNCTIONS_STMT:
     case QUERY_NODE_SHOW_INDEXES_STMT:

source/libs/parser/inc/parAst.h

@@ -167,7 +167,7 @@ SNode* createExplainStmt(SAstCreateContext* pCxt, bool analyze, SNode* pOptions,
 SNode* createDescribeStmt(SAstCreateContext* pCxt, SNode* pRealTable);
 SNode* createResetQueryCacheStmt(SAstCreateContext* pCxt);
 SNode* createCompactStmt(SAstCreateContext* pCxt, SNodeList* pVgroups);
-SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool aggFunc, const SToken* pFuncName, const SToken* pLibPath, SDataType dataType, int32_t bufSize);
+SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool aggFunc, const SToken* pFuncName, const SToken* pLibPath, SDataType dataType, int32_t bufSize);
 SNode* createDropFunctionStmt(SAstCreateContext* pCxt, const SToken* pFuncName);
 SNode* createStreamOptions(SAstCreateContext* pCxt);
 SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, const SToken* pStreamName, SNode* pRealTable, SNode* pOptions, SNode* pQuery);

source/libs/parser/inc/sql.y

@@ -346,6 +346,7 @@ cmd ::= SHOW TOPICS.
 cmd ::= SHOW VARIABLES.                                                           { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLE_STMT, NULL, NULL); }
 cmd ::= SHOW BNODES.                                                              { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT, NULL, NULL); }
 cmd ::= SHOW SNODES.                                                              { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT, NULL, NULL); }
+cmd ::= SHOW CLUSTER.                                                             { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT, NULL, NULL); }
 
 db_name_cond_opt(A) ::= .                                                         { A = createDefaultDatabaseCondValue(pCxt); }
 db_name_cond_opt(A) ::= db_name(B) NK_DOT.                                        { A = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &B); }
@@ -413,8 +414,8 @@ explain_options(A) ::= explain_options(B) RATIO NK_FLOAT(C).
 cmd ::= COMPACT VNODES IN NK_LP integer_list(A) NK_RP.                            { pCxt->pRootNode = createCompactStmt(pCxt, A); }
 
 /************************************************ create/drop function ************************************************/
-cmd ::= CREATE agg_func_opt(A) FUNCTION function_name(B) 
+cmd ::= CREATE agg_func_opt(A) FUNCTION not_exists_opt(F) function_name(B) 
-  AS NK_STRING(C) OUTPUTTYPE type_name(D) bufsize_opt(E).                         { pCxt->pRootNode = createCreateFunctionStmt(pCxt, A, &B, &C, D, E); }
+  AS NK_STRING(C) OUTPUTTYPE type_name(D) bufsize_opt(E).                         { pCxt->pRootNode = createCreateFunctionStmt(pCxt, F, A, &B, &C, D, E); }
 cmd ::= DROP FUNCTION function_name(A).                                           { pCxt->pRootNode = createDropFunctionStmt(pCxt, &A); }
 
 %type agg_func_opt                                                                { bool }

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;
@@ -1184,10 +1181,21 @@ SNode* createCompactStmt(SAstCreateContext* pCxt, SNodeList* pVgroups) {
   return pStmt;
 }
 
-SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool aggFunc, const SToken* pFuncName, const SToken* pLibPath, SDataType dataType, int32_t bufSize) {
+SNode* createCreateFunctionStmt(SAstCreateContext* pCxt,
-  SNode* pStmt = nodesMakeNode(QUERY_NODE_CREATE_FUNCTION_STMT);
+    bool ignoreExists, bool aggFunc, const SToken* pFuncName, const SToken* pLibPath, SDataType dataType, int32_t bufSize) {
+  if (pLibPath->n <= 2) {
+    pCxt->valid = false;
+    return NULL;
+  }
+  SCreateFunctionStmt* pStmt = nodesMakeNode(QUERY_NODE_CREATE_FUNCTION_STMT);
   CHECK_OUT_OF_MEM(pStmt);
-  return pStmt;
+  pStmt->ignoreExists = ignoreExists;
+  strncpy(pStmt->funcName, pFuncName->z, pFuncName->n);
+  pStmt->isAgg = aggFunc;
+  strncpy(pStmt->libraryPath, pLibPath->z + 1, pLibPath->n - 2);
+  pStmt->outputDt = dataType;
+  pStmt->bufSize = bufSize;
+  return (SNode*)pStmt;
 }
 
 SNode* createDropFunctionStmt(SAstCreateContext* pCxt, const SToken* pFuncName) {

source/libs/parser/src/parTokenizer.c

@@ -52,6 +52,7 @@ static SKeyword keywordTable[] = {
     {"CACHE",         TK_CACHE},
     {"CACHELAST",     TK_CACHELAST},
     {"CAST",          TK_CAST},
+    {"CLUSTER",       TK_CLUSTER},
     {"COLUMN",        TK_COLUMN},
     {"COMMENT",       TK_COMMENT},
     {"COMP",          TK_COMP},
@@ -248,7 +249,6 @@ static SKeyword keywordTable[] = {
     // {"BEFORE",       TK_BEFORE},
     // {"BEGIN",        TK_BEGIN},
     // {"CASCADE",      TK_CASCADE},
-    // {"CLUSTER",      TK_CLUSTER},
     // {"CONFLICT",     TK_CONFLICT},
     // {"COPY",         TK_COPY},
     // {"DEFERRED",     TK_DEFERRED},

source/libs/parser/src/parTranslater.c

@@ -1349,6 +1349,22 @@ static int32_t translateSelect(STranslateContext* pCxt, SSelectStmt* pSelect) {
   return code;
 }
 
+static int32_t translateSetOperatorImpl(STranslateContext* pCxt, SSetOperator* pSetOperator) {
+  // todo
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t translateSetOperator(STranslateContext* pCxt, SSetOperator* pSetOperator) {
+  int32_t code = translateQuery(pCxt, pSetOperator->pLeft);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = translateQuery(pCxt, pSetOperator->pRight);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = translateSetOperatorImpl(pCxt, pSetOperator);
+  }
+  return code;
+}
+
 static int64_t getUnitPerMinute(uint8_t precision) {
   switch (precision) {
     case TSDB_TIME_PRECISION_MILLI:
@@ -1403,22 +1419,22 @@ static int32_t buildCreateDbReq(STranslateContext* pCxt, SCreateDatabaseStmt* pS
   pReq->daysToKeep0 = GET_OPTION_VAL(nodesListGetNode(pStmt->pOptions->pKeep, 0), TSDB_DEFAULT_KEEP);
   pReq->daysToKeep1 = GET_OPTION_VAL(nodesListGetNode(pStmt->pOptions->pKeep, 1), TSDB_DEFAULT_KEEP);
   pReq->daysToKeep2 = GET_OPTION_VAL(nodesListGetNode(pStmt->pOptions->pKeep, 2), TSDB_DEFAULT_KEEP);
-  pReq->minRows = GET_OPTION_VAL(pStmt->pOptions->pMinRowsPerBlock, TSDB_DEFAULT_MIN_ROW_FBLOCK);
+  pReq->minRows = GET_OPTION_VAL(pStmt->pOptions->pMinRowsPerBlock, TSDB_DEFAULT_MINROWS_FBLOCK);
-  pReq->maxRows = GET_OPTION_VAL(pStmt->pOptions->pMaxRowsPerBlock, TSDB_DEFAULT_MAX_ROW_FBLOCK);
+  pReq->maxRows = GET_OPTION_VAL(pStmt->pOptions->pMaxRowsPerBlock, TSDB_DEFAULT_MAXROWS_FBLOCK);
   pReq->commitTime = -1;
   pReq->fsyncPeriod = GET_OPTION_VAL(pStmt->pOptions->pFsyncPeriod, TSDB_DEFAULT_FSYNC_PERIOD);
   pReq->walLevel = GET_OPTION_VAL(pStmt->pOptions->pWalLevel, TSDB_DEFAULT_WAL_LEVEL);
   pReq->precision = GET_OPTION_VAL(pStmt->pOptions->pPrecision, TSDB_TIME_PRECISION_MILLI);
   pReq->compression = GET_OPTION_VAL(pStmt->pOptions->pCompressionLevel, TSDB_DEFAULT_COMP_LEVEL);
-  pReq->replications = GET_OPTION_VAL(pStmt->pOptions->pReplica, TSDB_DEFAULT_DB_REPLICA_OPTION);
+  pReq->replications = GET_OPTION_VAL(pStmt->pOptions->pReplica, TSDB_DEFAULT_DB_REPLICA);
-  pReq->quorum = GET_OPTION_VAL(pStmt->pOptions->pQuorum, TSDB_DEFAULT_DB_QUORUM_OPTION);
   pReq->update = -1;
   pReq->cacheLastRow = GET_OPTION_VAL(pStmt->pOptions->pCachelast, TSDB_DEFAULT_CACHE_LAST_ROW);
   pReq->ignoreExist = pStmt->ignoreExists;
-  pReq->streamMode = GET_OPTION_VAL(pStmt->pOptions->pStreamMode, TSDB_DEFAULT_DB_STREAM_MODE_OPTION);
+  pReq->streamMode = GET_OPTION_VAL(pStmt->pOptions->pStreamMode, TSDB_DEFAULT_DB_STREAM_MODE);
-  pReq->ttl = GET_OPTION_VAL(pStmt->pOptions->pTtl, TSDB_DEFAULT_DB_TTL_OPTION);
+  pReq->ttl = GET_OPTION_VAL(pStmt->pOptions->pTtl, TSDB_DEFAULT_DB_TTL);
-  pReq->singleSTable = GET_OPTION_VAL(pStmt->pOptions->pSingleStable, TSDB_DEFAULT_DB_SINGLE_STABLE_OPTION);
+  pReq->singleSTable = GET_OPTION_VAL(pStmt->pOptions->pSingleStable, TSDB_DEFAULT_DB_SINGLE_STABLE);
-  // pReq->strict = GET_OPTION_VAL(pStmt->pOptions->pStrict, TSDB_DEFAULT_DB_SINGLE_STABLE_OPTION);
+  pReq->strict = GET_OPTION_VAL(pStmt->pOptions->pStrict, TSDB_DEFAULT_DB_STRICT);
+
   return buildCreateDbRetentions(pStmt->pOptions->pRetentions, pReq);
 }
 
@@ -1485,8 +1501,8 @@ static int32_t checkTtlOption(STranslateContext* pCxt, SValueNode* pVal) {
       return pCxt->errCode;
     }
     int64_t val = pVal->datum.i;
-    if (val < TSDB_MIN_DB_TTL_OPTION) {
+    if (val < TSDB_MIN_DB_TTL) {
-      return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_INVALID_TTL_OPTION, val, TSDB_MIN_DB_TTL_OPTION);
+      return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_INVALID_TTL_OPTION, val, TSDB_MIN_DB_TTL);
     }
   }
   return TSDB_CODE_SUCCESS;
@@ -1593,12 +1609,12 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, SDatabaseOptions* p
     code = checkRangeOption(pCxt, "fsyncPeriod", pOptions->pFsyncPeriod, TSDB_MIN_FSYNC_PERIOD, TSDB_MAX_FSYNC_PERIOD);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkRangeOption(pCxt, "maxRowsPerBlock", pOptions->pMaxRowsPerBlock, TSDB_MIN_MAX_ROW_FBLOCK,
+    code = checkRangeOption(pCxt, "maxRowsPerBlock", pOptions->pMaxRowsPerBlock, TSDB_MIN_MAXROWS_FBLOCK,
-                            TSDB_MAX_MAX_ROW_FBLOCK);
+                            TSDB_MAX_MAXROWS_FBLOCK);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkRangeOption(pCxt, "minRowsPerBlock", pOptions->pMinRowsPerBlock, TSDB_MIN_MIN_ROW_FBLOCK,
+    code = checkRangeOption(pCxt, "minRowsPerBlock", pOptions->pMinRowsPerBlock, TSDB_MIN_MINROWS_FBLOCK,
-                            TSDB_MAX_MIN_ROW_FBLOCK);
+                            TSDB_MAX_MINROWS_FBLOCK);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = checkKeepOption(pCxt, pOptions->pKeep);
@@ -1607,11 +1623,7 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, SDatabaseOptions* p
     code = checkDbPrecisionOption(pCxt, pOptions->pPrecision);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkRangeOption(pCxt, "quorum", pOptions->pQuorum, TSDB_MIN_DB_QUORUM_OPTION, TSDB_MAX_DB_QUORUM_OPTION);
+    code = checkDbEnumOption(pCxt, "replications", pOptions->pReplica, TSDB_MIN_DB_REPLICA, TSDB_MAX_DB_REPLICA);
-  }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = checkDbEnumOption(pCxt, "replications", pOptions->pReplica, TSDB_MIN_DB_REPLICA_OPTION,
-                             TSDB_MAX_DB_REPLICA_OPTION);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = checkTtlOption(pCxt, pOptions->pTtl);
@@ -1623,19 +1635,18 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, SDatabaseOptions* p
     code = checkRangeOption(pCxt, "vgroups", pOptions->pNumOfVgroups, TSDB_MIN_VNODES_PER_DB, TSDB_MAX_VNODES_PER_DB);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkDbEnumOption(pCxt, "singleStable", pOptions->pSingleStable, TSDB_MIN_DB_SINGLE_STABLE_OPTION,
+    code = checkDbEnumOption(pCxt, "singleStable", pOptions->pSingleStable, TSDB_DB_SINGLE_STABLE_ON,
-                             TSDB_MAX_DB_SINGLE_STABLE_OPTION);
+                             TSDB_DB_SINGLE_STABLE_OFF);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkDbEnumOption(pCxt, "streamMode", pOptions->pStreamMode, TSDB_DB_STREAM_MODE_OPTION_OFF,
+    code =
-                             TSDB_DB_STREAM_MODE_OPTION_ON);
+        checkDbEnumOption(pCxt, "streamMode", pOptions->pStreamMode, TSDB_DB_STREAM_MODE_OFF, TSDB_DB_STREAM_MODE_ON);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = checkDbRetentionsOption(pCxt, pOptions->pRetentions);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = checkDbEnumOption(pCxt, "strict", pOptions->pStrict, TSDB_DB_STRICT_OPTION_OFF,
+    code = checkDbEnumOption(pCxt, "strict", pOptions->pStrict, TSDB_DB_STRICT_OFF, TSDB_DB_STRICT_ON);
-                             TSDB_DB_STRICT_OPTION_ON);
   }
   return code;
 }
@@ -1698,7 +1709,7 @@ static void buildAlterDbReq(STranslateContext* pCxt, SAlterDatabaseStmt* pStmt,
   pReq->daysToKeep2 = GET_OPTION_VAL(nodesListGetNode(pStmt->pOptions->pKeep, 2), -1);
   pReq->fsyncPeriod = GET_OPTION_VAL(pStmt->pOptions->pFsyncPeriod, -1);
   pReq->walLevel = GET_OPTION_VAL(pStmt->pOptions->pWalLevel, -1);
-  pReq->quorum = GET_OPTION_VAL(pStmt->pOptions->pQuorum, -1);
+  pReq->strict = GET_OPTION_VAL(pStmt->pOptions->pQuorum, -1);
   pReq->cacheLastRow = GET_OPTION_VAL(pStmt->pOptions->pCachelast, -1);
   pReq->replications = GET_OPTION_VAL(pStmt->pOptions->pReplica, -1);
   return;
@@ -2595,12 +2606,64 @@ static int32_t translateDropStream(STranslateContext* pCxt, SDropStreamStmt* pSt
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t readFromFile(char* pName, int32_t *len, char **buf) {
+  int64_t filesize = 0;
+  if (taosStatFile(pName, &filesize, NULL) < 0) {
+    return TAOS_SYSTEM_ERROR(errno);
+  }
+
+  *len = filesize;
+
+  if (*len <= 0) {
+    return TSDB_CODE_TSC_FILE_EMPTY;
+  }
+
+  *buf = taosMemoryCalloc(1, *len);
+  if (*buf == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  TdFilePtr tfile = taosOpenFile(pName, O_RDONLY | O_BINARY);
+  if (NULL == tfile) {
+    taosMemoryFreeClear(*buf);
+    return TAOS_SYSTEM_ERROR(errno);
+  }
+
+  int64_t s = taosReadFile(tfile, *buf, *len);
+  if (s != *len) {
+    taosCloseFile(&tfile);
+    taosMemoryFreeClear(*buf);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+  taosCloseFile(&tfile);
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t translateCreateFunction(STranslateContext* pCxt, SCreateFunctionStmt* pStmt) {
+  SCreateFuncReq req = {0};
+  strcpy(req.name, pStmt->funcName);
+  req.igExists = pStmt->ignoreExists;
+  req.funcType = pStmt->isAgg ? TSDB_FUNC_TYPE_AGGREGATE : TSDB_FUNC_TYPE_SCALAR;
+  req.scriptType = TSDB_FUNC_SCRIPT_BIN_LIB;
+  req.outputType = pStmt->outputDt.type;
+  req.outputLen = pStmt->outputDt.bytes;
+  req.bufSize = pStmt->bufSize;
+  int32_t code = readFromFile(pStmt->libraryPath, &req.codeLen, &req.pCode);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = buildCmdMsg(pCxt, TDMT_MND_CREATE_FUNC, (FSerializeFunc)tSerializeSCreateFuncReq, &req);
+  }
+  return code;
+}
+
 static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
   int32_t code = TSDB_CODE_SUCCESS;
   switch (nodeType(pNode)) {
     case QUERY_NODE_SELECT_STMT:
       code = translateSelect(pCxt, (SSelectStmt*)pNode);
       break;
+    case QUERY_NODE_SET_OPERATOR:
+      code = translateSetOperator(pCxt, (SSetOperator*)pNode);
+      break;
     case QUERY_NODE_CREATE_DATABASE_STMT:
       code = translateCreateDatabase(pCxt, (SCreateDatabaseStmt*)pNode);
       break;
@@ -2693,6 +2756,9 @@ static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) {
     case QUERY_NODE_DROP_STREAM_STMT:
       code = translateDropStream(pCxt, (SDropStreamStmt*)pNode);
       break;
+    case QUERY_NODE_CREATE_FUNCTION_STMT:
+      code = translateCreateFunction(pCxt, (SCreateFunctionStmt*)pNode);
+      break;
     default:
       break;
   }
@@ -2807,6 +2873,7 @@ static const char* getSysDbName(ENodeType type) {
     case QUERY_NODE_SHOW_BNODES_STMT:
     case QUERY_NODE_SHOW_SNODES_STMT:
     case QUERY_NODE_SHOW_LICENCE_STMT:
+    case QUERY_NODE_SHOW_CLUSTER_STMT:
       return TSDB_INFORMATION_SCHEMA_DB;
     case QUERY_NODE_SHOW_CONNECTIONS_STMT:
     case QUERY_NODE_SHOW_QUERIES_STMT:
@@ -2849,6 +2916,8 @@ static const char* getSysTableName(ENodeType type) {
       return TSDB_INS_TABLE_SNODES;
     case QUERY_NODE_SHOW_LICENCE_STMT:
       return TSDB_INS_TABLE_LICENCES;
+    case QUERY_NODE_SHOW_CLUSTER_STMT:
+      return TSDB_INS_TABLE_CLUSTER;
     case QUERY_NODE_SHOW_CONNECTIONS_STMT:
       return TSDB_PERFS_TABLE_CONNECTIONS;
     case QUERY_NODE_SHOW_QUERIES_STMT:
@@ -3365,6 +3434,7 @@ static int32_t rewriteQuery(STranslateContext* pCxt, SQuery* pQuery) {
     case QUERY_NODE_SHOW_SNODES_STMT:
     case QUERY_NODE_SHOW_CONNECTIONS_STMT:
     case QUERY_NODE_SHOW_QUERIES_STMT:
+    case QUERY_NODE_SHOW_CLUSTER_STMT:
       code = rewriteShow(pCxt, pQuery);
       break;
     case QUERY_NODE_CREATE_TABLE_STMT:

source/libs/planner/src/planLogicCreater.c

@@ -768,6 +768,22 @@ static int32_t createSelectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSele
   return code;
 }
 
+static int32_t createSetOperatorLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
+  SLogicNode* pRoot = NULL;
+  int32_t code = createQueryLogicNode(pCxt, pSetOperator->pLeft, &pRoot);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = createQueryLogicNode(pCxt, pSetOperator->pRight, &pRoot);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    *pLogicNode = pRoot;
+  } else {
+    nodesDestroyNode(pRoot);
+  }
+
+  return code;
+}
+
 static int32_t getMsgType(ENodeType sqlType) {
   return (QUERY_NODE_CREATE_TABLE_STMT == sqlType || QUERY_NODE_CREATE_MULTI_TABLE_STMT == sqlType) ? TDMT_VND_CREATE_TABLE : TDMT_VND_SUBMIT;
 }
@@ -791,6 +807,8 @@ static int32_t createQueryLogicNode(SLogicPlanContext* pCxt, SNode* pStmt, SLogi
       return createVnodeModifLogicNode(pCxt, (SVnodeModifOpStmt*)pStmt, pLogicNode);
     case QUERY_NODE_EXPLAIN_STMT:
       return createQueryLogicNode(pCxt, ((SExplainStmt*)pStmt)->pQuery, pLogicNode);
+    case QUERY_NODE_SET_OPERATOR:
+      return createSetOperatorLogicNode(pCxt, (SSetOperator*)pStmt, pLogicNode);
     default:
       break;
   }

source/libs/scalar/src/sclfunc.c

@@ -587,10 +587,6 @@ static int32_t doTrimFunction(SScalarParam *pInput, int32_t inputNum, SScalarPar
 }
 
 int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
-  if (inputNum != 2 && inputNum!= 3) {
-    return TSDB_CODE_FAILED;
-  }
-
   int32_t subPos = 0;
   GET_TYPED_DATA(subPos, int32_t, GET_PARAM_TYPE(&pInput[1]), pInput[1].columnData->pData);
   if (subPos == 0) { //subPos needs to be positive or negative values;

source/libs/sync/src/syncMain.c

@@ -929,4 +929,17 @@ static void syncFreeNode(void* param) {
   syncNodePrint2((char*)"==syncFreeNode==", pNode);
 
   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";
+  }
 }

tests/script/basicSuite.sim

@@ -1,19 +0,0 @@
-run general/cache/new_metrics.sim
-run general/compute/interval.sim
-run general/http/restful_full.sim 
-run general/import/commit.sim
-run general/import/replica1.sim
-run general/parser/auto_create_tb_drop_tb.sim
-run general/parser/binary_escapeCharacter.sim
-run general/parser/select_from_cache_disk.sim
-run general/parser/null_char.sim
-run general/parser/alter.sim
-run general/stable/vnode3.sim
-run general/tag/filter.sim
-run general/table/vgroup.sim
-run general/user/authority.sim
-run general/vector/metrics_mix.sim
-run general/vector/table_field.sim
-run general/tag/set.sim
-run general/table/delete_writing.sim
-run general/stable/disk.sim

tests/script/bug.sim

@@ -1,2 +0,0 @@
-run general/parser/projection_limit_offset.sim
-run general/parser/limit2.sim

tests/script/fullGeneralSuite.sim

@@ -1,225 +0,0 @@
-#unsupport run general/alter/cached_schema_after_alter.sim
-run general/alter/count.sim
-run general/alter/import.sim
-#unsupport run general/alter/insert1.sim
-run general/alter/insert2.sim
-run general/alter/metrics.sim
-run general/alter/table.sim
-run general/cache/new_metrics.sim
-run general/cache/restart_metrics.sim
-run general/cache/restart_table.sim
-run general/connection/connection.sim  
-run general/column/commit.sim
-run general/column/metrics.sim
-run general/column/table.sim
-run general/compress/commitlog.sim
-run general/compress/compress.sim
-run general/compress/compress2.sim
-run general/compress/uncompress.sim
-run general/compute/avg.sim
-run general/compute/bottom.sim
-run general/compute/count.sim
-run general/compute/diff.sim
-run general/compute/diff2.sim
-run general/compute/first.sim
-run general/compute/interval.sim
-run general/compute/last.sim
-run general/compute/last_row.sim
-run general/compute/leastsquare.sim
-run general/compute/max.sim
-run general/compute/min.sim
-run general/compute/null.sim
-run general/compute/percentile.sim
-run general/compute/stddev.sim
-run general/compute/sum.sim
-run general/compute/top.sim
-run general/compute/block_dist.sim
-run general/db/alter_option.sim
-run general/db/alter_tables_d2.sim
-run general/db/alter_tables_v1.sim
-run general/db/alter_tables_v4.sim
-run general/db/alter_vgroups.sim
-run general/db/basic.sim
-run general/db/basic1.sim
-run general/db/basic2.sim
-run general/db/basic3.sim
-run general/db/basic4.sim
-run general/db/basic5.sim
-run general/db/delete_reuse1.sim
-run general/db/delete_reuse2.sim
-run general/db/delete_reusevnode.sim
-run general/db/delete_reusevnode2.sim
-run general/db/delete_writing1.sim
-run general/db/delete_writing2.sim
-run general/db/delete.sim
-run general/db/len.sim
-run general/db/repeat.sim
-run general/db/tables.sim
-run general/db/vnodes.sim
-run general/field/2.sim
-run general/field/3.sim
-run general/field/4.sim
-run general/field/5.sim
-run general/field/6.sim
-run general/field/bigint.sim
-run general/field/binary.sim
-run general/field/bool.sim
-run general/field/single.sim
-run general/field/smallint.sim
-run general/field/tinyint.sim
-run general/http/restful.sim
-run general/http/restful_insert.sim
-run general/http/restful_limit.sim
-run general/http/restful_full.sim
-run general/http/prepare.sim
-run general/http/telegraf.sim
-run general/http/grafana_bug.sim
-run general/http/grafana.sim
-run general/import/basic.sim
-run general/import/commit.sim
-run general/import/large.sim
-run general/import/replica1.sim
-run general/insert/basic.sim
-run general/insert/insert_drop.sim
-run general/insert/query_block1_memory.sim
-run general/insert/query_block2_memory.sim
-run general/insert/query_block1_file.sim
-run general/insert/query_block2_file.sim
-run general/insert/query_file_memory.sim
-run general/insert/query_multi_file.sim
-run general/insert/tcp.sim
-#unsupport run general/parser/alter.sim
-run general/parser/alter1.sim
-run general/parser/alter_stable.sim
-run general/parser/auto_create_tb.sim
-run general/parser/auto_create_tb_drop_tb.sim
-run general/parser/col_arithmetic_operation.sim
-run general/parser/columnValue.sim
-run general/parser/commit.sim
-run general/parser/create_db.sim
-run general/parser/create_mt.sim
-run general/parser/create_tb.sim
-run general/parser/dbtbnameValidate.sim
-run general/parser/import_commit1.sim
-run general/parser/import_commit2.sim
-run general/parser/import_commit3.sim
-run general/parser/insert_tb.sim
-run general/parser/first_last.sim
-run general/parser/line_insert.sim
-#unsupport run general/parser/import_file.sim
-run general/parser/lastrow.sim
-run general/parser/nchar.sim
-#unsupport run general/parser/null_char.sim
-run general/parser/single_row_in_tb.sim
-run general/parser/select_from_cache_disk.sim
-run general/parser/limit.sim
-run general/parser/limit1.sim
-run general/parser/limit1_tblocks100.sim
-run general/parser/mixed_blocks.sim
-run general/parser/selectResNum.sim
-run general/parser/select_across_vnodes.sim
-run general/parser/slimit1.sim
-run general/parser/tbnameIn.sim
-run general/parser/binary_escapeCharacter.sim
-run general/parser/projection_limit_offset.sim
-run general/parser/limit2.sim
-run general/parser/slimit.sim
-run general/parser/fill.sim
-run general/parser/fill_stb.sim
-run general/parser/interp.sim
-run general/parser/where.sim
-run general/parser/join.sim
-run general/parser/join_multivnode.sim
-run general/parser/select_with_tags.sim
-run general/parser/groupby.sim
-run general/parser/top_groupby.sim
-run general/parser/tags_dynamically_specifiy.sim
-run general/parser/set_tag_vals.sim
-#unsupport run general/parser/repeatAlter.sim
-#unsupport run general/parser/slimit_alter_tags.sim
-run general/parser/precision_ns.sim
-run general/stable/disk.sim
-run general/stable/dnode3.sim
-run general/stable/metrics.sim
-run general/stable/values.sim
-run general/stable/vnode3.sim
-run general/table/autocreate.sim
-run general/table/basic1.sim
-run general/table/basic2.sim
-run general/table/basic3.sim
-run general/table/bigint.sim
-run general/table/binary.sim
-run general/table/bool.sim
-run general/table/column_name.sim
-run general/table/column_num.sim
-run general/table/column_value.sim
-run general/table/column2.sim
-run general/table/date.sim
-run general/table/db.table.sim
-run general/table/delete_reuse1.sim
-run general/table/delete_reuse2.sim
-run general/table/delete_writing.sim
-run general/table/describe.sim
-run general/table/double.sim
-run general/table/fill.sim
-run general/table/float.sim
-run general/table/int.sim
-run general/table/limit.sim
-run general/table/smallint.sim
-run general/table/table_len.sim
-run general/table/table.sim
-run general/table/tinyint.sim
-run general/table/vgroup.sim
-run general/tag/3.sim
-run general/tag/4.sim
-run general/tag/5.sim
-run general/tag/6.sim
-run general/tag/add.sim
-run general/tag/bigint.sim
-run general/tag/binary_binary.sim
-run general/tag/binary.sim
-run general/tag/bool_binary.sim
-run general/tag/bool_int.sim
-run general/tag/bool.sim
-run general/tag/change.sim
-run general/tag/column.sim
-#unsupport run general/tag/commit.sim
-run general/tag/create.sim
-run general/tag/delete.sim
-run general/tag/double.sim
-run general/tag/filter.sim
-run general/tag/float.sim
-run general/tag/int_binary.sim
-run general/tag/int_float.sim
-run general/tag/int.sim
-run general/tag/set.sim
-run general/tag/smallint.sim
-run general/tag/tinyint.sim
-run general/user/authority.sim
-run general/user/monitor.sim
-run general/user/pass_alter.sim
-run general/user/pass_len.sim
-run general/user/user_create.sim
-run general/user/user_len.sim
-run general/vector/metrics_field.sim
-run general/vector/metrics_mix.sim
-run general/vector/metrics_query.sim
-run general/vector/metrics_tag.sim
-run general/vector/metrics_time.sim
-run general/vector/multi.sim
-run general/vector/single.sim
-run general/vector/table_field.sim
-run general/vector/table_mix.sim
-run general/vector/table_query.sim
-run general/vector/table_time.sim
-run general/stream/restart_stream.sim
-run general/stream/stream_3.sim
-run general/stream/stream_restart.sim
-run general/stream/table_del.sim
-run general/stream/metrics_del.sim
-run general/stream/table_replica1_vnoden.sim
-run general/stream/metrics_replica1_vnoden.sim
-run general/db/show_create_db.sim
-run general/db/show_create_table.sim
-run general/parser/like.sim
-run general/parser/regex.sim

tests/script/regressionSuite.sim

@@ -1,221 +0,0 @@
-##unsupport run general/alter/cached_schema_after_alter.sim
-run general/alter/count.sim
-run general/alter/import.sim
-##unsupport run general/alter/insert1.sim
-run general/alter/insert2.sim
-run general/alter/metrics.sim
-run general/alter/table.sim
-run general/cache/new_metrics.sim
-run general/cache/restart_metrics.sim
-run general/cache/restart_table.sim
-run general/connection/connection.sim  
-run general/column/commit.sim
-run general/column/metrics.sim
-run general/column/table.sim
-run general/compress/commitlog.sim
-run general/compress/compress.sim
-run general/compress/compress2.sim
-run general/compress/uncompress.sim
-run general/compute/avg.sim
-run general/compute/bottom.sim
-run general/compute/count.sim
-run general/compute/diff.sim
-run general/compute/diff2.sim
-run general/compute/first.sim
-run general/compute/interval.sim
-run general/compute/last.sim
-run general/compute/leastsquare.sim
-run general/compute/max.sim
-run general/compute/min.sim
-run general/compute/null.sim
-run general/compute/percentile.sim
-run general/compute/stddev.sim
-run general/compute/sum.sim
-run general/compute/top.sim
-run general/compute/block_dist.sim
-run general/db/alter_option.sim
-run general/db/alter_tables_d2.sim
-run general/db/alter_tables_v1.sim
-run general/db/alter_tables_v4.sim
-run general/db/alter_vgroups.sim
-run general/db/basic.sim
-run general/db/basic1.sim
-run general/db/basic2.sim
-run general/db/basic3.sim
-run general/db/basic4.sim
-run general/db/basic5.sim
-run general/db/delete_reuse1.sim
-run general/db/delete_reuse2.sim
-run general/db/delete_reusevnode.sim
-run general/db/delete_reusevnode2.sim
-run general/db/delete_writing1.sim
-run general/db/delete_writing2.sim
-run general/db/delete.sim
-run general/db/len.sim
-run general/db/repeat.sim
-run general/db/tables.sim
-run general/db/vnodes.sim
-run general/field/2.sim
-run general/field/3.sim
-run general/field/4.sim
-run general/field/5.sim
-run general/field/6.sim
-run general/field/bigint.sim
-run general/field/binary.sim
-run general/field/bool.sim
-run general/field/single.sim
-run general/field/smallint.sim
-run general/field/tinyint.sim
-run general/http/restful.sim
-run general/http/restful_insert.sim
-run general/http/restful_limit.sim
-run general/http/restful_full.sim
-run general/http/prepare.sim
-run general/http/telegraf.sim
-run general/http/grafana_bug.sim
-run general/http/grafana.sim
-run general/import/basic.sim
-run general/import/commit.sim
-run general/import/large.sim
-run general/import/replica1.sim
-run general/insert/basic.sim
-run general/insert/insert_drop.sim
-run general/insert/query_block1_memory.sim
-run general/insert/query_block2_memory.sim
-run general/insert/query_block1_file.sim
-run general/insert/query_block2_file.sim
-run general/insert/query_file_memory.sim
-run general/insert/query_multi_file.sim
-run general/insert/tcp.sim
-run general/parser/alter.sim
-run general/parser/alter1.sim
-run general/parser/alter_stable.sim
-run general/parser/auto_create_tb.sim
-run general/parser/auto_create_tb_drop_tb.sim
-run general/parser/col_arithmetic_operation.sim
-run general/parser/columnValue.sim
-run general/parser/commit.sim
-run general/parser/create_db.sim
-run general/parser/create_mt.sim
-run general/parser/create_tb.sim
-run general/parser/dbtbnameValidate.sim
-run general/parser/import_commit1.sim
-run general/parser/import_commit2.sim
-run general/parser/import_commit3.sim
-run general/parser/insert_tb.sim
-run general/parser/first_last.sim
-##unsupport run general/parser/import_file.sim
-run general/parser/lastrow.sim
-run general/parser/nchar.sim
-run general/parser/null_char.sim
-run general/parser/single_row_in_tb.sim
-run general/parser/select_from_cache_disk.sim
-run general/parser/limit.sim
-run general/parser/limit1.sim
-run general/parser/limit1_tblocks100.sim
-run general/parser/mixed_blocks.sim
-run general/parser/selectResNum.sim
-run general/parser/select_across_vnodes.sim
-run general/parser/slimit1.sim
-run general/parser/tbnameIn.sim
-run general/parser/binary_escapeCharacter.sim
-run general/parser/projection_limit_offset.sim
-run general/parser/limit2.sim
-run general/parser/slimit.sim
-run general/parser/fill.sim
-run general/parser/fill_stb.sim
-run general/parser/interp.sim
-run general/parser/where.sim
-run general/parser/join.sim
-run general/parser/join_multivnode.sim
-run general/parser/select_with_tags.sim
-run general/parser/groupby.sim
-run general/parser/bug.sim
-run general/parser/tags_dynamically_specifiy.sim
-run general/parser/set_tag_vals.sim
-run general/parser/repeatAlter.sim
-run general/parser/precision_ns.sim
-##unsupport run general/parser/slimit_alter_tags.sim
-run general/stable/disk.sim
-run general/stable/dnode3.sim
-run general/stable/metrics.sim
-run general/stable/values.sim
-run general/stable/vnode3.sim
-run general/stable/refcount.sim
-run general/stable/show.sim
-run general/table/autocreate.sim
-run general/table/basic1.sim
-run general/table/basic2.sim
-run general/table/basic3.sim
-run general/table/bigint.sim
-run general/table/binary.sim
-run general/table/bool.sim
-run general/table/column_name.sim
-run general/table/column_num.sim
-run general/table/column_value.sim
-run general/table/column2.sim
-run general/table/date.sim
-run general/table/db.table.sim
-run general/table/delete_reuse1.sim
-run general/table/delete_reuse2.sim
-run general/table/delete_writing.sim
-run general/table/describe.sim
-run general/table/double.sim
-run general/table/fill.sim
-run general/table/float.sim
-run general/table/int.sim
-run general/table/limit.sim
-run general/table/smallint.sim
-run general/table/table_len.sim
-run general/table/table.sim
-run general/table/tinyint.sim
-run general/table/vgroup.sim
-run general/tag/3.sim
-run general/tag/4.sim
-run general/tag/5.sim
-run general/tag/6.sim
-run general/tag/add.sim
-run general/tag/bigint.sim
-run general/tag/binary_binary.sim
-run general/tag/binary.sim
-run general/tag/bool_binary.sim
-run general/tag/bool_int.sim
-run general/tag/bool.sim
-run general/tag/change.sim
-run general/tag/column.sim
-##unsupport run general/tag/commit.sim
-run general/tag/create.sim
-run general/tag/delete.sim
-run general/tag/double.sim
-run general/tag/filter.sim
-run general/tag/float.sim
-run general/tag/int_binary.sim
-run general/tag/int_float.sim
-run general/tag/int.sim
-run general/tag/set.sim
-run general/tag/smallint.sim
-run general/tag/tinyint.sim
-run general/user/authority.sim
-run general/user/monitor.sim
-run general/user/pass_alter.sim
-run general/user/pass_len.sim
-run general/user/user_create.sim
-run general/user/user_len.sim
-run general/vector/metrics_field.sim
-run general/vector/metrics_mix.sim
-run general/vector/metrics_query.sim
-run general/vector/metrics_tag.sim
-run general/vector/metrics_time.sim
-run general/vector/multi.sim
-run general/vector/single.sim
-run general/vector/table_field.sim
-run general/vector/table_mix.sim
-run general/vector/table_query.sim
-run general/vector/table_time.sim
-run general/stream/restart_stream.sim
-run general/stream/stream_3.sim
-run general/stream/stream_restart.sim
-run general/stream/table_del.sim
-run general/stream/metrics_del.sim
-run general/stream/table_replica1_vnoden.sim
-run general/stream/metrics_replica1_vnoden.sim

tests/script/tmp/data.sim

@@ -1,9 +1,14 @@
 system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c telemetryReporting -v 1
+system sh/cfg.sh -n dnode1 -c telemetryInterval -v 1
+system sh/cfg.sh -n dnode1 -c telemetryServer -v localhost
+system sh/cfg.sh -n dnode1 -c telemetryPort -v 80
+
+return
 system sh/exec.sh -n dnode1 -s start
 sql connect
 
-return 
 sql create database db 
 sql create table db.tb (ts timestamp, i int)
 sql insert into db.tb values(now, 1)

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
+#print ============== modify quorum
-sql alter database db quorum 2
+#sql alter database db quorum 2
-sql show databases
+#sql show databases
-print quorum $data5_db
+#print quorum $data5_db
-if $data5_db != 2 then 
+#if $data5_db != 2 then 
-  return -1
+#  return -1
-endi
+#endi
-sql alter database db quorum 1
+#sql alter database db quorum 1
-sql show databases
+#sql show databases
-print quorum $data5_db
+#print quorum $data5_db
-if $data5_db != 1 then 
+#if $data5_db != 1 then 
-  return -1
+#  return -1
-endi
+#endi
 
-sql_error alter database db quorum -1
+#sql_error alter database db quorum -1
-sql_error alter database db quorum 0
+#sql_error alter database db quorum 0
-sql_error alter database db quorum 3
+#sql_error alter database db quorum 3
-sql_error alter database db quorum 4
+#sql_error alter database db quorum 4
-sql_error alter database db quorum 5
+#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 create database db QUORUM 1
-sql show databases
+#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
+#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
+#if $data5_db != 1 then
-  return -1
+#  return -1
-endi
+#endi
-sql drop database db
+#sql drop database db
-sql_error create database db QUORUM 3
+#sql_error create database db QUORUM 3
-sql_error create database db QUORUM 0
+#sql_error create database db QUORUM 0
-sql_error create database db QUORUM -1
+#sql_error create database db QUORUM -1
 
 print ====> REPLICA value [1 | 3, default: 1]
 sql create database db REPLICA 3

tests/script/tsim/query/explain.sim

@@ -45,7 +45,7 @@ sql explain select * from information_schema.user_stables;
 sql explain select count(*),sum(f1) from tb1;
 sql explain select count(*),sum(f1) from st1;
 sql explain select count(*),sum(f1) from st1 group by f1;
-sql explain select count(f1) from tb1 interval(10s, 2s) sliding(3s) fill(prev);
+#sql explain select count(f1) from tb1 interval(10s, 2s) sliding(3s) fill(prev);
 sql explain select min(f1) from st1 interval(1m, 2a) sliding(30s); 
 
 print ======== step3 
@@ -65,7 +65,7 @@ sql explain analyze select * from information_schema.user_stables;
 sql explain analyze select count(*),sum(f1) from tb1;
 sql explain analyze select count(*),sum(f1) from st1;
 sql explain analyze select count(*),sum(f1) from st1 group by f1;
-sql explain analyze select count(f1) from tb1 interval(10s, 2s) sliding(3s) fill(prev);
+#sql explain analyze select count(f1) from tb1 interval(10s, 2s) sliding(3s) fill(prev);
 sql explain analyze select min(f1) from st1 interval(3m, 2a) sliding(1m); 
 
 print ======== step5 
@@ -78,7 +78,7 @@ sql explain analyze verbose true select * from information_schema.user_stables;
 sql explain analyze verbose true select count(*),sum(f1) from tb1;
 sql explain analyze verbose true select count(*),sum(f1) from st1;
 sql explain analyze verbose true select count(*),sum(f1) from st1 group by f1;
-sql explain analyze verbose true select count(f1) from tb1 interval(10s, 2s) sliding(3s) fill(prev);
+#sql explain analyze verbose true select count(f1) from tb1 interval(10s, 2s) sliding(3s) fill(prev);
 sql explain analyze verbose true select ts from tb1 where f1 > 0;
 sql explain analyze verbose true select f1 from st1 where f1 > 0 and ts > '2020-10-31 00:00:00' and ts < '2021-10-31 00:00:00';
 sql explain analyze verbose true select * from information_schema.user_stables where db_name='db2';