[td-11818] merge 3.0

.gitignore

@@ -2,6 +2,8 @@ build/
 compile_commands.json
 .cache
 .ycm_extra_conf.py
+.tasks
+.vimspector.json
 .vscode/
 .idea/
 cmake-build-debug/

.gitmodules

 [submodule "src/connector/go"]
 	path = src/connector/go
 	url = git@github.com:taosdata/driver-go.git
-[submodule "src/connector/grafanaplugin"]
-	path = src/connector/grafanaplugin
-	url = git@github.com:taosdata/grafanaplugin.git
 [submodule "src/connector/hivemq-tdengine-extension"]
 	path = src/connector/hivemq-tdengine-extension
 	url = git@github.com:taosdata/hivemq-tdengine-extension.git
-[submodule "tests/examples/rust"]
-	path = tests/examples/rust
-	url = https://github.com/songtianyi/tdengine-rust-bindings.git
 [submodule "deps/jemalloc"]
 	path = deps/jemalloc
 	url = https://github.com/jemalloc/jemalloc
 [submodule "deps/TSZ"]
 	path = deps/TSZ
 	url = https://github.com/taosdata/TSZ.git
+[submodule "tests"]
+	path = tests
+	url = https://github.com/taosdata/tests
+	branch = 3.0

include/client/taos.h

@@ -92,17 +92,6 @@ typedef struct taosField {
 
 typedef void (*__taos_async_fn_t)(void *param, TAOS_RES *, int code);
 
-typedef struct tmq_t tmq_t;
-typedef struct tmq_conf_t tmq_conf_t;
-typedef struct tmq_list_t tmq_list_t;
-
-typedef struct tmq_message_t       tmq_message_t;
-typedef struct tmq_message_topic_t tmq_message_topic_t;
-typedef struct tmq_message_tb_t    tmq_message_tb_t;
-typedef struct tmq_tb_iter_t       tmq_tb_iter_t;
-typedef struct tmq_message_col_t   tmq_message_col_t;
-typedef struct tmq_col_iter_t      tmq_col_iter_t;
-
 typedef struct TAOS_BIND {
   int            buffer_type;
   void *         buffer;
@@ -204,26 +193,66 @@ DLL_EXPORT void taos_close_stream(TAOS_STREAM *tstr);
 DLL_EXPORT int taos_load_table_info(TAOS *taos, const char* tableNameList);
 DLL_EXPORT TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int protocol, int precision);
 
-DLL_EXPORT tmq_list_t* tmq_list_new();
-DLL_EXPORT int32_t tmq_list_append(tmq_list_t*, char*);
+/* --------------------------TMQ INTERFACE------------------------------- */
+
+enum tmq_resp_err_t {
+  TMQ_RESP_ERR__SUCCESS = 0,
+  TMQ_RESP_ERR__FAIL = 1,
+};
+
+typedef enum tmq_resp_err_t tmq_resp_err_t;
+
+typedef struct tmq_t                   tmq_t;
+typedef struct tmq_topic_vgroup_t      tmq_topic_vgroup_t;
+typedef struct tmq_topic_vgroup_list_t tmq_topic_vgroup_list_t;
 
-DLL_EXPORT tmq_conf_t* tmq_conf_new();
+typedef struct tmq_conf_t    tmq_conf_t;
+typedef struct tmq_list_t    tmq_list_t;
+typedef struct tmq_message_t tmq_message_t;
 
-DLL_EXPORT int32_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value);
+typedef void(tmq_commit_cb(tmq_t *, tmq_resp_err_t, tmq_topic_vgroup_list_t *, void *param));
 
-DLL_EXPORT TAOS_RES *taos_create_topic(TAOS* taos, const char* name, const char* sql, int sqlLen);
+DLL_EXPORT tmq_list_t *tmq_list_new();
+DLL_EXPORT int32_t     tmq_list_append(tmq_list_t *, const char *);
+
+DLL_EXPORT TAOS_RES *tmq_create_topic(TAOS *taos, const char *name, const char *sql, int sqlLen);
+DLL_EXPORT tmq_t    *tmq_consumer_new(void *conn, tmq_conf_t *conf, char *errstr, int32_t errstrLen);
+DLL_EXPORT void tmq_message_destroy(tmq_message_t* tmq_message);
+DLL_EXPORT const char* tmq_err2str(tmq_resp_err_t);
+
+/* ------------------------TMQ CONSUMER INTERFACE------------------------ */
+DLL_EXPORT tmq_resp_err_t tmq_subscribe(tmq_t *tmq, tmq_list_t *topic_list);
+#if 0
+DLL_EXPORT tmq_resp_err_t tmq_unsubscribe(tmq_t* tmq);
+DLL_EXPORT tmq_resp_err_t tmq_subscription(tmq_t* tmq, tmq_topic_vgroup_list_t** topics);
+#endif
+DLL_EXPORT tmq_message_t *tmq_consumer_poll(tmq_t *tmq, int64_t blocking_time);
+DLL_EXPORT tmq_resp_err_t tmq_consumer_close(tmq_t* tmq);
+#if 0
+DLL_EXPORT tmq_resp_err_t tmq_assign(tmq_t* tmq, const tmq_topic_vgroup_list_t* vgroups);
+DLL_EXPORT tmq_resp_err_t tmq_assignment(tmq_t* tmq, tmq_topic_vgroup_list_t** vgroups);
+#endif
+DLL_EXPORT tmq_resp_err_t tmq_commit(tmq_t *tmq, const tmq_topic_vgroup_list_t *offsets, int32_t async);
+#if 0
+DLL_EXPORT tmq_resp_err_t tmq_commit_message(tmq_t* tmq, const tmq_message_t* tmqmessage, int32_t async);
+#endif
+/* ----------------------TMQ CONFIGURATION INTERFACE---------------------- */
 
-DLL_EXPORT tmq_t* taos_consumer_new(void* conn, tmq_conf_t* conf, char* errstr, int32_t errstrLen);
+enum tmq_conf_res_t {
+  TMQ_CONF_UNKNOWN = -2,
+  TMQ_CONF_INVALID = -1,
+  TMQ_CONF_OK = 0,
+};
 
-DLL_EXPORT TAOS_RES* tmq_subscribe(tmq_t* tmq, tmq_list_t* topic_list);
+typedef enum tmq_conf_res_t tmq_conf_res_t;
 
-DLL_EXPORT tmq_message_t* tmq_consume_poll(tmq_t* tmq, int64_t blocking_time);
+DLL_EXPORT tmq_conf_t    *tmq_conf_new();
+DLL_EXPORT void           tmq_conf_destroy(tmq_conf_t *conf);
+DLL_EXPORT tmq_conf_res_t tmq_conf_set(tmq_conf_t *conf, const char *key, const char *value);
+DLL_EXPORT void           tmq_conf_set_offset_commit_cb(tmq_conf_t *conf, tmq_commit_cb *cb);
 
-DLL_EXPORT int32_t tmq_topic_num(tmq_message_t* msg);
-DLL_EXPORT char* tmq_get_topic(tmq_message_topic_t* msg);
-DLL_EXPORT int32_t tmq_get_vgId(tmq_message_topic_t* msg);
-DLL_EXPORT tmq_message_tb_t* tmq_get_next_tb(tmq_message_topic_t* msg, tmq_tb_iter_t* iter);
-DLL_EXPORT tmq_message_col_t* tmq_get_next_col(tmq_message_tb_t* msg, tmq_col_iter_t* iter);
+//temporary used function for demo only
+void tmqShowMsg(tmq_message_t* tmq_message);
 
 #ifdef __cplusplus
 }

include/common/common.h

@@ -26,6 +26,10 @@ extern "C" {
 #include "tarray.h"
 #include "tvariant.h"
 
+#define TMQ_REQ_TYPE_COMMIT_ONLY        0
+#define TMQ_REQ_TYPE_CONSUME_ONLY       1
+#define TMQ_REQ_TYPE_CONSUME_AND_COMMIT 2
+
 typedef struct {
   uint32_t  numOfTables;
   SArray *  pGroupList;
@@ -82,6 +86,125 @@ typedef struct SColumnInfoData {
   };
 } SColumnInfoData;
 
+static FORCE_INLINE int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock) {
+  int64_t tbUid = pBlock->info.uid;
+  int32_t numOfCols = pBlock->info.numOfCols;
+  int32_t rows = pBlock->info.rows;
+  int32_t sz = taosArrayGetSize(pBlock->pDataBlock);
+
+  int32_t tlen = 0;
+  tlen += taosEncodeFixedI64(buf, tbUid);
+  tlen += taosEncodeFixedI32(buf, numOfCols);
+  tlen += taosEncodeFixedI32(buf, rows);
+  tlen += taosEncodeFixedI32(buf, sz);
+  for (int32_t i = 0; i < sz; i++) {
+    SColumnInfoData* pColData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
+    tlen += taosEncodeFixedI16(buf, pColData->info.colId);
+    tlen += taosEncodeFixedI16(buf, pColData->info.type);
+    tlen += taosEncodeFixedI16(buf, pColData->info.bytes);
+    int32_t colSz = rows * pColData->info.bytes;
+    tlen += taosEncodeBinary(buf, pColData->pData, colSz);
+  }
+  return tlen;
+}
+
+static FORCE_INLINE void* tDecodeDataBlock(void* buf, SSDataBlock* pBlock) {
+  int32_t sz;
+
+  buf = taosDecodeFixedI64(buf, &pBlock->info.uid);
+  buf = taosDecodeFixedI32(buf, &pBlock->info.numOfCols);
+  buf = taosDecodeFixedI32(buf, &pBlock->info.rows);
+  buf = taosDecodeFixedI32(buf, &sz);
+  pBlock->pDataBlock = taosArrayInit(sz, sizeof(SColumnInfoData));
+  for (int32_t i = 0; i < sz; i++) {
+    SColumnInfoData data = {0};
+    buf = taosDecodeFixedI16(buf, &data.info.colId);
+    buf = taosDecodeFixedI16(buf, &data.info.type);
+    buf = taosDecodeFixedI16(buf, &data.info.bytes);
+    int32_t colSz = pBlock->info.rows * data.info.bytes;
+    buf = taosDecodeBinary(buf, (void**)&data.pData, colSz);
+    taosArrayPush(pBlock->pDataBlock, &data);
+  }
+  return buf;
+}
+
+static FORCE_INLINE int32_t tEncodeSMqConsumeRsp(void** buf, const SMqConsumeRsp* pRsp) {
+  int32_t tlen = 0;
+  int32_t sz = 0;
+  tlen += taosEncodeFixedI64(buf, pRsp->consumerId);
+  tlen += taosEncodeFixedI64(buf, pRsp->committedOffset);
+  tlen += taosEncodeFixedI64(buf, pRsp->reqOffset);
+  tlen += taosEncodeFixedI64(buf, pRsp->rspOffset);
+  tlen += taosEncodeFixedI32(buf, pRsp->skipLogNum);
+  tlen += taosEncodeFixedI32(buf, pRsp->numOfTopics);
+  if (pRsp->numOfTopics == 0) return tlen;
+  tlen += tEncodeSSchemaWrapper(buf, pRsp->schemas);
+  if (pRsp->pBlockData) {
+    sz = taosArrayGetSize(pRsp->pBlockData);
+  }
+  tlen += taosEncodeFixedI32(buf, sz);
+  for (int32_t i = 0; i < sz; i++) {
+    SSDataBlock* pBlock = (SSDataBlock*) taosArrayGet(pRsp->pBlockData, i);
+    tlen += tEncodeDataBlock(buf, pBlock);
+  }
+  return tlen;
+}
+
+static FORCE_INLINE void* tDecodeSMqConsumeRsp(void* buf, SMqConsumeRsp* pRsp) {
+  int32_t sz;
+  buf = taosDecodeFixedI64(buf, &pRsp->consumerId);
+  buf = taosDecodeFixedI64(buf, &pRsp->committedOffset);
+  buf = taosDecodeFixedI64(buf, &pRsp->reqOffset);
+  buf = taosDecodeFixedI64(buf, &pRsp->rspOffset);
+  buf = taosDecodeFixedI32(buf, &pRsp->skipLogNum);
+  buf = taosDecodeFixedI32(buf, &pRsp->numOfTopics);
+  if (pRsp->numOfTopics == 0) return buf;
+  pRsp->schemas = (SSchemaWrapper*)calloc(1, sizeof(SSchemaWrapper));
+  if (pRsp->schemas == NULL) return NULL;
+  buf = tDecodeSSchemaWrapper(buf, pRsp->schemas);
+  buf = taosDecodeFixedI32(buf, &sz);
+  pRsp->pBlockData = taosArrayInit(sz, sizeof(SSDataBlock));
+  for (int32_t i = 0; i < sz; i++) {
+    SSDataBlock block = {0};
+    tDecodeDataBlock(buf, &block);
+    taosArrayPush(pRsp->pBlockData, &block);
+  }
+  return buf;
+}
+
+static FORCE_INLINE void tDeleteSSDataBlock(SSDataBlock* pBlock) {
+  if (pBlock == NULL) {
+    return;
+  }
+
+  //int32_t numOfOutput = pBlock->info.numOfCols;
+  int32_t sz = taosArrayGetSize(pBlock->pDataBlock);
+  for(int32_t i = 0; i < sz; ++i) {
+    SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
+    tfree(pColInfoData->pData);
+  }
+
+  taosArrayDestroy(pBlock->pDataBlock);
+  tfree(pBlock->pBlockAgg);
+  //tfree(pBlock);
+}
+
+
+static FORCE_INLINE void tDeleteSMqConsumeRsp(SMqConsumeRsp* pRsp) {
+  if (pRsp->schemas) {
+    if (pRsp->schemas->nCols) {
+      tfree(pRsp->schemas->pSchema);
+    }
+    free(pRsp->schemas);
+  }
+    taosArrayDestroyEx(pRsp->pBlockData, (void(*)(void*))tDeleteSSDataBlock);
+    pRsp->pBlockData = NULL;
+  //for (int i = 0; i < taosArrayGetSize(pRsp->pBlockData); i++) {
+    //SSDataBlock* pDataBlock = (SSDataBlock*)taosArrayGet(pRsp->pBlockData, i);
+    //tDeleteSSDataBlock(pDataBlock);
+  //}
+}
+
 //======================================================================================================================
 // the following structure shared by parser and executor
 typedef struct SColumn {

include/common/tdataformat.h

@@ -24,6 +24,13 @@
 extern "C" {
 #endif
 
+// Imported since 3.0 and use bitmap to demonstrate None/Null/Norm, while use Null/Norm below 3.0 without of bitmap.
+#define TD_SUPPORT_BITMAP
+#define TD_SUPPORT_READ2
+#define TD_SUPPORT_BACK2  // suppport back compatibility of 2.0
+
+#define TASSERT(x) ASSERT(x)
+
 #define STR_TO_VARSTR(x, str)                     \
   do {                                            \
     VarDataLenT __len = (VarDataLenT)strlen(str); \
@@ -53,9 +60,9 @@ extern "C" {
 // ----------------- TSDB COLUMN DEFINITION
 typedef struct {
   int8_t   type;    // Column type
-  int16_t  colId;   // column ID
+  col_id_t colId;   // column ID(start from PRIMARYKEY_TIMESTAMP_COL_ID(1))
   int16_t  bytes;   // column bytes (restore to int16_t in case of misuse)
-  uint16_t offset;  // point offset in SDataRow after the header part.
+  uint16_t offset;  // point offset in STpRow after the header part.
 } STColumn;
 
 #define colType(col) ((col)->type)
@@ -72,9 +79,9 @@ typedef struct {
 typedef struct {
   int version;    // version
   int numOfCols;  // Number of columns appended
-  int tlen;  // maximum length of a SDataRow without the header part (sizeof(VarDataOffsetT) + sizeof(VarDataLenT) +
-             // (bytes))
-  uint16_t flen;  // First part length in a SDataRow after the header part
+  int tlen;       // maximum length of a STpRow without the header part (sizeof(VarDataOffsetT) + sizeof(VarDataLenT) +
+                  // (bytes))
+  uint16_t flen;  // First part length in a STpRow after the header part
   uint16_t vlen;  // pure value part length, excluded the overhead (bytes only)
   STColumn columns[];
 } STSchema;
@@ -118,6 +125,13 @@ typedef struct {
   STColumn *columns;
 } STSchemaBuilder;
 
+#define TD_VTYPE_BITS 2   // val type
+#define TD_VTYPE_PARTS 4  // 8 bits / TD_VTYPE_BITS = 4
+#define TD_VTYPE_OPTR 3   // TD_VTYPE_PARTS - 1, utilize to get remainder
+
+#define TD_BITMAP_BYTES(cnt) (ceil((double)cnt / TD_VTYPE_PARTS))
+#define TD_BIT_TO_BYTES(cnt) (ceil((double)cnt / 8))
+
 int       tdInitTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version);
 void      tdDestroyTSchemaBuilder(STSchemaBuilder *pBuilder);
 void      tdResetTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version);
@@ -125,6 +139,8 @@ int       tdAddColToSchema(STSchemaBuilder *pBuilder, int8_t type, int16_t colId
 STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder);
 
 // ----------------- Semantic timestamp key definition
+#ifdef TD_2_0
+
 typedef uint64_t TKEY;
 
 #define TKEY_INVALID UINT64_MAX
@@ -144,6 +160,29 @@ typedef uint64_t TKEY;
 
 #define TD_TO_TKEY(key) tdGetTKEY(((key) < MIN_TS_KEY) ? MIN_TS_KEY : (((key) > MAX_TS_KEY) ? MAX_TS_KEY : key))
 
+#else
+
+// typedef uint64_t TKEY;
+#define TKEY TSKEY
+
+#define TKEY_INVALID UINT64_MAX
+#define TKEY_NULL TKEY_INVALID
+#define TKEY_NEGATIVE_FLAG (((TKEY)1) << 63)
+#define TKEY_VALUE_FILTER (~(TKEY_NEGATIVE_FLAG))
+
+#define TKEY_IS_NEGATIVE(tkey) (((tkey)&TKEY_NEGATIVE_FLAG) != 0)
+#define TKEY_IS_DELETED(tkey) (false)
+
+#define tdGetTKEY(key) (key)
+#define tdGetKey(tskey) (tskey)
+
+#define MIN_TS_KEY ((TSKEY)0x8000000000000001)
+#define MAX_TS_KEY ((TSKEY)0x7fffffffffffffff)
+
+#define TD_TO_TKEY(key) tdGetTKEY(((key) < MIN_TS_KEY) ? MIN_TS_KEY : (((key) > MAX_TS_KEY) ? MAX_TS_KEY : key))
+
+#endif
+
 static FORCE_INLINE TKEY keyToTkey(TSKEY key) {
   TSKEY lkey = key;
   if (key > MAX_TS_KEY) {
@@ -168,6 +207,7 @@ static FORCE_INLINE int tkeyComparFn(const void *tkey1, const void *tkey2) {
   }
 }
 
+#if 0
 // ----------------- Data row structure
 
 /* A data row, the format is like below:
@@ -317,10 +357,12 @@ static FORCE_INLINE void tdCopyColOfRowBySchema(SDataRow dst, STSchema *pDstSche
       memcpy(pData, value, pSrcSchema->columns[srcIdx].bytes);
   }
 }
-
+#endif
 // ----------------- Data column structure
 typedef struct SDataCol {
-  int8_t          type;       // column type
+  int8_t          type;        // column type
+  uint8_t         bitmap : 1;  // 0: has bitmap if has NULL/NORM rows, 1: no bitmap if all rows are NORM
+  uint8_t         reserve : 7;
   int16_t         colId;      // column ID
   int             bytes;      // column data bytes defined
   int             offset;     // data offset in a SDataRow (including the header size)
@@ -328,20 +370,23 @@ typedef struct SDataCol {
   int             len;        // column data length
   VarDataOffsetT *dataOff;    // For binary and nchar data, the offset in the data column
   void *          pData;      // Actual data pointer
+  void *          pBitmap;    // Bitmap pointer
   TSKEY           ts;         // only used in last NULL column
 } SDataCol;
 
 #define isAllRowsNull(pCol) ((pCol)->len == 0)
+#define isAllRowsNone(pCol) ((pCol)->len == 0)
 static FORCE_INLINE void dataColReset(SDataCol *pDataCol) { pDataCol->len = 0; }
 
 int tdAllocMemForCol(SDataCol *pCol, int maxPoints);
 
 void dataColInit(SDataCol *pDataCol, STColumn *pCol, int maxPoints);
 int  dataColAppendVal(SDataCol *pCol, const void *value, int numOfRows, int maxPoints);
-void dataColSetOffset(SDataCol *pCol, int nEle);
+void *dataColSetOffset(SDataCol *pCol, int nEle);
 
 bool isNEleNull(SDataCol *pCol, int nEle);
 
+#if 0
 // Get the data pointer from a column-wised data
 static FORCE_INLINE const void *tdGetColDataOfRow(SDataCol *pCol, int row) {
   if (isAllRowsNull(pCol)) {
@@ -363,13 +408,13 @@ static FORCE_INLINE int32_t dataColGetNEleLen(SDataCol *pDataCol, int rows) {
     return TYPE_BYTES[pDataCol->type] * rows;
   }
 }
-
+#endif
 typedef struct {
-  int       maxCols;    // max number of columns
+  col_id_t  maxCols;    // max number of columns
+  col_id_t  numOfCols;  // Total number of cols
   int       maxPoints;  // max number of points
   int       numOfRows;
-  int       numOfCols;  // Total number of cols
-  int       sversion;   // TODO: set sversion
+  int       sversion;  // TODO: set sversion
   SDataCol *cols;
 } SDataCols;
 
@@ -481,6 +526,7 @@ static FORCE_INLINE void *tdGetKVRowIdxOfCol(SKVRow row, int16_t colId) {
   return taosbsearch(&colId, kvRowColIdx(row), kvRowNCols(row), sizeof(SColIdx), comparTagId, TD_EQ);
 }
 
+#if 0
 // offset here not include kvRow header length
 static FORCE_INLINE int tdAppendKvColVal(SKVRow row, const void *value, bool isCopyValData, int16_t colId, int8_t type,
                                          int32_t offset) {
@@ -527,7 +573,7 @@ static FORCE_INLINE void *tdGetKVRowValOfColEx(SKVRow row, int16_t colId, int32_
   }
   return NULL;
 }
-
+#endif
 // ----------------- K-V data row builder
 typedef struct {
   int16_t  tCols;
@@ -571,8 +617,8 @@ static FORCE_INLINE int tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId,
 
   return 0;
 }
-
-// ----------------- SMemRow appended with sequential data row structure
+#if 0
+// ----------------- SMemRow appended with tuple row structure
 /*
  * |---------|------------------------------------------------- len ---------------------------------->|
  * |<--------     Head      ------>|<---------   flen -------------->|                                 |
@@ -605,22 +651,17 @@ typedef void *SMemRow;
 
 #define SMEM_ROW_DATA 0x0U      // SDataRow
 #define SMEM_ROW_KV 0x01U       // SKVRow
-#define SMEM_ROW_CONVERT 0x80U  // SMemRow convert flag
 
-#define KVRatioKV (0.2f)  // all bool
-#define KVRatioPredict (0.4f)
-#define KVRatioData (0.75f)  // all bigint
 #define KVRatioConvert (0.9f)
 
 #define memRowType(r) ((*(uint8_t *)(r)) & 0x01)
 
 #define memRowSetType(r, t) ((*(uint8_t *)(r)) = (t))  // set the total byte in case of dirty memory
-#define memRowSetConvert(r) ((*(uint8_t *)(r)) = (((*(uint8_t *)(r)) & 0x7F) | SMEM_ROW_CONVERT))  // highest bit
 #define isDataRowT(t) (SMEM_ROW_DATA == (((uint8_t)(t)) & 0x01))
 #define isDataRow(r) (SMEM_ROW_DATA == memRowType(r))
 #define isKvRowT(t) (SMEM_ROW_KV == (((uint8_t)(t)) & 0x01))
 #define isKvRow(r) (SMEM_ROW_KV == memRowType(r))
-#define isNeedConvertRow(r) (((*(uint8_t *)(r)) & 0x80) == SMEM_ROW_CONVERT)
+#define isUtilizeKVRow(k, d) ((k) < ((d)*KVRatioConvert))
 
 #define memRowDataBody(r) POINTER_SHIFT(r, TD_MEM_ROW_TYPE_SIZE)  // section after flag
 #define memRowKvBody(r) \
@@ -630,9 +671,9 @@ typedef void *SMemRow;
 #define memRowKvLen(r) (*(TDRowLenT *)memRowKvBody(r))      //  0~65535
 
 #define memRowDataTLen(r) \
-  ((TDRowTLenT)(memRowDataLen(r) + TD_MEM_ROW_TYPE_SIZE))  // using uint32_t/int32_t to store the TLen
+  ((TDRowLenT)(memRowDataLen(r) + TD_MEM_ROW_TYPE_SIZE))  // using uint32_t/int32_t to store the TLen
 
-#define memRowKvTLen(r) ((TDRowTLenT)(memRowKvLen(r) + TD_MEM_ROW_KV_TYPE_VER_SIZE))
+#define memRowKvTLen(r) ((TDRowLenT)(memRowKvLen(r) + TD_MEM_ROW_KV_TYPE_VER_SIZE))
 
 #define memRowLen(r) (isDataRow(r) ? memRowDataLen(r) : memRowKvLen(r))
 #define memRowTLen(r) (isDataRow(r) ? memRowDataTLen(r) : memRowKvTLen(r))  // using uint32_t/int32_t to store the TLen
@@ -722,31 +763,6 @@ static FORCE_INLINE int32_t tdGetColAppendLen(uint8_t rowType, const void *value
   return len;
 }
 
-/**
- * 1. calculate the delta of AllNullLen for SDataRow.
- * 2. calculate the real len for SKVRow.
- */
-static FORCE_INLINE void tdGetColAppendDeltaLen(const void *value, int8_t colType, int32_t *dataLen, int32_t *kvLen) {
-  switch (colType) {
-    case TSDB_DATA_TYPE_BINARY: {
-      int32_t varLen = varDataLen(value);
-      *dataLen += (varLen - CHAR_BYTES);
-      *kvLen += (varLen + sizeof(SColIdx));
-      break;
-    }
-    case TSDB_DATA_TYPE_NCHAR: {
-      int32_t varLen = varDataLen(value);
-      *dataLen += (varLen - TSDB_NCHAR_SIZE);
-      *kvLen += (varLen + sizeof(SColIdx));
-      break;
-    }
-    default: {
-      *kvLen += (TYPE_BYTES[colType] + sizeof(SColIdx));
-      break;
-    }
-  }
-}
-
 typedef struct {
   int16_t colId;
   uint8_t colType;
@@ -760,53 +776,6 @@ static FORCE_INLINE void setSColInfo(SColInfo *colInfo, int16_t colId, uint8_t c
 }
 
 SMemRow mergeTwoMemRows(void *buffer, SMemRow row1, SMemRow row2, STSchema *pSchema1, STSchema *pSchema2);
-
-#if 0
-// ----------------- Raw payload structure for row:
-/* |<------------ Head ------------->|<----------- body of column data tuple ------------------->|
- * |                                 |<----------------- flen ------------->|<--- value part --->|
- * |SMemRowType| dataTLen |  nCols   |  colId  | colType | offset   |  ...  | value |...|...|... |
- * +-----------+----------+----------+--------------------------------------|--------------------|
- * | uint8_t   | uint32_t | uint16_t | int16_t | uint8_t | uint16_t |  ...  |.......|...|...|... |
- * +-----------+----------+----------+--------------------------------------+--------------------|
- *  1. offset in column data tuple starts from the value part in case of uint16_t overflow.
- *  2. dataTLen: total length including the header and body.
- */
-
-#define PAYLOAD_NCOLS_LEN sizeof(uint16_t)
-#define PAYLOAD_NCOLS_OFFSET (sizeof(uint8_t) + sizeof(TDRowTLenT))
-#define PAYLOAD_HEADER_LEN (PAYLOAD_NCOLS_OFFSET + PAYLOAD_NCOLS_LEN)
-#define PAYLOAD_ID_LEN sizeof(int16_t)
-#define PAYLOAD_ID_TYPE_LEN (sizeof(int16_t) + sizeof(uint8_t))
-#define PAYLOAD_COL_HEAD_LEN (PAYLOAD_ID_TYPE_LEN + sizeof(uint16_t))
-#define PAYLOAD_PRIMARY_COL_LEN (PAYLOAD_ID_TYPE_LEN + sizeof(TSKEY))
-
-#define payloadBody(r) POINTER_SHIFT(r, PAYLOAD_HEADER_LEN)
-#define payloadType(r) (*(uint8_t *)(r))
-#define payloadSetType(r, t) (payloadType(r) = (t))
-#define payloadTLen(r) (*(TDRowTLenT *)POINTER_SHIFT(r, TD_MEM_ROW_TYPE_SIZE))  // including total header
-#define payloadSetTLen(r, l) (payloadTLen(r) = (l))
-#define payloadNCols(r) (*(TDRowLenT *)POINTER_SHIFT(r, PAYLOAD_NCOLS_OFFSET))
-#define payloadSetNCols(r, n) (payloadNCols(r) = (n))
-#define payloadValuesOffset(r) \
-  (PAYLOAD_HEADER_LEN + payloadNCols(r) * PAYLOAD_COL_HEAD_LEN)    // avoid using the macro in loop
-#define payloadValues(r) POINTER_SHIFT(r, payloadValuesOffset(r))  // avoid using the macro in loop
-#define payloadColId(c) (*(int16_t *)(c))
-#define payloadColType(c) (*(uint8_t *)POINTER_SHIFT(c, PAYLOAD_ID_LEN))
-#define payloadColOffset(c) (*(uint16_t *)POINTER_SHIFT(c, PAYLOAD_ID_TYPE_LEN))
-#define payloadColValue(c) POINTER_SHIFT(c, payloadColOffset(c))
-
-#define payloadColSetId(c, i) (payloadColId(c) = (i))
-#define payloadColSetType(c, t) (payloadColType(c) = (t))
-#define payloadColSetOffset(c, o) (payloadColOffset(c) = (o))
-
-#define payloadTSKey(r) (*(TSKEY *)POINTER_SHIFT(r, payloadValuesOffset(r)))
-#define payloadTKey(r) (*(TKEY *)POINTER_SHIFT(r, payloadValuesOffset(r)))
-#define payloadKey(r) tdGetKey(payloadTKey(r))
-
-
-static FORCE_INLINE char *payloadNextCol(char *pCol) { return (char *)POINTER_SHIFT(pCol, PAYLOAD_COL_HEAD_LEN); }
-
 #endif
 
 #ifdef __cplusplus

include/common/tmsg.h

@@ -25,7 +25,7 @@ extern "C" {
 #include "taoserror.h"
 #include "tarray.h"
 #include "tcoding.h"
-#include "tdataformat.h"
+#include "trow.h"
 #include "thash.h"
 #include "tlist.h"
 
@@ -76,6 +76,13 @@ typedef enum {
   HEARTBEAT_TYPE_MAX
 } EHbType;
 
+enum {
+  HEARTBEAT_KEY_DBINFO = 1,
+  HEARTBEAT_KEY_STBINFO,
+  HEARTBEAT_KEY_MQ_TMP,
+};
+
+
 typedef enum _mgmt_table {
   TSDB_MGMT_TABLE_START,
   TSDB_MGMT_TABLE_ACCT,
@@ -104,15 +111,15 @@ typedef enum _mgmt_table {
   TSDB_MGMT_TABLE_MAX,
 } EShowType;
 
-#define TSDB_ALTER_TABLE_ADD_TAG_COLUMN 1
-#define TSDB_ALTER_TABLE_DROP_TAG_COLUMN 2
-#define TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN 3
+#define TSDB_ALTER_TABLE_ADD_TAG 1
+#define TSDB_ALTER_TABLE_DROP_TAG 2
+#define TSDB_ALTER_TABLE_UPDATE_TAG_NAME 3
 #define TSDB_ALTER_TABLE_UPDATE_TAG_VAL 4
 
 #define TSDB_ALTER_TABLE_ADD_COLUMN 5
 #define TSDB_ALTER_TABLE_DROP_COLUMN 6
-#define TSDB_ALTER_TABLE_CHANGE_COLUMN 7
-#define TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN 8
+#define TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES 7
+#define TSDB_ALTER_TABLE_UPDATE_TAG_BYTES 8
 
 #define TSDB_FILL_NONE 0
 #define TSDB_FILL_NULL 1
@@ -122,6 +129,14 @@ typedef enum _mgmt_table {
 #define TSDB_FILL_NEXT 5
 
 #define TSDB_ALTER_USER_PASSWD 0x1
+#define TSDB_ALTER_USER_SUPERUSER 0x2
+#define TSDB_ALTER_USER_ADD_READ_DB 0x3
+#define TSDB_ALTER_USER_REMOVE_READ_DB 0x4
+#define TSDB_ALTER_USER_CLEAR_READ_DB 0x5
+#define TSDB_ALTER_USER_ADD_WRITE_DB 0x6
+#define TSDB_ALTER_USER_REMOVE_WRITE_DB 0x7
+#define TSDB_ALTER_USER_CLEAR_WRITE_DB 0x7
+
 #define TSDB_ALTER_USER_PRIVILEGES 0x2
 
 #define TSDB_KILL_MSG_LEN 30
@@ -140,17 +155,28 @@ typedef enum _mgmt_table {
 #define TSDB_COL_IS_NORMAL_COL(f) ((f & (~(TSDB_COL_NULL))) == TSDB_COL_NORMAL)
 #define TSDB_COL_IS_UD_COL(f) ((f & (~(TSDB_COL_NULL))) == TSDB_COL_UDC)
 #define TSDB_COL_REQ_NULL(f) (((f)&TSDB_COL_NULL) != 0)
+
+#define TD_SUPER_TABLE TSDB_SUPER_TABLE
+#define TD_CHILD_TABLE TSDB_CHILD_TABLE
+#define TD_NORMAL_TABLE TSDB_NORMAL_TABLE
+
 typedef struct {
   int32_t vgId;
-  char*   dbName;
-  char*   tableFullName;
+  char*   dbFName;
+  char*   tbName;
 } SBuildTableMetaInput;
 
 typedef struct {
-  char    db[TSDB_TABLE_FNAME_LEN];
+  char    db[TSDB_DB_FNAME_LEN];
   int32_t vgVersion;
 } SBuildUseDBInput;
 
+typedef struct SField {
+  char    name[TSDB_COL_NAME_LEN];
+  uint8_t type;
+  int32_t bytes;
+} SField;
+
 #pragma pack(push, 1)
 
 // null-terminated string instead of char array to avoid too many memory consumption in case of more than 1M tableMeta
@@ -200,7 +226,7 @@ typedef struct {
 typedef struct {
   int32_t totalLen;
   int32_t len;
-  SMemRow row;
+  STSRow  *row;
 } SSubmitBlkIter;
 
 typedef struct {
@@ -212,7 +238,7 @@ typedef struct {
 int     tInitSubmitMsgIter(SSubmitMsg* pMsg, SSubmitMsgIter* pIter);
 int     tGetSubmitMsgNext(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
 int     tInitSubmitBlkIter(SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
-SMemRow tGetSubmitBlkNext(SSubmitBlkIter* pIter);
+STSRow* tGetSubmitBlkNext(SSubmitBlkIter* pIter);
 
 typedef struct {
   int32_t index;  // index of failed block in submit blocks
@@ -240,21 +266,33 @@ typedef struct SSchema {
 typedef struct {
   char    name[TSDB_TABLE_FNAME_LEN];
   int8_t  igExists;
-  int32_t numOfTags;
   int32_t numOfColumns;
-  SSchema pSchema[];
+  int32_t numOfTags;
+  SArray* pColumns;
+  SArray* pTags;
+  char    comment[TSDB_STB_COMMENT_LEN];
 } SMCreateStbReq;
 
+int32_t tSerializeSMCreateStbReq(void** buf, SMCreateStbReq* pReq);
+void*   tDeserializeSMCreateStbReq(void* buf, SMCreateStbReq* pReq);
+
 typedef struct {
   char   name[TSDB_TABLE_FNAME_LEN];
   int8_t igNotExists;
 } SMDropStbReq;
 
+int32_t tSerializeSMDropStbReq(void** buf, SMDropStbReq* pReq);
+void*   tDeserializeSMDropStbReq(void* buf, SMDropStbReq* pReq);
+
 typedef struct {
   char    name[TSDB_TABLE_FNAME_LEN];
   int8_t  alterType;
-  SSchema schema;
-} SMAlterStbReq;
+  int32_t numOfFields;
+  SArray* pFields;
+} SMAltertbReq;
+
+int32_t tSerializeSMAlterStbReq(void** buf, SMAltertbReq* pReq);
+void*   tDeserializeSMAlterStbReq(void* buf, SMAltertbReq* pReq);
 
 typedef struct {
   int32_t pid;
@@ -311,16 +349,36 @@ typedef struct {
   int64_t maxStorage;   // In unit of GB
 } SCreateAcctReq, SAlterAcctReq;
 
+int32_t tSerializeSCreateAcctReq(void** buf, SCreateAcctReq* pReq);
+void*   tDeserializeSCreateAcctReq(void* buf, SCreateAcctReq* pReq);
+
 typedef struct {
   char user[TSDB_USER_LEN];
 } SDropUserReq, SDropAcctReq;
 
+int32_t tSerializeSDropUserReq(void** buf, SDropUserReq* pReq);
+void*   tDeserializeSDropUserReq(void* buf, SDropUserReq* pReq);
+
 typedef struct {
-  int8_t type;
+  int8_t createType;
+  int8_t superUser;  // denote if it is a super user or not
   char   user[TSDB_USER_LEN];
   char   pass[TSDB_PASSWORD_LEN];
-  int8_t superUser;  // denote if it is a super user or not
-} SCreateUserReq, SAlterUserReq;
+} SCreateUserReq;
+
+int32_t tSerializeSCreateUserReq(void** buf, SCreateUserReq* pReq);
+void*   tDeserializeSCreateUserReq(void* buf, SCreateUserReq* pReq);
+
+typedef struct {
+  int8_t alterType;
+  char   user[TSDB_USER_LEN];
+  char   pass[TSDB_PASSWORD_LEN];
+  char   dbname[TSDB_DB_FNAME_LEN];
+  int8_t superUser;
+} SAlterUserReq;
+
+int32_t tSerializeSAlterUserReq(void** buf, SAlterUserReq* pReq);
+void*   tDeserializeSAlterUserReq(void* buf, SAlterUserReq* pReq);
 
 typedef struct {
   int16_t colId;     // column id
@@ -508,21 +566,26 @@ typedef struct {
 } SAlterDbReq;
 
 typedef struct {
-  char   db[TSDB_TABLE_FNAME_LEN];
+  char   db[TSDB_DB_FNAME_LEN];
   int8_t ignoreNotExists;
 } SDropDbReq;
 
 typedef struct {
-  char    db[TSDB_TABLE_FNAME_LEN];
+  char     db[TSDB_DB_FNAME_LEN];
+  uint64_t uid;
+} SDropDbRsp;
+
+typedef struct {
+  char    db[TSDB_DB_FNAME_LEN];
   int32_t vgVersion;
 } SUseDbReq;
 
 typedef struct {
-  char db[TSDB_TABLE_FNAME_LEN];
+  char db[TSDB_DB_FNAME_LEN];
 } SSyncDbReq;
 
 typedef struct {
-  char db[TSDB_TABLE_FNAME_LEN];
+  char db[TSDB_DB_FNAME_LEN];
 } SCompactDbReq;
 
 typedef struct {
@@ -579,35 +642,29 @@ typedef struct {
 typedef struct {
   int32_t vgId;
   int8_t  role;
-  int8_t  align[3];
+  int64_t numOfTables;
+  int64_t numOfTimeSeries;
   int64_t totalStorage;
   int64_t compStorage;
   int64_t pointsWritten;
-  int64_t tablesNum;
 } SVnodeLoad;
 
 typedef struct {
-  int32_t    num;
-  SVnodeLoad data[];
-} SVnodeLoads;
-
-typedef struct {
-  int32_t     sver;
+  int32_t     sver;  // software version
+  int64_t     dver;  // dnode table version in sdb
   int32_t     dnodeId;
   int64_t     clusterId;
-  int64_t     dver;
   int64_t     rebootTime;
   int64_t     updateTime;
   int32_t     numOfCores;
   int32_t     numOfSupportVnodes;
   char        dnodeEp[TSDB_EP_LEN];
   SClusterCfg clusterCfg;
-  SVnodeLoads vnodeLoads;
+  SArray*     pVloads;  // array of SVnodeLoad
 } SStatusReq;
 
-typedef struct {
-  int32_t reserved;
-} STransReq;
+int32_t tSerializeSStatusReq(void** buf, SStatusReq* pReq);
+void*   tDeserializeSStatusReq(void* buf, SStatusReq* pReq);
 
 typedef struct {
   int32_t dnodeId;
@@ -617,21 +674,22 @@ typedef struct {
 typedef struct {
   int32_t  id;
   int8_t   isMnode;
-  int8_t   align;
   SEp      ep;
 } SDnodeEp;
 
-typedef struct {
-  int32_t  num;
-  SDnodeEp eps[];
-} SDnodeEps;
-
 typedef struct {
   int64_t   dver;
   SDnodeCfg dnodeCfg;
-  SDnodeEps dnodeEps;
+  SArray*   pDnodeEps;  // Array of SDnodeEp
 } SStatusRsp;
 
+int32_t tSerializeSStatusRsp(void** buf, SStatusRsp* pRsp);
+void*   tDeserializeSStatusRsp(void* buf, SStatusRsp* pRsp);
+
+typedef struct {
+  int32_t reserve;
+} STransReq;
+
 typedef struct {
   int32_t  id;
   uint16_t port;                 // node sync Port
@@ -679,8 +737,8 @@ typedef struct {
 
 typedef struct {
   SMsgHead header;
-  char     dbFname[TSDB_DB_FNAME_LEN];
-  char     tableFname[TSDB_TABLE_FNAME_LEN];
+  char     dbFName[TSDB_DB_FNAME_LEN];
+  char     tbName[TSDB_TABLE_NAME_LEN];
 } STableInfoReq;
 
 typedef struct {
@@ -705,9 +763,10 @@ typedef struct {
 } SVgroupsInfo;
 
 typedef struct {
-  char     tbFname[TSDB_TABLE_FNAME_LEN];  // table full name
-  char     stbFname[TSDB_TABLE_FNAME_LEN];
-  char     dbFname[TSDB_DB_FNAME_LEN];
+  char     tbName[TSDB_TABLE_NAME_LEN];
+  char     stbName[TSDB_TABLE_NAME_LEN];
+  char     dbFName[TSDB_DB_FNAME_LEN];
+  uint64_t dbId;
   int32_t  numOfTags;
   int32_t  numOfColumns;
   int8_t   precision;
@@ -740,7 +799,7 @@ typedef struct {
 
 typedef struct {
   char        db[TSDB_DB_FNAME_LEN];
-  int64_t     uid;
+  uint64_t    uid;
   int32_t     vgVersion;
   int32_t     vgNum;
   int8_t      hashMethod;
@@ -1092,10 +1151,14 @@ static FORCE_INLINE void* tDeserializeSMVSubscribeReq(void* buf, SMVSubscribeReq
   return buf;
 }
 
-typedef struct SMqTmrMsg {
+typedef struct {
   int32_t reserved;
 } SMqTmrMsg;
 
+typedef struct {
+  int64_t consumerId;
+} SMqDoRebalanceMsg;
+
 typedef struct {
   int64_t status;
 } SMVSubscribeRsp;
@@ -1142,10 +1205,7 @@ typedef struct SVCreateTbReq {
   char*    name;
   uint32_t ttl;
   uint32_t keep;
-#define TD_SUPER_TABLE TSDB_SUPER_TABLE
-#define TD_CHILD_TABLE TSDB_CHILD_TABLE
-#define TD_NORMAL_TABLE TSDB_NORMAL_TABLE
-  uint8_t type;
+  uint8_t  type;
   union {
     struct {
       tb_uid_t suid;
@@ -1163,42 +1223,38 @@ typedef struct SVCreateTbReq {
       SSchema* pSchema;
     } ntbCfg;
   };
-} SVCreateTbReq;
+} SVCreateTbReq, SVUpdateTbReq;
+
+typedef struct {
+} SVCreateTbRsp, SVUpdateTbRsp;
+
+int32_t tSerializeSVCreateTbReq(void** buf, SVCreateTbReq* pReq);
+void*   tDeserializeSVCreateTbReq(void* buf, SVCreateTbReq* pReq);
 
 typedef struct {
   uint64_t ver;  // use a general definition
   SArray*  pArray;
 } SVCreateTbBatchReq;
 
-int   tSerializeSVCreateTbReq(void** buf, SVCreateTbReq* pReq);
-void* tDeserializeSVCreateTbReq(void* buf, SVCreateTbReq* pReq);
-int   tSVCreateTbBatchReqSerialize(void** buf, SVCreateTbBatchReq* pReq);
-void* tSVCreateTbBatchReqDeserialize(void* buf, SVCreateTbBatchReq* pReq);
-
 typedef struct {
-  SMsgHead head;
-} SVCreateTbRsp;
+} SVCreateTbBatchRsp;
 
-typedef struct {
-  SMsgHead head;
-  char     name[TSDB_TABLE_FNAME_LEN];
-  int8_t   ignoreNotExists;
-} SVAlterTbReq;
-
-typedef struct {
-  SMsgHead head;
-} SVAlterTbRsp;
+int32_t tSerializeSVCreateTbBatchReq(void** buf, SVCreateTbBatchReq* pReq);
+void*   tDeserializeSVCreateTbBatchReq(void* buf, SVCreateTbBatchReq* pReq);
 
 typedef struct {
-  SMsgHead head;
-  char     name[TSDB_TABLE_FNAME_LEN];
-  int64_t  suid;
+  uint64_t ver;
+  char*    name;
+  uint8_t  type;
+  tb_uid_t suid;
 } SVDropTbReq;
 
 typedef struct {
-  SMsgHead head;
 } SVDropTbRsp;
 
+int32_t tSerializeSVDropTbReq(void** buf, SVDropTbReq* pReq);
+void*   tDeserializeSVDropTbReq(void* buf, SVDropTbReq* pReq);
+
 typedef struct {
   SMsgHead head;
   int64_t  uid;
@@ -1343,9 +1399,8 @@ static FORCE_INLINE void* taosDecodeSMqHbBatchRsp(void* buf, SMqHbBatchRsp* pBat
 }
 
 typedef struct {
-  int32_t keyLen;
+  int32_t key;
   int32_t valueLen;
-  void*   key;
   void*   value;
 } SKv;
 
@@ -1367,8 +1422,7 @@ typedef struct {
 typedef struct {
   SClientHbKey connKey;
   int32_t      status;
-  int32_t      bodyLen;
-  void*        body;
+  SArray*      info;  // Array<Skv>
 } SClientHbRsp;
 
 typedef struct {
@@ -1387,9 +1441,26 @@ void* tDeserializeSClientHbReq(void* buf, SClientHbReq* pReq);
 int   tSerializeSClientHbRsp(void** buf, const SClientHbRsp* pRsp);
 void* tDeserializeSClientHbRsp(void* buf, SClientHbRsp* pRsp);
 
+
+static FORCE_INLINE void tFreeReqKvHash(SHashObj*      info) {
+  void *pIter = taosHashIterate(info, NULL);
+  while (pIter != NULL) {
+    SKv* kv = (SKv*)pIter;
+
+    tfree(kv->value);
+
+    pIter = taosHashIterate(info, pIter);
+  }
+}
+
+
 static FORCE_INLINE void  tFreeClientHbReq(void *pReq) {
   SClientHbReq* req = (SClientHbReq*)pReq;
-  if (req->info) taosHashCleanup(req->info);
+  if (req->info) {
+    tFreeReqKvHash(req->info);
+  
+    taosHashCleanup(req->info);
+  }
 }
 
 int   tSerializeSClientHbBatchReq(void** buf, const SClientHbBatchReq* pReq);
@@ -1405,22 +1476,39 @@ static FORCE_INLINE void tFreeClientHbBatchReq(void* pReq, bool deep) {
   free(pReq);
 }
 
+static FORCE_INLINE void tFreeClientKv(void *pKv) {
+  SKv *kv = (SKv *)pKv;
+  if (kv) {
+    tfree(kv->value);
+  }
+}
+
+static FORCE_INLINE void  tFreeClientHbRsp(void *pRsp) {
+  SClientHbRsp* rsp = (SClientHbRsp*)pRsp;
+  if (rsp->info) taosArrayDestroyEx(rsp->info, tFreeClientKv);
+}
+
+
+static FORCE_INLINE void tFreeClientHbBatchRsp(void* pRsp) {
+  SClientHbBatchRsp *rsp = (SClientHbBatchRsp*)pRsp;
+  taosArrayDestroyEx(rsp->rsps, tFreeClientHbRsp);
+}
+
+
 int   tSerializeSClientHbBatchRsp(void** buf, const SClientHbBatchRsp* pBatchRsp);
 void* tDeserializeSClientHbBatchRsp(void* buf, SClientHbBatchRsp* pBatchRsp);
 
 static FORCE_INLINE int taosEncodeSKv(void** buf, const SKv* pKv) {
   int tlen = 0;
-  tlen += taosEncodeFixedI32(buf, pKv->keyLen);
+  tlen += taosEncodeFixedI32(buf, pKv->key);
   tlen += taosEncodeFixedI32(buf, pKv->valueLen);
-  tlen += taosEncodeBinary(buf, pKv->key, pKv->keyLen);
   tlen += taosEncodeBinary(buf, pKv->value, pKv->valueLen);
   return tlen;
 }
 
 static FORCE_INLINE void* taosDecodeSKv(void* buf, SKv* pKv) {
-  buf = taosDecodeFixedI32(buf, &pKv->keyLen);
+  buf = taosDecodeFixedI32(buf, &pKv->key);
   buf = taosDecodeFixedI32(buf, &pKv->valueLen);
-  buf = taosDecodeBinary(buf, &pKv->key, pKv->keyLen);
   buf = taosDecodeBinary(buf, &pKv->value, pKv->valueLen);
   return buf;
 }
@@ -1526,6 +1614,7 @@ static FORCE_INLINE void* taosDecodeSMqMsg(void* buf, SMqHbMsg* pMsg) {
 }
 
 typedef struct SMqSetCVgReq {
+  int64_t  leftForVer;
   int32_t  vgId;
   int64_t  oldConsumerId;
   int64_t  newConsumerId;
@@ -1560,6 +1649,7 @@ static FORCE_INLINE void* tDecodeSSubQueryMsg(void* buf, SSubQueryMsg* pMsg) {
 
 static FORCE_INLINE int32_t tEncodeSMqSetCVgReq(void** buf, const SMqSetCVgReq* pReq) {
   int32_t tlen = 0;
+  tlen += taosEncodeFixedI64(buf, pReq->leftForVer);
   tlen += taosEncodeFixedI32(buf, pReq->vgId);
   tlen += taosEncodeFixedI64(buf, pReq->oldConsumerId);
   tlen += taosEncodeFixedI64(buf, pReq->newConsumerId);
@@ -1568,12 +1658,13 @@ static FORCE_INLINE int32_t tEncodeSMqSetCVgReq(void** buf, const SMqSetCVgReq*
   tlen += taosEncodeString(buf, pReq->sql);
   tlen += taosEncodeString(buf, pReq->logicalPlan);
   tlen += taosEncodeString(buf, pReq->physicalPlan);
-  tlen += taosEncodeString(buf, (char*)pReq->qmsg);
+  tlen += taosEncodeString(buf, pReq->qmsg);
   //tlen += tEncodeSSubQueryMsg(buf, &pReq->msg);
   return tlen;
 }
 
 static FORCE_INLINE void* tDecodeSMqSetCVgReq(void* buf, SMqSetCVgReq* pReq) {
+  buf = taosDecodeFixedI64(buf, &pReq->leftForVer);
   buf = taosDecodeFixedI32(buf, &pReq->vgId);
   buf = taosDecodeFixedI64(buf, &pReq->oldConsumerId);
   buf = taosDecodeFixedI64(buf, &pReq->newConsumerId);
@@ -1582,7 +1673,7 @@ static FORCE_INLINE void* tDecodeSMqSetCVgReq(void* buf, SMqSetCVgReq* pReq) {
   buf = taosDecodeString(buf, &pReq->sql);
   buf = taosDecodeString(buf, &pReq->logicalPlan);
   buf = taosDecodeString(buf, &pReq->physicalPlan);
-  buf = taosDecodeString(buf, (char**)&pReq->qmsg);
+  buf = taosDecodeString(buf, &pReq->qmsg);
   //buf = tDecodeSSubQueryMsg(buf, &pReq->msg);
   return buf;
 }
@@ -1595,19 +1686,56 @@ typedef struct SMqSetCVgRsp {
   char     cGroup[TSDB_CONSUMER_GROUP_LEN];
 } SMqSetCVgRsp;
 
-typedef struct SMqColData {
-  int16_t colId;
-  int16_t type;
-  int16_t bytes;
-} SMqColMeta;
+typedef struct {
+  uint32_t nCols;
+  SSchema *pSchema;
+} SSchemaWrapper;
+
+static FORCE_INLINE int32_t tEncodeSSchema(void** buf, const SSchema* pSchema) {
+  int32_t tlen = 0;
+  tlen += taosEncodeFixedI8(buf, pSchema->type);
+  tlen += taosEncodeFixedI32(buf, pSchema->bytes);
+  tlen += taosEncodeFixedI32(buf, pSchema->colId);
+  tlen += taosEncodeString(buf, pSchema->name);
+  return tlen;
+}
+
+static FORCE_INLINE void* tDecodeSSchema(void* buf, SSchema* pSchema) {
+  buf = taosDecodeFixedI8(buf, &pSchema->type);
+  buf = taosDecodeFixedI32(buf, &pSchema->bytes);
+  buf = taosDecodeFixedI32(buf, &pSchema->colId);
+  buf = taosDecodeStringTo(buf, pSchema->name);
+  return buf;
+}
+
+static FORCE_INLINE int32_t tEncodeSSchemaWrapper(void** buf, const SSchemaWrapper* pSW) {
+  int32_t tlen = 0;
+  tlen += taosEncodeFixedU32(buf, pSW->nCols);
+  for (int32_t i = 0; i < pSW->nCols; i ++) {
+    tlen += tEncodeSSchema(buf, &pSW->pSchema[i]);
+  }
+  return tlen;
+}
+
+static FORCE_INLINE void* tDecodeSSchemaWrapper(void* buf, SSchemaWrapper* pSW) {
+  buf = taosDecodeFixedU32(buf, &pSW->nCols);
+  pSW->pSchema = (SSchema*) calloc(pSW->nCols, sizeof(SSchema));
+  if (pSW->pSchema == NULL) {
+    return NULL;
+  }
+  for (int32_t i = 0; i < pSW->nCols; i ++) {
+    buf = tDecodeSSchema(buf, &pSW->pSchema[i]);
+  }
+  return buf;
+}
 
-typedef struct SMqTbData {
+typedef struct {
   int64_t    uid;
   int32_t    numOfRows;
-  char       colData[];
+  char*      colData;
 } SMqTbData;
 
-typedef struct SMqTopicBlk {
+typedef struct {
   char       topicName[TSDB_TOPIC_FNAME_LEN];
   int64_t    committedOffset;
   int64_t    reqOffset;
@@ -1618,21 +1746,19 @@ typedef struct SMqTopicBlk {
   SMqTbData* tbData;
 } SMqTopicData;
 
-typedef struct SMqConsumeRsp {
-  int64_t       consumerId;
-  int32_t       numOfCols;
-  SMqColMeta*   meta;
-  int32_t       numOfTopics;
-  SMqTopicData* data;
+typedef struct {
+  int64_t         consumerId;
+  SSchemaWrapper* schemas;
+  int64_t         committedOffset;
+  int64_t         reqOffset;
+  int64_t         rspOffset;
+  int32_t         skipLogNum;
+  int32_t         numOfTopics;
+  SArray*         pBlockData;   //SArray<SSDataBlock>
 } SMqConsumeRsp;
 
-static FORCE_INLINE int32_t tEncodeSMqConsumeRsp(void** buf, const SMqConsumeRsp* pRsp) {
-  int32_t tlen = 0;
-  return tlen;
-}
-
 // one req for one vg+topic
-typedef struct SMqConsumeReq {
+typedef struct {
   SMsgHead       head;
   //0: commit only, current offset
   //1: consume only, poll next offset
@@ -1648,22 +1774,27 @@ typedef struct SMqConsumeReq {
   char           topic[TSDB_TOPIC_FNAME_LEN];
 } SMqConsumeReq;
 
-typedef struct SMqSubVgEp {
+typedef struct {
   int32_t vgId;
   SEpSet  epSet;
 } SMqSubVgEp;
 
-typedef struct SMqSubTopicEp {
+typedef struct {
   char    topic[TSDB_TOPIC_FNAME_LEN];
   SArray* vgs;   // SArray<SMqSubVgEp>
 } SMqSubTopicEp;
 
-typedef struct SMqCMGetSubEpRsp {
+typedef struct {
   int64_t consumerId;
+  int64_t epoch;
   char    cgroup[TSDB_CONSUMER_GROUP_LEN];
   SArray* topics;  // SArray<SMqSubTopicEp>
 } SMqCMGetSubEpRsp;
 
+static FORCE_INLINE void tDeleteSMqSubTopicEp(SMqSubTopicEp* pSubTopicEp) {
+  taosArrayDestroy(pSubTopicEp->vgs);
+}
+
 static FORCE_INLINE int32_t tEncodeSMqSubVgEp(void** buf, const SMqSubVgEp* pVgEp) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI32(buf, pVgEp->vgId);
@@ -1677,6 +1808,10 @@ static FORCE_INLINE void* tDecodeSMqSubVgEp(void* buf, SMqSubVgEp* pVgEp) {
   return buf;
 }
 
+static FORCE_INLINE void tDeleteSMqCMGetSubEpRsp(SMqCMGetSubEpRsp* pRsp) {
+  taosArrayDestroyEx(pRsp->topics, (void (*)(void*)) tDeleteSMqSubTopicEp);
+}
+
 static FORCE_INLINE int32_t tEncodeSMqSubTopicEp(void** buf, const SMqSubTopicEp* pTopicEp) {
   int32_t tlen = 0;
   tlen += taosEncodeString(buf, pTopicEp->topic);
@@ -1708,6 +1843,7 @@ static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicE
 static FORCE_INLINE int32_t tEncodeSMqCMGetSubEpRsp(void** buf, const SMqCMGetSubEpRsp* pRsp) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI64(buf, pRsp->consumerId);
+  tlen += taosEncodeFixedI64(buf, pRsp->epoch);
   tlen += taosEncodeString(buf, pRsp->cgroup);
   int32_t sz = taosArrayGetSize(pRsp->topics);
   tlen += taosEncodeFixedI32(buf, sz);
@@ -1720,6 +1856,7 @@ static FORCE_INLINE int32_t tEncodeSMqCMGetSubEpRsp(void** buf, const SMqCMGetSu
 
 static FORCE_INLINE void* tDecodeSMqCMGetSubEpRsp(void* buf, SMqCMGetSubEpRsp* pRsp) {
   buf = taosDecodeFixedI64(buf, &pRsp->consumerId);
+  buf = taosDecodeFixedI64(buf, &pRsp->epoch);
   buf = taosDecodeStringTo(buf, pRsp->cgroup);
   int32_t sz;
   buf = taosDecodeFixedI32(buf, &sz);

include/common/tmsgdef.h

@@ -141,7 +141,8 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_MND_DROP_TOPIC, "mnode-drop-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_MND_SUBSCRIBE, "mnode-subscribe", SCMSubscribeReq, SCMSubscribeRsp)
   TD_DEF_MSG_TYPE(TDMT_MND_GET_SUB_EP, "mnode-get-sub-ep", SMqCMGetSubEpReq, SMqCMGetSubEpRsp)
-  TD_DEF_MSG_TYPE(TDMT_MND_MQ_TIMER, "mnode-timer", SMqTmrMsg, SMqTmrMsg)
+  TD_DEF_MSG_TYPE(TDMT_MND_MQ_TIMER, "mnode-mq-timer", SMqTmrMsg, SMqTmrMsg)
+  TD_DEF_MSG_TYPE(TDMT_MND_MQ_DO_REBALANCE, "mnode-mq-do-rebalance", SMqDoRebalanceMsg, SMqDoRebalanceMsg)
 
   // Requests handled by VNODE
   TD_NEW_MSG_SEG(TDMT_VND_MSG)

include/common/tschema.h

@@ -18,13 +18,12 @@
 
 #include "os.h"
 #include "tarray.h"
+#include "ttypes.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef uint16_t col_id_t;
-
 #if 0
 typedef struct STColumn {
   /// column name

include/common/ttokendef.h

@@ -207,36 +207,77 @@
 #define TK_INTO                           189
 #define TK_VALUES                         190
 
-#define NEW_TK_UNION                            1
-#define NEW_TK_ALL                              2
-#define NEW_TK_MINUS                            3
-#define NEW_TK_EXCEPT                           4
-#define NEW_TK_INTERSECT                        5
-#define NEW_TK_NK_PLUS                          6
-#define NEW_TK_NK_MINUS                         7
-#define NEW_TK_NK_STAR                          8
-#define NEW_TK_NK_SLASH                         9
-#define NEW_TK_SHOW                            10
-#define NEW_TK_DATABASES                       11
-#define NEW_TK_NK_ID                           12
-#define NEW_TK_NK_LP                           13
-#define NEW_TK_NK_RP                           14
-#define NEW_TK_NK_COMMA                        15
-#define NEW_TK_NK_LITERAL                      16
-#define NEW_TK_NK_DOT                          17
-#define NEW_TK_SELECT                          18
-#define NEW_TK_DISTINCT                        19
-#define NEW_TK_AS                              20
-#define NEW_TK_FROM                            21
-#define NEW_TK_WITH                            22
-#define NEW_TK_RECURSIVE                       23
-#define NEW_TK_ORDER                           24
-#define NEW_TK_BY                              25
-#define NEW_TK_ASC                             26
-#define NEW_TK_DESC                            27
-#define NEW_TK_NULLS                           28
-#define NEW_TK_FIRST                           29
-#define NEW_TK_LAST                            30
+#define NEW_TK_OR                               1
+#define NEW_TK_AND                              2
+#define NEW_TK_UNION                            3
+#define NEW_TK_ALL                              4
+#define NEW_TK_MINUS                            5
+#define NEW_TK_EXCEPT                           6
+#define NEW_TK_INTERSECT                        7
+#define NEW_TK_NK_PLUS                          8
+#define NEW_TK_NK_MINUS                         9
+#define NEW_TK_NK_STAR                         10
+#define NEW_TK_NK_SLASH                        11
+#define NEW_TK_NK_REM                          12
+#define NEW_TK_SHOW                            13
+#define NEW_TK_DATABASES                       14
+#define NEW_TK_NK_INTEGER                      15
+#define NEW_TK_NK_FLOAT                        16
+#define NEW_TK_NK_STRING                       17
+#define NEW_TK_NK_BOOL                         18
+#define NEW_TK_TIMESTAMP                       19
+#define NEW_TK_NK_VARIABLE                     20
+#define NEW_TK_NK_COMMA                        21
+#define NEW_TK_NK_ID                           22
+#define NEW_TK_NK_LP                           23
+#define NEW_TK_NK_RP                           24
+#define NEW_TK_NK_DOT                          25
+#define NEW_TK_BETWEEN                         26
+#define NEW_TK_NOT                             27
+#define NEW_TK_IS                              28
+#define NEW_TK_NULL                            29
+#define NEW_TK_NK_LT                           30
+#define NEW_TK_NK_GT                           31
+#define NEW_TK_NK_LE                           32
+#define NEW_TK_NK_GE                           33
+#define NEW_TK_NK_NE                           34
+#define NEW_TK_NK_EQ                           35
+#define NEW_TK_LIKE                            36
+#define NEW_TK_MATCH                           37
+#define NEW_TK_NMATCH                          38
+#define NEW_TK_IN                              39
+#define NEW_TK_FROM                            40
+#define NEW_TK_AS                              41
+#define NEW_TK_JOIN                            42
+#define NEW_TK_ON                              43
+#define NEW_TK_INNER                           44
+#define NEW_TK_SELECT                          45
+#define NEW_TK_DISTINCT                        46
+#define NEW_TK_WHERE                           47
+#define NEW_TK_PARTITION                       48
+#define NEW_TK_BY                              49
+#define NEW_TK_SESSION                         50
+#define NEW_TK_STATE_WINDOW                    51
+#define NEW_TK_INTERVAL                        52
+#define NEW_TK_SLIDING                         53
+#define NEW_TK_FILL                            54
+#define NEW_TK_VALUE                           55
+#define NEW_TK_NONE                            56
+#define NEW_TK_PREV                            57
+#define NEW_TK_LINEAR                          58
+#define NEW_TK_NEXT                            59
+#define NEW_TK_GROUP                           60
+#define NEW_TK_HAVING                          61
+#define NEW_TK_ORDER                           62
+#define NEW_TK_SLIMIT                          63
+#define NEW_TK_SOFFSET                         64
+#define NEW_TK_LIMIT                           65
+#define NEW_TK_OFFSET                          66
+#define NEW_TK_ASC                             67
+#define NEW_TK_DESC                            68
+#define NEW_TK_NULLS                           69
+#define NEW_TK_FIRST                           70
+#define NEW_TK_LAST                            71
 
 #define TK_SPACE                          300
 #define TK_COMMENT                        301
@@ -247,6 +288,8 @@
 #define TK_FILE                           306
 #define TK_QUESTION                       307   // denoting the placeholder of "?",when invoking statement bind query
 
+#define TK_NIL                            65535
+
 #endif
 
 

include/common/ttypes.h

@@ -10,8 +10,10 @@ extern "C" {
 
 // ----------------- For variable data types such as TSDB_DATA_TYPE_BINARY and TSDB_DATA_TYPE_NCHAR
 typedef int32_t  VarDataOffsetT;
-typedef uint16_t TDRowLenT;    // not including overhead: 0 ~ 65535
-typedef uint32_t TDRowTLenT;   // total length, including overhead
+typedef uint32_t TDRowLenT;
+typedef uint8_t  TDRowValT;
+typedef uint16_t col_id_t;
+typedef int8_t   col_type_t;
 
 typedef struct tstr {
   VarDataLenT len;

include/dnode/mnode/mnode.h

@@ -27,6 +27,7 @@ typedef struct SMnodeMsg SMnodeMsg;
 typedef int32_t (*SendReqToDnodeFp)(SDnode *pDnode, struct SEpSet *epSet, struct SRpcMsg *rpcMsg);
 typedef int32_t (*SendReqToMnodeFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 typedef int32_t (*PutReqToMWriteQFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
+typedef int32_t (*PutReqToMReadQFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 typedef void (*SendRedirectRspFp)(SDnode *pDnode, struct SRpcMsg *rpcMsg);
 
 typedef struct SMnodeLoad {
@@ -64,6 +65,7 @@ typedef struct {
   SMnodeCfg         cfg;
   SDnode           *pDnode;
   PutReqToMWriteQFp putReqToMWriteQFp;
+  PutReqToMReadQFp  putReqToMReadQFp;
   SendReqToDnodeFp  sendReqToDnodeFp;
   SendReqToMnodeFp  sendReqToMnodeFp;
   SendRedirectRspFp sendRedirectRspFp;

include/libs/catalog/catalog.h

@@ -32,6 +32,15 @@ extern "C" {
 
 struct SCatalog;
 
+enum {
+  CTG_DBG_DB_NUM = 1,
+  CTG_DBG_META_NUM,
+  CTG_DBG_STB_NUM,
+  CTG_DBG_DB_RENT_NUM,
+  CTG_DBG_STB_RENT_NUM,
+};
+
+
 typedef struct SCatalogReq {
   SArray *pTableName;     // element is SNAME
   SArray *pUdf;           // udf name
@@ -49,16 +58,19 @@ typedef struct SCatalogCfg {
   uint32_t maxTblCacheNum;
   uint32_t maxDBCacheNum;
   uint32_t dbRentSec;
-  uint32_t stableRentSec;
+  uint32_t stbRentSec;
 } SCatalogCfg;
 
 typedef struct SSTableMetaVersion {
+  char     dbFName[TSDB_DB_FNAME_LEN];
+  char     stbName[TSDB_TABLE_NAME_LEN];
   uint64_t suid;
   int16_t  sversion;
   int16_t  tversion;  
 } SSTableMetaVersion;
 
 typedef struct SDbVgVersion {
+  char    dbFName[TSDB_DB_FNAME_LEN];
   int64_t dbId;
   int32_t vgVersion;
 } SDbVgVersion;
@@ -96,7 +108,11 @@ int32_t catalogGetDBVgroupVersion(struct SCatalog* pCatalog, const char* dbName,
  */
 int32_t catalogGetDBVgroup(struct SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const char* pDBName, bool forceUpdate, SArray** pVgroupList);
 
-int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDBVgroupInfo* dbInfo);
+int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, uint64_t dbId, SDBVgroupInfo* dbInfo);
+
+int32_t catalogRemoveDB(struct SCatalog* pCatalog, const char* dbName, uint64_t dbId);
+
+int32_t catalogRemoveSTableMeta(struct SCatalog* pCatalog, const char* dbName, const char* stbName, uint64_t suid);
 
 /**
  * Get a table's meta data. 
@@ -120,6 +136,8 @@ int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void * pTransporter, cons
  */
 int32_t catalogGetSTableMeta(struct SCatalog* pCatalog, void * pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta);
 
+int32_t catalogUpdateSTableMeta(struct SCatalog* pCatalog, STableMetaRsp *rspMsg);
+
 
 /**
  * Force renew a table's local cached meta data. 

include/libs/function/functionMgt.h

@@ -22,6 +22,81 @@ extern "C" {
 
 #include "nodes.h"
 
+typedef enum EFunctionType {
+  // aggregate function
+  FUNCTION_TYPE_APERCENTILE = 1,
+  FUNCTION_TYPE_AVG,
+  FUNCTION_TYPE_COUNT,
+  FUNCTION_TYPE_ELAPSED,
+  FUNCTION_TYPE_IRATE,
+  FUNCTION_TYPE_LAST_ROW,
+  FUNCTION_TYPE_LEASTSQUARES,
+  FUNCTION_TYPE_MAX,
+  FUNCTION_TYPE_MIN,
+  FUNCTION_TYPE_MODE,
+  FUNCTION_TYPE_PERCENTILE,
+  FUNCTION_TYPE_SPREAD,
+  FUNCTION_TYPE_STDDEV,
+  FUNCTION_TYPE_SUM,
+  FUNCTION_TYPE_TWA,
+
+  // nonstandard SQL function
+  FUNCTION_TYPE_BOTTOM = 500,
+  FUNCTION_TYPE_CSUM,
+  FUNCTION_TYPE_DERIVATIVE,
+  FUNCTION_TYPE_DIFF,
+  FUNCTION_TYPE_FIRST,
+  FUNCTION_TYPE_INTERP,
+  FUNCTION_TYPE_LAST,
+  FUNCTION_TYPE_MAVG,
+  FUNCTION_TYPE_SAMPLE,
+  FUNCTION_TYPE_TAIL,
+  FUNCTION_TYPE_TOP,
+  FUNCTION_TYPE_UNIQUE,
+
+  // math function
+  FUNCTION_TYPE_ABS = 1000,
+  FUNCTION_TYPE_ACOS,
+  FUNCTION_TYPE_ASION,
+  FUNCTION_TYPE_ATAN,
+  FUNCTION_TYPE_CEIL,
+  FUNCTION_TYPE_COS,
+  FUNCTION_TYPE_FLOOR,
+  FUNCTION_TYPE_LOG,
+  FUNCTION_TYPE_POW,
+  FUNCTION_TYPE_ROUND,
+  FUNCTION_TYPE_SIN,
+  FUNCTION_TYPE_SQRT,
+  FUNCTION_TYPE_TAN,
+
+  // string function
+  FUNCTION_TYPE_CHAR_LENGTH = 1500,
+  FUNCTION_TYPE_CONCAT,
+  FUNCTION_TYPE_CONCAT_WS,
+  FUNCTION_TYPE_LENGTH,
+
+  // conversion function
+  FUNCTION_TYPE_CAST = 2000,
+  FUNCTION_TYPE_TO_ISO8601,
+  FUNCTION_TYPE_TO_JSON,
+  FUNCTION_TYPE_UNIXTIMESTAMP,
+
+  // date and time function
+  FUNCTION_TYPE_NOW = 2500,
+  FUNCTION_TYPE_TIMEDIFF,
+  FUNCTION_TYPE_TIMETRUNCATE,
+  FUNCTION_TYPE_TIMEZONE,
+  FUNCTION_TYPE_TODAY,
+
+  // system function
+  FUNCTION_TYPE_DATABASE = 3000,
+  FUNCTION_TYPE_CLIENT_VERSION,
+  FUNCTION_TYPE_SERVER_SERSION,
+  FUNCTION_TYPE_SERVER_STATUS,
+  FUNCTION_TYPE_CURRENT_USER,
+  FUNCTION_TYPE_USER
+} EFunctionType;
+
 struct SqlFunctionCtx;
 struct SResultRowEntryInfo;
 struct STimeWindow;
@@ -47,14 +122,18 @@ int32_t fmFuncMgtInit();
 
 int32_t fmGetHandle(FuncMgtHandle* pHandle);
 
-int32_t fmGetFuncId(FuncMgtHandle handle, const char* name);
-int32_t fmGetFuncResultType(FuncMgtHandle handle, SFunctionNode* pFunc);
+int32_t fmGetFuncInfo(FuncMgtHandle handle, const char* pFuncName, int32_t* pFuncId, int32_t* pFuncType);
+
+int32_t fmGetFuncResultType(SFunctionNode* pFunc);
+
 bool fmIsAggFunc(int32_t funcId);
+bool fmIsScalarFunc(int32_t funcId);
+bool fmIsNonstandardSQLFunc(int32_t funcId);
 bool fmIsStringFunc(int32_t funcId);
-bool fmIsTimestampFunc(int32_t funcId);
+bool fmIsDatetimeFunc(int32_t funcId);
 bool fmIsTimelineFunc(int32_t funcId);
 bool fmIsTimeorderFunc(int32_t funcId);
-bool fmIsNonstandardSQLFunc(int32_t funcId);
+
 int32_t fmFuncScanType(int32_t funcId);
 
 int32_t fmGetFuncExecFuncs(FuncMgtHandle handle, int32_t funcId, SFuncExecFuncs* pFpSet);

include/libs/parser/parsenodes.h

@@ -37,12 +37,6 @@ typedef struct SQueryNode {
 
 #define queryNodeType(nodeptr) (((const SQueryNode*)(nodeptr))->type)
 
-typedef struct SField {
-  char     name[TSDB_COL_NAME_LEN];
-  uint8_t  type;
-  int32_t  bytes;
-} SField;
-
 typedef struct SFieldInfo {
   int16_t     numOfOutput;   // number of column in result
   SField     *final;

include/libs/qcom/query.h

@@ -81,20 +81,19 @@ typedef struct STableMeta {
 } STableMeta;
 
 typedef struct SDBVgroupInfo {
-  SRWLatch  lock;
-  int64_t   dbId;
   int32_t   vgVersion;  
   int8_t    hashMethod;
-  SHashObj *vgInfo;  //key:vgId, value:SVgroupInfo
+  SHashObj *vgHash;  //key:vgId, value:SVgroupInfo
 } SDBVgroupInfo;
 
 typedef struct SUseDbOutput {
-  char db[TSDB_DB_FNAME_LEN];
-  SDBVgroupInfo dbVgroup;
+  char           db[TSDB_DB_FNAME_LEN];
+  uint64_t       dbId;
+  SDBVgroupInfo *dbVgroup;
 } SUseDbOutput;
 
 enum {
-  META_TYPE_NON_TABLE = 1,
+  META_TYPE_NULL_TABLE = 1,
   META_TYPE_CTABLE,
   META_TYPE_TABLE,
   META_TYPE_BOTH_TABLE
@@ -103,8 +102,10 @@ enum {
 
 typedef struct STableMetaOutput {
   int32_t     metaType;
-  char        ctbFname[TSDB_TABLE_FNAME_LEN];
-  char        tbFname[TSDB_TABLE_FNAME_LEN];
+  uint64_t    dbId;
+  char        dbFName[TSDB_DB_FNAME_LEN];
+  char        ctbName[TSDB_TABLE_NAME_LEN];
+  char        tbName[TSDB_TABLE_NAME_LEN];
   SCTableMeta ctbMeta;
   STableMeta *tbMeta;
 } STableMetaOutput;
@@ -159,11 +160,13 @@ void initQueryModuleMsgHandle();
 const SSchema* tGetTbnameColumnSchema();
 bool tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags);
 
+int32_t queryCreateTableMetaFromMsg(STableMetaRsp* msg, bool isSuperTable, STableMeta **pMeta);
+
 extern int32_t (*queryBuildMsg[TDMT_MAX])(void* input, char **msg, int32_t msgSize, int32_t *msgLen);
 extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char *msg, int32_t msgSize);
 
 
-#define SET_META_TYPE_NONE(t) (t) = META_TYPE_NON_TABLE
+#define SET_META_TYPE_NULL(t) (t) = META_TYPE_NULL_TABLE
 #define SET_META_TYPE_CTABLE(t) (t) = META_TYPE_CTABLE
 #define SET_META_TYPE_TABLE(t) (t) = META_TYPE_TABLE
 #define SET_META_TYPE_BOTH_TABLE(t) (t) = META_TYPE_BOTH_TABLE

include/libs/transport/trpc.h

@@ -29,6 +29,8 @@ extern "C" {
 
 extern int tsRpcHeadSize;
 
+typedef struct SRpcPush SRpcPush;
+
 typedef struct SRpcConnInfo {
   uint32_t clientIp;
   uint16_t clientPort;
@@ -43,8 +45,17 @@ typedef struct SRpcMsg {
   int32_t code;
   void *  handle;   // rpc handle returned to app
   void *  ahandle;  // app handle set by client
+  int     persist;  // keep handle or not, default 0
+
+  SRpcPush *push;
+
 } SRpcMsg;
 
+typedef struct SRpcPush {
+  void *arg;
+  int (*callback)(void *arg, SRpcMsg *rpcMsg);
+} SRpcPush;
+
 typedef struct SRpcInit {
   uint16_t localPort;     // local port
   char *   label;         // for debug purpose
@@ -83,6 +94,7 @@ int     rpcGetConnInfo(void *thandle, SRpcConnInfo *pInfo);
 void    rpcSendRecv(void *shandle, SEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp);
 int     rpcReportProgress(void *pConn, char *pCont, int contLen);
 void    rpcCancelRequest(int64_t rid);
+
 #ifdef __cplusplus
 }
 #endif

include/nodes/nodes.h

@@ -22,6 +22,33 @@ extern "C" {
 
 #include "tdef.h"
 
+#define nodeType(nodeptr) (((const SNode*)(nodeptr))->type)
+#define setNodeType(nodeptr, type) (((SNode*)(nodeptr))->type = (type))
+
+#define LIST_LENGTH(l) (NULL != (l) ? (l)->length : 0)
+
+#define FOREACH(node, list)	\
+  for (SListCell* cell = (NULL != (list) ? (list)->pHead : NULL); (NULL != cell ? (node = cell->pNode, true) : (node = NULL, false)); cell = cell->pNext)
+
+// only be use in FOREACH
+#define ERASE_NODE(list) \
+  if (NULL == cell->pPrev) { \
+    (list)->pHead = cell->pNext; \
+  } else { \
+    cell->pPrev->pNext = cell->pNext; \
+    cell->pNext->pPrev = cell->pPrev; \
+  } \
+  SListCell* tmp = cell; \
+  cell = cell->pNext; \
+  tfree(tmp);
+
+#define REPLACE_NODE(newNode) cell->pNode = (SNode*)(newNode)
+
+#define FORBOTH(node1, list1, node2, list2) \
+  for (SListCell* cell1 = (NULL != (list1) ? (list1)->pHead : NULL), *cell2 = (NULL != (list2) ? (list2)->pHead : NULL); \
+    (NULL == cell1 ? (node1 = NULL, false) : (node1 = cell1->pNode, true)), (NULL == cell2 ? (node2 = NULL, false) : (node2 = cell2->pNode, true)), (node1 != NULL && node2 != NULL); \
+    cell1 = cell1->pNext, cell2 = cell2->pNext)
+
 typedef enum ENodeType {
   QUERY_NODE_COLUMN = 1,
   QUERY_NODE_VALUE,
@@ -38,6 +65,11 @@ typedef enum ENodeType {
   QUERY_NODE_STATE_WINDOW,
   QUERY_NODE_SESSION_WINDOW,
   QUERY_NODE_INTERVAL_WINDOW,
+  QUERY_NODE_NODE_LIST,
+  QUERY_NODE_FILL,
+
+  // only for parser
+  QUERY_NODE_RAW_EXPR,
 
   QUERY_NODE_SET_OPERATOR,
   QUERY_NODE_SELECT_STMT,
@@ -52,28 +84,24 @@ typedef struct SNode {
   ENodeType type;
 } SNode;
 
-#define nodeType(nodeptr) (((const SNode*)(nodeptr))->type)
-#define setNodeType(nodeptr, type) (((SNode*)(nodeptr))->type = (type))
-
 typedef struct SListCell {
-  SNode* pNode;
+  struct SListCell* pPrev;
   struct SListCell* pNext;
+  SNode* pNode;
 } SListCell;
 
 typedef struct SNodeList {
   int16_t length;
-  SListCell* pHeader;
+  SListCell* pHead;
+  SListCell* pTail;
 } SNodeList;
 
-#define LIST_LENGTH(l) (NULL != (l) ? (l)->length : 0)
-
-#define FOREACH(node, list)	\
-  for (SListCell* cell = (NULL != (list) ? (list)->pHeader : NULL); (NULL != cell ? (node = cell->pNode, true) : (node = NULL, false)); cell = cell->pNext)
-
-#define FORBOTH(node1, list1, node2, list2) \
-  for (SListCell* cell1 = (NULL != (list1) ? (list1)->pHeader : NULL), *cell2 = (NULL != (list2) ? (list2)->pHeader : NULL); \
-    (NULL == cell1 ? (node1 = NULL, false) : (node1 = cell1->pNode, true)), (NULL == cell2 ? (node2 = NULL, false) : (node2 = cell2->pNode, true)), (node1 != NULL && node2 != NULL); \
-    cell1 = cell1->pNext, cell2 = cell2->pNext)
+typedef struct SRawExprNode {
+  ENodeType nodeType;
+  char* p;
+  uint32_t n;
+  SNode* pNode;
+} SRawExprNode;
 
 typedef struct SDataType {
   uint8_t type;
@@ -86,6 +114,7 @@ typedef struct SExprNode {
   ENodeType nodeType;
   SDataType resType;
   char aliasName[TSDB_COL_NAME_LEN];
+  SNodeList* pAssociationList;
 } SExprNode;
 
 typedef enum EColumnType {
@@ -99,12 +128,22 @@ typedef struct SColumnNode {
   EColumnType colType; // column or tag
   char dbName[TSDB_DB_NAME_LEN];
   char tableName[TSDB_TABLE_NAME_LEN];
+  char tableAlias[TSDB_TABLE_NAME_LEN];
   char colName[TSDB_COL_NAME_LEN];
+  SNode* pProjectRef;
 } SColumnNode;
 
 typedef struct SValueNode {
-  SExprNode type; // QUERY_NODE_VALUE
+  SExprNode node; // QUERY_NODE_VALUE
   char* literal;
+  bool isDuration;
+  union {
+    bool b;
+    int64_t i;
+    uint64_t u;
+    double d;
+    char* p;
+  } datum;
 } SValueNode;
 
 typedef enum EOperatorType {
@@ -135,7 +174,7 @@ typedef enum EOperatorType {
 } EOperatorType;
 
 typedef struct SOperatorNode {
-  SExprNode type; // QUERY_NODE_OPERATOR
+  SExprNode node; // QUERY_NODE_OPERATOR
   EOperatorType opType;
   SNode* pLeft;
   SNode* pRight;
@@ -156,25 +195,34 @@ typedef struct SLogicConditionNode {
 typedef struct SIsNullCondNode {
   ENodeType type; // QUERY_NODE_IS_NULL_CONDITION
   SNode* pExpr;
-  bool isNot;
+  bool isNull;
 } SIsNullCondNode;
 
+typedef struct SNodeListNode {
+  ENodeType type; // QUERY_NODE_NODE_LIST
+  SNodeList* pNodeList;
+} SNodeListNode;
+
 typedef struct SFunctionNode {
-  SExprNode type; // QUERY_NODE_FUNCTION
+  SExprNode node; // QUERY_NODE_FUNCTION
   char functionName[TSDB_FUNC_NAME_LEN];
   int32_t funcId;
-  SNodeList* pParameterList; // SNode
+  int32_t funcType;
+  SNodeList* pParameterList;
 } SFunctionNode;
 
 typedef struct STableNode {
   ENodeType type;
+  char dbName[TSDB_DB_NAME_LEN];
   char tableName[TSDB_TABLE_NAME_LEN];
-  char tableAliasName[TSDB_COL_NAME_LEN];
+  char tableAlias[TSDB_TABLE_NAME_LEN];
 } STableNode;
 
+struct STableMeta;
+
 typedef struct SRealTableNode {
   STableNode table; // QUERY_NODE_REAL_TABLE
-  char dbName[TSDB_DB_NAME_LEN];
+  struct STableMeta* pMeta;
 } SRealTableNode;
 
 typedef struct STempTableNode {
@@ -241,24 +289,40 @@ typedef struct SSessionWindowNode {
 
 typedef struct SIntervalWindowNode {
   ENodeType type; // QUERY_NODE_INTERVAL_WINDOW
-  int64_t interval;
-  int64_t sliding;
-  int64_t offset;
+  SNode* pInterval; // SValueNode
+  SNode* pOffset;   // SValueNode
+  SNode* pSliding;  // SValueNode
+  SNode* pFill;
 } SIntervalWindowNode;
 
+typedef enum EFillMode {
+  FILL_MODE_NONE = 1,
+  FILL_MODE_VALUE,
+  FILL_MODE_PREV,
+  FILL_MODE_NULL,
+  FILL_MODE_LINEAR,
+  FILL_MODE_NEXT
+} EFillMode;
+
+typedef struct SFillNode {
+  ENodeType type; // QUERY_NODE_FILL
+  EFillMode mode;
+  SNode* pValues; // SNodeListNode
+} SFillNode;
+
 typedef struct SSelectStmt {
   ENodeType type; // QUERY_NODE_SELECT_STMT
   bool isDistinct;
-  bool isStar;
   SNodeList* pProjectionList; // SNode
   SNode* pFromTable;
-  SNode* pWhereCond;
+  SNode* pWhere;
   SNodeList* pPartitionByList; // SNode
-  SNode* pWindowClause;
+  SNode* pWindow;
   SNodeList* pGroupByList; // SGroupingSetNode
+  SNode* pHaving;
   SNodeList* pOrderByList; // SOrderByExprNode
-  SLimitNode limit;
-  SLimitNode slimit;
+  SNode* pLimit;
+  SNode* pSlimit;
 } SSelectStmt;
 
 typedef enum ESetOperatorType {
@@ -270,12 +334,24 @@ typedef struct SSetOperator {
   ESetOperatorType opType;
   SNode* pLeft;
   SNode* pRight;
+  SNodeList* pOrderByList; // SOrderByExprNode
+  SNode* pLimit;
 } SSetOperator;
 
+SNode* nodesMakeNode(ENodeType type);
+void nodesDestroyNode(SNode* pNode);
+
+SNodeList* nodesMakeList();
+SNodeList* nodesListAppend(SNodeList* pList, SNode* pNode);
+SNode* nodesListGetNode(SNodeList* pList, int32_t index);
+void nodesDestroyList(SNodeList* pList);
+
 typedef bool (*FQueryNodeWalker)(SNode* pNode, void* pContext);
 
-bool nodesWalkNode(SNode* pNode, FQueryNodeWalker walker, void* pContext);
-bool nodesWalkNodeList(SNodeList* pNodeList, FQueryNodeWalker walker, void* pContext);
+void nodesWalkNode(SNode* pNode, FQueryNodeWalker walker, void* pContext);
+void nodesWalkList(SNodeList* pList, FQueryNodeWalker walker, void* pContext);
+void nodesWalkNodePostOrder(SNode* pNode, FQueryNodeWalker walker, void* pContext);
+void nodesWalkListPostOrder(SNodeList* pList, FQueryNodeWalker walker, void* pContext);
 
 bool nodesWalkStmt(SNode* pNode, FQueryNodeWalker walker, void* pContext);
 
@@ -286,13 +362,13 @@ void nodesCloneNode(const SNode* pNode);
 int32_t nodesNodeToString(const SNode* pNode, char** pStr, int32_t* pLen);
 int32_t nodesStringToNode(const char* pStr, SNode** pNode);
 
+bool nodesIsArithmeticOp(const SOperatorNode* pOp);
+bool nodesIsComparisonOp(const SOperatorNode* pOp);
+bool nodesIsJsonOp(const SOperatorNode* pOp);
+
 bool nodesIsTimeorderQuery(const SNode* pQuery);
 bool nodesIsTimelineQuery(const SNode* pQuery);
 
-SNode* nodesMakeNode(ENodeType type);
-void nodesDestroyNode(SNode* pNode);
-void nodesDestroyNodeList(SNodeList* pList);
-
 #ifdef __cplusplus
 }
 #endif

include/os/osEndian.h

@@ -30,4 +30,4 @@ static const int32_t endian_test_var = 1;
 }
 #endif
 
-#endif /*_TD_OS_ENDIAN_H_*/
+#endif /*_TD_OS_ENDIAN_H_*/
\ No newline at end of file

include/os/osMath.h

@@ -36,25 +36,25 @@ extern "C" {
 
 #else
 
-  #define TSWAP(a, b, c)      \
-    do {                     \
-      typeof(a) __tmp = (a); \
-      (a) = (b);             \
-      (b) = __tmp;           \
+  #define TSWAP(a, b, c)       \
+    do {                       \
+      __typeof(a) __tmp = (a); \
+      (a) = (b);               \
+      (b) = __tmp;             \
     } while (0)
 
-  #define TMAX(a, b)            \
-    ({                         \
-      typeof(a) __a = (a);     \
-      typeof(b) __b = (b);     \
-      (__a > __b) ? __a : __b; \
+  #define TMAX(a, b)             \
+    ({                           \
+      __typeof(a) __a = (a);     \
+      __typeof(b) __b = (b);     \
+      (__a > __b) ? __a : __b;   \
     })
 
-  #define TMIN(a, b)            \
-    ({                         \
-      typeof(a) __a = (a);     \
-      typeof(b) __b = (b);     \
-      (__a < __b) ? __a : __b; \
+  #define TMIN(a, b)             \
+    ({                           \
+      __typeof(a) __a = (a);     \
+      __typeof(b) __b = (b);     \
+      (__a < __b) ? __a : __b;   \
     })
 #endif
 

include/util/taoserror.h

@@ -199,6 +199,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_INVALID_USER_FORMAT       TAOS_DEF_ERROR_CODE(0, 0x0373)
 #define TSDB_CODE_MND_INVALID_PASS_FORMAT       TAOS_DEF_ERROR_CODE(0, 0x0374)
 #define TSDB_CODE_MND_NO_USER_FROM_CONN         TAOS_DEF_ERROR_CODE(0, 0x0375)
+#define TSDB_CODE_MND_INVALID_ALTER_OPER        TAOS_DEF_ERROR_CODE(0, 0x0376)
 
 // mnode-db
 #define TSDB_CODE_MND_DB_ALREADY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0380)
@@ -218,18 +219,19 @@ int32_t* taosGetErrno();
 // mnode-stable
 #define TSDB_CODE_MND_STB_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x03A0)
 #define TSDB_CODE_MND_STB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x03A1)
-#define TSDB_CODE_MND_TOO_MANY_STBS             TAOS_DEF_ERROR_CODE(0, 0x03A2)
-#define TSDB_CODE_MND_INVALID_STB               TAOS_DEF_ERROR_CODE(0, 0x03A3)
-#define TSDB_CODE_MND_INVALID_STB_OPTION        TAOS_DEF_ERROR_CODE(0, 0x03A4)
-#define TSDB_CODE_MND_STB_OPTION_UNCHNAGED      TAOS_DEF_ERROR_CODE(0, 0x03A5)
-#define TSDB_CODE_MND_TOO_MANY_TAGS             TAOS_DEF_ERROR_CODE(0, 0x03A6)
-#define TSDB_CODE_MND_TAG_ALREAY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03A7)
-#define TSDB_CODE_MND_TAG_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x03A8)
-#define TSDB_CODE_MND_TOO_MANY_COLUMNS          TAOS_DEF_ERROR_CODE(0, 0x03A9)
-#define TSDB_CODE_MND_COLUMN_ALREAY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x03AA)
-#define TSDB_CODE_MND_COLUMN_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03AB)
-#define TSDB_CODE_MND_EXCEED_MAX_ROW_BYTES      TAOS_DEF_ERROR_CODE(0, 0x03AC)
-#define TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC  TAOS_DEF_ERROR_CODE(0, 0x03AD)
+#define TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC  TAOS_DEF_ERROR_CODE(0, 0x03A2)
+#define TSDB_CODE_MND_TOO_MANY_STBS             TAOS_DEF_ERROR_CODE(0, 0x03A3)
+#define TSDB_CODE_MND_INVALID_STB               TAOS_DEF_ERROR_CODE(0, 0x03A4)
+#define TSDB_CODE_MND_INVALID_STB_OPTION        TAOS_DEF_ERROR_CODE(0, 0x03A5)
+#define TSDB_CODE_MND_INVALID_STB_ALTER_OPTION  TAOS_DEF_ERROR_CODE(0, 0x03A6)
+#define TSDB_CODE_MND_STB_OPTION_UNCHNAGED      TAOS_DEF_ERROR_CODE(0, 0x03A7)
+#define TSDB_CODE_MND_INVALID_ROW_BYTES         TAOS_DEF_ERROR_CODE(0, 0x03A8)
+#define TSDB_CODE_MND_TOO_MANY_TAGS             TAOS_DEF_ERROR_CODE(0, 0x03A9)
+#define TSDB_CODE_MND_TAG_ALREADY_EXIST         TAOS_DEF_ERROR_CODE(0, 0x03AA)
+#define TSDB_CODE_MND_TAG_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x03AB)
+#define TSDB_CODE_MND_TOO_MANY_COLUMNS          TAOS_DEF_ERROR_CODE(0, 0x03AC)
+#define TSDB_CODE_MND_COLUMN_ALREADY_EXIST      TAOS_DEF_ERROR_CODE(0, 0x03AD)
+#define TSDB_CODE_MND_COLUMN_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03AE)
 
 // mnode-func
 #define TSDB_CODE_MND_FUNC_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x03C0)
@@ -254,6 +256,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_TOPIC_OPTION_UNCHNAGED    TAOS_DEF_ERROR_CODE(0, 0x03E5)
 #define TSDB_CODE_MND_NAME_CONFLICT_WITH_STB    TAOS_DEF_ERROR_CODE(0, 0x03E6)
 #define TSDB_CODE_MND_CONSUMER_NOT_EXIST        TAOS_DEF_ERROR_CODE(0, 0x03E7)
+#define TSDB_CODE_MND_UNSUPPORTED_TOPIC         TAOS_DEF_ERROR_CODE(0, 0x03E7)
 
 // dnode
 #define TSDB_CODE_DND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0400)
@@ -434,12 +437,23 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_CTG_NOT_READY                 TAOS_DEF_ERROR_CODE(0, 0x2402)  //catalog is not ready
 #define TSDB_CODE_CTG_MEM_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x2403)  //catalog memory error
 #define TSDB_CODE_CTG_SYS_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x2404)  //catalog system error
+#define TSDB_CODE_CTG_DB_DROPPED                TAOS_DEF_ERROR_CODE(0, 0x2405)  //Database is dropped
+#define TSDB_CODE_CTG_OUT_OF_SERVICE            TAOS_DEF_ERROR_CODE(0, 0x2406)  //catalog is out of service
 
 //scheduler
 #define TSDB_CODE_SCH_STATUS_ERROR              TAOS_DEF_ERROR_CODE(0, 0x2501)  //scheduler status error
 #define TSDB_CODE_SCH_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2502)  //scheduler internal error
 
-
+//parser
+#define TSDB_CODE_PAR_INVALID_COLUMN            TAOS_DEF_ERROR_CODE(0, 0x2601)  //Invalid column name
+#define TSDB_CODE_PAR_TABLE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x2602)  //Table does not exist
+#define TSDB_CODE_PAR_AMBIGUOUS_COLUMN          TAOS_DEF_ERROR_CODE(0, 0x2603)  //Column ambiguously defined
+#define TSDB_CODE_PAR_WRONG_VALUE_TYPE          TAOS_DEF_ERROR_CODE(0, 0x2604)  //Invalid value type
+#define TSDB_CODE_PAR_INVALID_FUNTION           TAOS_DEF_ERROR_CODE(0, 0x2605)  //Invalid function name
+#define TSDB_CODE_PAR_FUNTION_PARA_NUM          TAOS_DEF_ERROR_CODE(0, 0x2606)  //Invalid number of arguments
+#define TSDB_CODE_PAR_FUNTION_PARA_TYPE         TAOS_DEF_ERROR_CODE(0, 0x2607)  //Inconsistent datatypes
+#define TSDB_CODE_PAR_ILLEGAL_USE_AGG_FUNCTION  TAOS_DEF_ERROR_CODE(0, 0x2608)  //There mustn't be aggregation
+#define TSDB_CODE_PAR_WRONG_NUMBER_OF_SELECT    TAOS_DEF_ERROR_CODE(0, 0x2609)  //ORDER BY item must be the number of a SELECT-list expression
 
 #ifdef __cplusplus
 }

include/util/tdef.h

@@ -186,8 +186,8 @@ do { \
 #define TSDB_MAX_SQL_SHOW_LEN     1024
 #define TSDB_MAX_ALLOWED_SQL_LEN  (1*1024*1024u)          // sql length should be less than 1mb
 
-#define TSDB_APP_NAME_LEN          TSDB_UNI_LEN
-
+#define TSDB_APP_NAME_LEN         TSDB_UNI_LEN
+#define TSDB_STB_COMMENT_LEN      1024
   /**
    *  In some scenarios uint16_t (0~65535) is used to store the row len.
    *  - Firstly, we use 65531(65535 - 4), as the SDataRow/SKVRow contains 4 bits header.
@@ -321,6 +321,7 @@ do { \
 #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
 #define PRIMARYKEY_TIMESTAMP_COL_ID     1
+#define COL_REACH_END(colId, maxColId)  ((colId) > (maxColId))
 
 #define TSDB_MAX_RPC_THREADS            5
 

include/util/types.h

@@ -72,14 +72,13 @@ static FORCE_INLINE double taos_align_get_double(const char *pBuf) {
   #define SET_DOUBLE_PTR(x, y) { (*(double *)(x)) = (*(double *)(y)); }
 // #endif
 
-typedef int16_t  VarDataLenT;  // maxVarDataLen: 32767
+typedef uint16_t  VarDataLenT;  // maxVarDataLen: 32767
 #define VARSTR_HEADER_SIZE  sizeof(VarDataLenT)
 
 #define varDataLen(v) ((VarDataLenT *)(v))[0]
 #define varDataVal(v) ((void *)((char *)v + VARSTR_HEADER_SIZE))
 
 typedef int32_t VarDataOffsetT;
-typedef int16_t VarDataLenT;  // maxVarDataLen: 32767
 
 #ifdef __cplusplus
 }

source/client/inc/clientInt.h

@@ -30,14 +30,28 @@ extern "C" {
 #include "tmsgtype.h"
 #include "trpc.h"
 #include "query.h"
+#include "parser.h"
+
+#define CHECK_CODE_GOTO(expr, label) \
+  do {                               \
+    int32_t code = expr;             \
+    if (TSDB_CODE_SUCCESS != code) { \
+      terrno = code;                 \
+      goto label;                    \
+    }                                \
+  } while (0)
 
 #define HEARTBEAT_INTERVAL 1500  // ms
 
 typedef struct SAppInstInfo SAppInstInfo;
 
-typedef int32_t (*FHbRspHandle)(SClientHbRsp* pReq);
+typedef struct SHbConnInfo {
+  void         *param;
+  SClientHbReq *req;
+} SHbConnInfo;
 
 typedef struct SAppHbMgr {
+  char   *key;
   // statistics
   int32_t reportCnt;
   int32_t connKeyCnt;
@@ -49,9 +63,15 @@ typedef struct SAppHbMgr {
   SAppInstInfo* pAppInstInfo;
   // info
   SHashObj* activeInfo;    // hash<SClientHbKey, SClientHbReq>
-  SHashObj* getInfoFuncs;  // hash<SClientHbKey, FGetConnInfo>
+  SHashObj* connInfo;      // hash<SClientHbKey, SHbConnInfo>
 } SAppHbMgr;
 
+
+typedef int32_t (*FHbRspHandle)(struct SAppHbMgr *pAppHbMgr, SClientHbRsp* pRsp);
+
+typedef int32_t (*FHbReqHandle)(SClientHbKey *connKey, void* param, SClientHbReq *req);
+
+
 typedef struct SClientHbMgr {
   int8_t inited;
   // ctl
@@ -59,12 +79,10 @@ typedef struct SClientHbMgr {
   pthread_t       thread;
   pthread_mutex_t lock;       // used when app init and cleanup
   SArray*         appHbMgrs;  // SArray<SAppHbMgr*> one for each cluster
-  FHbRspHandle    handle[HEARTBEAT_TYPE_MAX];
+  FHbReqHandle    reqHandle[HEARTBEAT_TYPE_MAX];
+  FHbRspHandle    rspHandle[HEARTBEAT_TYPE_MAX];
 } SClientHbMgr;
 
-// TODO: embed param into function
-// return type: SArray<Skv>
-typedef SArray* (*FGetConnInfo)(SClientHbKey connKey, void* param);
 
 typedef struct SQueryExecMetric {
   int64_t      start;    // start timestamp
@@ -211,6 +229,11 @@ void *doFetchRow(SRequestObj* pRequest);
 
 void  setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows);
 
+
+int32_t buildRequest(STscObj *pTscObj, const char *sql, int sqlLen, SRequestObj** pRequest);
+
+int32_t parseSql(SRequestObj* pRequest, SQueryNode** pQuery);
+
 // --- heartbeat 
 // global, called by mgmt
 int  hbMgrInit();
@@ -218,11 +241,11 @@ void hbMgrCleanUp();
 int  hbHandleRsp(SClientHbBatchRsp* hbRsp);
 
 // cluster level
-SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo);
-void appHbMgrCleanup(SAppHbMgr* pAppHbMgr);
+SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo, char *key);
+void appHbMgrCleanup(void);
 
 // conn level
-int  hbRegisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, FGetConnInfo func);
+int  hbRegisterConn(SAppHbMgr* pAppHbMgr, int32_t connId, int64_t clusterId, int32_t hbType);
 void hbDeregisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey);
 
 int hbAddConnInfo(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, void* key, void* value, int32_t keyLen, int32_t valueLen);

source/client/src/clientEnv.c

@@ -127,6 +127,8 @@ void* openTransporter(const char *user, const char *auth, int32_t numOfThread) {
 void destroyTscObj(void *pObj) {
   STscObj *pTscObj = pObj;
 
+  SClientHbKey connKey = {.connId = pTscObj->connId, .hbType = pTscObj->connType};
+  hbDeregisterConn(pTscObj->pAppInfo->pAppHbMgr, connKey);
   atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
   tscDebug("connObj 0x%"PRIx64" destroyed, totalConn:%"PRId64, pTscObj->id, pTscObj->pAppInfo->numOfConns);
   pthread_mutex_destroy(&pTscObj->mutex);
@@ -517,4 +519,4 @@ setConfRet taos_set_config(const char *config){
   pthread_mutex_unlock(&setConfMutex);
   return ret;
 }
-#endif
+#endif
\ No newline at end of file

source/client/src/clientHb.c

@@ -15,33 +15,334 @@
 
 #include "clientInt.h"
 #include "trpc.h"
+#include "catalog.h"
+#include "clientLog.h"
 
 static SClientHbMgr clientHbMgr = {0};
 
 static int32_t hbCreateThread();
 static void    hbStopThread();
 
-static int32_t hbMqHbRspHandle(SClientHbRsp* pRsp) {
+static int32_t hbMqHbRspHandle(struct SAppHbMgr *pAppHbMgr, SClientHbRsp* pRsp) {
   return 0;
 }
 
+static int32_t hbProcessDBInfoRsp(void *value, int32_t valueLen, struct SCatalog *pCatalog) {
+  int32_t msgLen = 0;
+  int32_t code = 0;
+  
+  while (msgLen < valueLen) {
+    SUseDbRsp *rsp = (SUseDbRsp *)((char *)value + msgLen);
+
+    rsp->vgVersion = ntohl(rsp->vgVersion);
+    rsp->vgNum = ntohl(rsp->vgNum);
+    rsp->uid = be64toh(rsp->uid);
+
+    tscDebug("hb db rsp, db:%s, vgVersion:%d, uid:%"PRIx64, rsp->db, rsp->vgVersion, rsp->uid);
+    
+    if (rsp->vgVersion < 0) {
+      code = catalogRemoveDB(pCatalog, rsp->db, rsp->uid);
+    } else {
+      SDBVgroupInfo vgInfo = {0};
+      vgInfo.vgVersion = rsp->vgVersion;
+      vgInfo.hashMethod = rsp->hashMethod;
+      vgInfo.vgHash = taosHashInit(rsp->vgNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
+      if (NULL == vgInfo.vgHash) {
+        tscError("hash init[%d] failed", rsp->vgNum);
+        return TSDB_CODE_TSC_OUT_OF_MEMORY;
+      }
+
+      for (int32_t i = 0; i < rsp->vgNum; ++i) {
+        rsp->vgroupInfo[i].vgId = ntohl(rsp->vgroupInfo[i].vgId);
+        rsp->vgroupInfo[i].hashBegin = ntohl(rsp->vgroupInfo[i].hashBegin);
+        rsp->vgroupInfo[i].hashEnd = ntohl(rsp->vgroupInfo[i].hashEnd);
+
+        for (int32_t n = 0; n < rsp->vgroupInfo[i].epset.numOfEps; ++n) {
+          rsp->vgroupInfo[i].epset.eps[n].port = ntohs(rsp->vgroupInfo[i].epset.eps[n].port);
+        }
+
+        if (0 != taosHashPut(vgInfo.vgHash, &rsp->vgroupInfo[i].vgId, sizeof(rsp->vgroupInfo[i].vgId), &rsp->vgroupInfo[i], sizeof(rsp->vgroupInfo[i]))) {
+          tscError("hash push failed, errno:%d", errno);
+          taosHashCleanup(vgInfo.vgHash);
+          return TSDB_CODE_TSC_OUT_OF_MEMORY;
+        }
+      }  
+      
+      code = catalogUpdateDBVgroup(pCatalog, rsp->db, rsp->uid, &vgInfo);
+      if (code) {
+        taosHashCleanup(vgInfo.vgHash);
+      }
+    }
+
+    if (code) {
+      return code;
+    }
+
+    msgLen += sizeof(SUseDbRsp) + rsp->vgNum * sizeof(SVgroupInfo);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t hbProcessStbInfoRsp(void *value, int32_t valueLen, struct SCatalog *pCatalog) {
+  int32_t msgLen = 0;
+  int32_t code = 0;
+  int32_t schemaNum = 0;
+  
+  while (msgLen < valueLen) {
+    STableMetaRsp *rsp = (STableMetaRsp *)((char *)value + msgLen);
+
+    rsp->numOfColumns = ntohl(rsp->numOfColumns);
+    rsp->suid = be64toh(rsp->suid);
+    
+    if (rsp->numOfColumns < 0) {
+      schemaNum = 0;
+      
+      tscDebug("hb remove stb, db:%s, stb:%s", rsp->dbFName, rsp->stbName);
+
+      catalogRemoveSTableMeta(pCatalog, rsp->dbFName, rsp->stbName, rsp->suid);
+    } else {
+      tscDebug("hb update stb, db:%s, stb:%s", rsp->dbFName, rsp->stbName);
+
+      rsp->numOfTags = ntohl(rsp->numOfTags);
+      rsp->sversion = ntohl(rsp->sversion);
+      rsp->tversion = ntohl(rsp->tversion);
+      rsp->tuid = be64toh(rsp->tuid);
+      rsp->vgId = ntohl(rsp->vgId);
+
+      SSchema* pSchema = rsp->pSchema;
+      
+      schemaNum = rsp->numOfColumns + rsp->numOfTags;
+
+      for (int i = 0; i < schemaNum; ++i) {
+        pSchema->bytes = ntohl(pSchema->bytes);
+        pSchema->colId = ntohl(pSchema->colId);
+
+        pSchema++;
+      }
+
+      if (rsp->pSchema[0].colId != PRIMARYKEY_TIMESTAMP_COL_ID) {
+        tscError("invalid colId[%d] for the first column in table meta rsp msg", rsp->pSchema[0].colId);
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }      
+
+      catalogUpdateSTableMeta(pCatalog, rsp);
+    }
+
+    msgLen += sizeof(STableMetaRsp) + schemaNum * sizeof(SSchema);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+static int32_t hbQueryHbRspHandle(struct SAppHbMgr *pAppHbMgr, SClientHbRsp* pRsp) {
+  SHbConnInfo * info = taosHashGet(pAppHbMgr->connInfo, &pRsp->connKey, sizeof(SClientHbKey));
+  if (NULL == info) {
+    tscWarn("fail to get connInfo, may be dropped, connId:%d, type:%d", pRsp->connKey.connId, pRsp->connKey.hbType);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  int32_t kvNum = pRsp->info ? taosArrayGetSize(pRsp->info) : 0;
+
+  tscDebug("hb got %d rsp kv", kvNum);
+  
+  for (int32_t i = 0; i < kvNum; ++i) {
+    SKv *kv = taosArrayGet(pRsp->info, i);
+    switch (kv->key) {
+      case HEARTBEAT_KEY_DBINFO: {
+        if (kv->valueLen <= 0 || NULL == kv->value) {
+          tscError("invalid hb db info, len:%d, value:%p", kv->valueLen, kv->value);
+          break;
+        }
+
+        int64_t *clusterId = (int64_t *)info->param;
+        struct SCatalog *pCatalog = NULL;
+        
+        int32_t code = catalogGetHandle(*clusterId, &pCatalog);
+        if (code != TSDB_CODE_SUCCESS) {
+          tscWarn("catalogGetHandle failed, clusterId:%"PRIx64", error:%s", *clusterId, tstrerror(code));
+          break;
+        }
+
+        hbProcessDBInfoRsp(kv->value, kv->valueLen, pCatalog);
+        break;
+      }
+      case HEARTBEAT_KEY_STBINFO:{
+        if (kv->valueLen <= 0 || NULL == kv->value) {
+          tscError("invalid hb stb info, len:%d, value:%p", kv->valueLen, kv->value);
+          break;
+        }
+
+        int64_t *clusterId = (int64_t *)info->param;
+        struct SCatalog *pCatalog = NULL;
+        
+        int32_t code = catalogGetHandle(*clusterId, &pCatalog);
+        if (code != TSDB_CODE_SUCCESS) {
+          tscWarn("catalogGetHandle failed, clusterId:%"PRIx64", error:%s", *clusterId, tstrerror(code));
+          break;
+        }
+
+        hbProcessStbInfoRsp(kv->value, kv->valueLen, pCatalog);
+        break;
+      }
+      default:
+        tscError("invalid hb key type:%d", kv->key);
+        break;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t hbMqAsyncCallBack(void* param, const SDataBuf* pMsg, int32_t code) {
+  static int32_t emptyRspNum = 0;
   if (code != 0) {
+    tfree(param);
+    return -1;
+  }
+  char *key = (char *)param;
+  SClientHbBatchRsp pRsp = {0};
+  tDeserializeSClientHbBatchRsp(pMsg->pData, &pRsp);
+  
+  int32_t rspNum = taosArrayGetSize(pRsp.rsps);
+
+  SAppInstInfo** pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
+  if (pInst == NULL || NULL == *pInst) {
+    tscError("cluster not exist, key:%s", key);    
+    tfree(param);
+    tFreeClientHbBatchRsp(&pRsp);
     return -1;
   }
-  SClientHbRsp* pRsp = (SClientHbRsp*) pMsg->pData;
-  return hbMqHbRspHandle(pRsp);
+
+  tfree(param);
+
+  if (rspNum) {
+    tscDebug("hb got %d rsp, %d empty rsp received before", rspNum, atomic_val_compare_exchange_32(&emptyRspNum, emptyRspNum, 0));
+  } else {
+    atomic_add_fetch_32(&emptyRspNum, 1);
+  }
+
+  for (int32_t i = 0; i < rspNum; ++i) {
+    SClientHbRsp* rsp = taosArrayGet(pRsp.rsps, i);
+    code = (*clientHbMgr.rspHandle[rsp->connKey.hbType])((*pInst)->pAppHbMgr, rsp);
+    if (code) {
+      break;
+    }
+  }
+
+  tFreeClientHbBatchRsp(&pRsp);
+  
+  return code;
+}
+
+int32_t hbGetExpiredDBInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SClientHbReq *req) {
+  SDbVgVersion *dbs = NULL;
+  uint32_t dbNum = 0;
+  int32_t code = 0;
+
+  code = catalogGetExpiredDBs(pCatalog, &dbs, &dbNum);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
+
+  if (dbNum <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  for (int32_t i = 0; i < dbNum; ++i) {
+    SDbVgVersion *db = &dbs[i];
+    db->dbId = htobe64(db->dbId);
+    db->vgVersion = htonl(db->vgVersion);
+  }
+
+  SKv kv = {.key = HEARTBEAT_KEY_DBINFO, .valueLen = sizeof(SDbVgVersion) * dbNum, .value = dbs};
+
+  tscDebug("hb got %d expired db, valueLen:%d", dbNum, kv.valueLen);
+
+  taosHashPut(req->info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t hbGetExpiredStbInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SClientHbReq *req) {
+  SSTableMetaVersion *stbs = NULL;
+  uint32_t stbNum = 0;
+  int32_t code = 0;
+
+  code = catalogGetExpiredSTables(pCatalog, &stbs, &stbNum);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
+
+  if (stbNum <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  for (int32_t i = 0; i < stbNum; ++i) {
+    SSTableMetaVersion *stb = &stbs[i];
+    stb->suid = htobe64(stb->suid);
+    stb->sversion = htons(stb->sversion);
+    stb->tversion = htons(stb->tversion);    
+  }
+
+  SKv kv = {.key = HEARTBEAT_KEY_STBINFO, .valueLen = sizeof(SSTableMetaVersion) * stbNum, .value = stbs};
+
+  tscDebug("hb got %d expired stb, valueLen:%d", stbNum, kv.valueLen);
+
+  taosHashPut(req->info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t hbQueryHbReqHandle(SClientHbKey *connKey, void* param, SClientHbReq *req) {
+  int64_t *clusterId = (int64_t *)param;
+  struct SCatalog *pCatalog = NULL;
+
+  int32_t code = catalogGetHandle(*clusterId, &pCatalog);
+  if (code != TSDB_CODE_SUCCESS) {
+    tscWarn("catalogGetHandle failed, clusterId:%"PRIx64", error:%s", *clusterId, tstrerror(code));
+    return code;
+  }
+  
+  code = hbGetExpiredDBInfo(connKey, pCatalog, req);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
+
+  code = hbGetExpiredStbInfo(connKey, pCatalog, req);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
+
+
+  return TSDB_CODE_SUCCESS;
 }
 
-void hbMgrInitMqHbRspHandle() {
-  clientHbMgr.handle[HEARTBEAT_TYPE_MQ] = hbMqHbRspHandle;
+int32_t hbMqHbReqHandle(SClientHbKey *connKey, void* param, SClientHbReq *req) {
+
+}
+
+void hbMgrInitMqHbHandle() {
+  clientHbMgr.reqHandle[HEARTBEAT_TYPE_QUERY] = hbQueryHbReqHandle;
+  clientHbMgr.reqHandle[HEARTBEAT_TYPE_MQ] = hbMqHbReqHandle;
+  clientHbMgr.rspHandle[HEARTBEAT_TYPE_QUERY] = hbQueryHbRspHandle;
+  clientHbMgr.rspHandle[HEARTBEAT_TYPE_MQ] = hbMqHbRspHandle;
 }
 
 static FORCE_INLINE void hbMgrInitHandle() {
   // init all handle
-  hbMgrInitMqHbRspHandle();
+  hbMgrInitMqHbHandle();
+}
+
+void hbFreeReq(void *req) {
+  SClientHbReq *pReq = (SClientHbReq *)req;
+  tFreeReqKvHash(pReq->info);
 }
 
+
+
 SClientHbBatchReq* hbGatherAllInfo(SAppHbMgr *pAppHbMgr) {
   SClientHbBatchReq* pBatchReq = malloc(sizeof(SClientHbBatchReq));
   if (pBatchReq == NULL) {
@@ -51,38 +352,58 @@ SClientHbBatchReq* hbGatherAllInfo(SAppHbMgr *pAppHbMgr) {
   int32_t connKeyCnt = atomic_load_32(&pAppHbMgr->connKeyCnt);
   pBatchReq->reqs = taosArrayInit(connKeyCnt, sizeof(SClientHbReq));
 
+  int32_t code = 0;
   void *pIter = taosHashIterate(pAppHbMgr->activeInfo, NULL);
   while (pIter != NULL) {
     SClientHbReq* pOneReq = pIter;
+
+    SHbConnInfo * info = taosHashGet(pAppHbMgr->connInfo, &pOneReq->connKey, sizeof(SClientHbKey));
+    if (info) {
+      code = (*clientHbMgr.reqHandle[pOneReq->connKey.hbType])(&pOneReq->connKey, info->param, pOneReq);
+      if (code) {
+        taosHashCancelIterate(pAppHbMgr->activeInfo, pIter);
+        break;
+      }
+    }
+
     taosArrayPush(pBatchReq->reqs, pOneReq);
-    taosHashClear(pOneReq->info);
 
     pIter = taosHashIterate(pAppHbMgr->activeInfo, pIter);
   }
 
-#if 0
-  pIter = taosHashIterate(pAppHbMgr->getInfoFuncs, NULL);
-  while (pIter != NULL) {
-    FGetConnInfo getConnInfoFp = (FGetConnInfo)pIter;
-    SClientHbKey connKey;
-    taosHashCopyKey(pIter, &connKey);
-    SArray* pArray = getConnInfoFp(connKey, NULL);
-
-    pIter = taosHashIterate(pAppHbMgr->getInfoFuncs, pIter);
+  if (code) {
+    taosArrayDestroyEx(pBatchReq->reqs, hbFreeReq);
+    tfree(pBatchReq);
   }
-#endif
 
   return pBatchReq;
 }
 
+
+void hbClearReqInfo(SAppHbMgr *pAppHbMgr) {
+  void *pIter = taosHashIterate(pAppHbMgr->activeInfo, NULL);
+  while (pIter != NULL) {
+    SClientHbReq* pOneReq = pIter;
+
+    tFreeReqKvHash(pOneReq->info);
+    taosHashClear(pOneReq->info);
+
+    pIter = taosHashIterate(pAppHbMgr->activeInfo, pIter);
+  }
+}
+
+
+
 static void* hbThreadFunc(void* param) {
   setThreadName("hb");
   while (1) {
-    int8_t threadStop = atomic_load_8(&clientHbMgr.threadStop);
-    if(threadStop) {
+    int8_t threadStop = atomic_val_compare_exchange_8(&clientHbMgr.threadStop, 1, 2);
+    if(1 == threadStop) {
       break;
     }
 
+    pthread_mutex_lock(&clientHbMgr.lock);
+
     int sz = taosArrayGetSize(clientHbMgr.appHbMgrs);
     for(int i = 0; i < sz; i++) {
       SAppHbMgr* pAppHbMgr = taosArrayGetP(clientHbMgr.appHbMgrs, i);
@@ -98,7 +419,9 @@ static void* hbThreadFunc(void* param) {
       int tlen = tSerializeSClientHbBatchReq(NULL, pReq);
       void *buf = malloc(tlen);
       if (buf == NULL) {
-        //TODO: error handling
+        terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        tFreeClientHbBatchReq(pReq, false);
+        hbClearReqInfo(pAppHbMgr);
         break;
       }
       void *abuf = buf;
@@ -107,6 +430,7 @@ static void* hbThreadFunc(void* param) {
       if (pInfo == NULL) {
         terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
         tFreeClientHbBatchReq(pReq, false);
+        hbClearReqInfo(pAppHbMgr);
         free(buf);
         break;
       }
@@ -114,7 +438,7 @@ static void* hbThreadFunc(void* param) {
       pInfo->msgInfo.pData = buf;
       pInfo->msgInfo.len = tlen;
       pInfo->msgType = TDMT_MND_HEARTBEAT;
-      pInfo->param = NULL;
+      pInfo->param = strdup(pAppHbMgr->key);
       pInfo->requestId = generateRequestId();
       pInfo->requestObjRefId = 0;
 
@@ -122,10 +446,14 @@ static void* hbThreadFunc(void* param) {
       int64_t transporterId = 0;
       SEpSet epSet = getEpSet_s(&pAppInstInfo->mgmtEp);
       asyncSendMsgToServer(pAppInstInfo->pTransporter, &epSet, &transporterId, pInfo);
-      tFreeClientHbBatchReq(pReq, false);
+      tFreeClientHbBatchReq(pReq, false);      
+      hbClearReqInfo(pAppHbMgr);
 
       atomic_add_fetch_32(&pAppHbMgr->reportCnt, 1);
     }
+
+    pthread_mutex_unlock(&clientHbMgr.lock);
+    
     taosMsleep(HEARTBEAT_INTERVAL);
   }
   return NULL;
@@ -145,10 +473,19 @@ static int32_t hbCreateThread() {
 }
 
 static void hbStopThread() {
-  atomic_store_8(&clientHbMgr.threadStop, 1);
+  if (atomic_val_compare_exchange_8(&clientHbMgr.threadStop, 0, 1)) {
+    tscDebug("hb thread already stopped");
+    return;
+  }
+  
+  while (2 != atomic_load_8(&clientHbMgr.threadStop)) {
+    usleep(10);
+  }
+
+  tscDebug("hb thread stopped");  
 }
 
-SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo) {
+SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo, char *key) {
   hbMgrInit();
   SAppHbMgr* pAppHbMgr = malloc(sizeof(SAppHbMgr)); 
   if (pAppHbMgr == NULL) {
@@ -160,6 +497,7 @@ SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo) {
   pAppHbMgr->connKeyCnt = 0;
   pAppHbMgr->reportCnt = 0;
   pAppHbMgr->reportBytes = 0;
+  pAppHbMgr->key = strdup(key);
 
   // init app info
   pAppHbMgr->pAppInstInfo = pAppInstInfo;
@@ -174,28 +512,31 @@ SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo) {
   }
   pAppHbMgr->activeInfo->freeFp = tFreeClientHbReq;
   // init getInfoFunc
-  pAppHbMgr->getInfoFuncs = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);
+  pAppHbMgr->connInfo = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);
 
-  if (pAppHbMgr->getInfoFuncs == NULL) {
+  if (pAppHbMgr->connInfo == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     free(pAppHbMgr);
     return NULL;
   }
 
+  pthread_mutex_lock(&clientHbMgr.lock);
   taosArrayPush(clientHbMgr.appHbMgrs, &pAppHbMgr);
+  pthread_mutex_unlock(&clientHbMgr.lock);
+  
   return pAppHbMgr;
 }
 
-void appHbMgrCleanup(SAppHbMgr* pAppHbMgr) {
+void appHbMgrCleanup(void) {
   pthread_mutex_lock(&clientHbMgr.lock);
 
   int sz = taosArrayGetSize(clientHbMgr.appHbMgrs);
   for (int i = 0; i < sz; i++) {
     SAppHbMgr* pTarget = taosArrayGetP(clientHbMgr.appHbMgrs, i);
-    if (pAppHbMgr == pTarget) {
-      taosHashCleanup(pTarget->activeInfo);
-      taosHashCleanup(pTarget->getInfoFuncs);
-    }
+    taosHashCleanup(pTarget->activeInfo);
+    pTarget->activeInfo = NULL;
+    taosHashCleanup(pTarget->connInfo);
+    pTarget->connInfo = NULL;
   }
 
   pthread_mutex_unlock(&clientHbMgr.lock);
@@ -219,31 +560,22 @@ int hbMgrInit() {
 }
 
 void hbMgrCleanUp() {
+  return;
+  hbStopThread();
+  
   // destroy all appHbMgr
   int8_t old = atomic_val_compare_exchange_8(&clientHbMgr.inited, 1, 0);
   if (old == 0) return;
 
-  taosArrayDestroy(clientHbMgr.appHbMgrs);
-}
-
-int hbHandleRsp(SClientHbBatchRsp* hbRsp) {
-  int64_t reqId = hbRsp->reqId;
-  int64_t rspId = hbRsp->rspId;
-
-  SArray* rsps = hbRsp->rsps;
-  int32_t sz = taosArrayGetSize(rsps);
-  for (int i = 0; i < sz; i++) {
-    SClientHbRsp* pRsp = taosArrayGet(rsps, i);
-    if (pRsp->connKey.hbType < HEARTBEAT_TYPE_MAX) {
-      clientHbMgr.handle[pRsp->connKey.hbType](pRsp);
-    } else {
-      // discard rsp
-    }
-  }
-  return 0;
+  pthread_mutex_lock(&clientHbMgr.lock);
+  appHbMgrCleanup();
+  taosArrayDestroy(clientHbMgr.appHbMgrs);  
+  pthread_mutex_unlock(&clientHbMgr.lock);
+  
+  clientHbMgr.appHbMgrs = NULL;
 }
 
-int hbRegisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, FGetConnInfo func) {
+int hbRegisterConnImpl(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, SHbConnInfo *info) {
   // init hash in activeinfo
   void* data = taosHashGet(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
   if (data != NULL) {
@@ -252,19 +584,49 @@ int hbRegisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, FGetConnInfo func
   SClientHbReq hbReq;
   hbReq.connKey = connKey;
   hbReq.info = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);
+  
   taosHashPut(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey), &hbReq, sizeof(SClientHbReq));
+ 
   // init hash
-  if (func != NULL) {
-    taosHashPut(pAppHbMgr->getInfoFuncs, &connKey, sizeof(SClientHbKey), func, sizeof(FGetConnInfo));
+  if (info != NULL) {
+    SClientHbReq * pReq = taosHashGet(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
+    info->req = pReq;
+    taosHashPut(pAppHbMgr->connInfo, &connKey, sizeof(SClientHbKey), info, sizeof(SHbConnInfo));
   }
 
   atomic_add_fetch_32(&pAppHbMgr->connKeyCnt, 1);
   return 0;
 }
 
+int hbRegisterConn(SAppHbMgr* pAppHbMgr, int32_t connId, int64_t clusterId, int32_t hbType) {
+  SClientHbKey connKey = {.connId = connId, .hbType = HEARTBEAT_TYPE_QUERY};
+  SHbConnInfo info = {0};
+
+  switch (hbType) {
+    case HEARTBEAT_TYPE_QUERY: {
+      int64_t *pClusterId = malloc(sizeof(int64_t));
+      *pClusterId = clusterId;
+
+      info.param = pClusterId;
+      break;
+    }
+    case HEARTBEAT_TYPE_MQ: {
+      break;
+    }
+    default:
+      break;
+  }
+  
+  return hbRegisterConnImpl(pAppHbMgr, connKey, &info);
+}
+
 void hbDeregisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey) {
-  taosHashRemove(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
-  taosHashRemove(pAppHbMgr->getInfoFuncs, &connKey, sizeof(SClientHbKey));
+  int32_t code = 0;
+  code = taosHashRemove(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
+  code = taosHashRemove(pAppHbMgr->connInfo, &connKey, sizeof(SClientHbKey));
+  if (code) {
+    return;
+  }
   atomic_sub_fetch_32(&pAppHbMgr->connKeyCnt, 1);
 }
 

source/client/src/clientImpl.c

@@ -12,15 +12,6 @@
 #include "tpagedbuf.h"
 #include "tref.h"
 
-#define CHECK_CODE_GOTO(expr, label) \
-  do {                               \
-    int32_t code = expr;             \
-    if (TSDB_CODE_SUCCESS != code) { \
-      terrno = code;                 \
-      goto label;                    \
-    }                                \
-  } while (0)
-
 static int32_t initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet);
 static SMsgSendInfo* buildConnectMsg(SRequestObj *pRequest);
 static void destroySendMsgInfo(SMsgSendInfo* pMsgBody);
@@ -114,11 +105,12 @@ TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass,
   pthread_mutex_lock(&appInfo.mutex);
 
   pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
+  SAppInstInfo* p = NULL;
   if (pInst == NULL) {
-    SAppInstInfo* p = calloc(1, sizeof(struct SAppInstInfo));
+    p = calloc(1, sizeof(struct SAppInstInfo));
     p->mgmtEp       = epSet;
     p->pTransporter = openTransporter(user, secretEncrypt, tsNumOfCores);
-    p->pAppHbMgr = appHbMgrInit(p);
+    p->pAppHbMgr = appHbMgrInit(p, key);
     taosHashPut(appInfo.pInstMap, key, strlen(key), &p, POINTER_BYTES);
 
     pInst = &p;
@@ -258,501 +250,6 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, SArray* pNodeList)
   return schedulerAsyncExecJob(pTransporter, pNodeList, pDag, pRequest->sqlstr, &pRequest->body.pQueryJob);
 }
 
-
-typedef struct SMqClientVg {
-  // statistics
-  int64_t pollCnt;
-  // offset
-  int64_t committedOffset;
-  int64_t currentOffset;
-  //connection info
-  int32_t vgId;
-  SEpSet  epSet;
-} SMqClientVg;
-
-typedef struct SMqClientTopic {
-  // subscribe info
-  int32_t sqlLen;
-  char*   sql;
-  char*   topicName;
-  int64_t topicId;
-  int32_t nextVgIdx;
-  SArray* vgs;    //SArray<SMqClientVg>
-} SMqClientTopic;
-
-typedef struct tmq_resp_err_t {
-  int32_t code;
-} tmq_resp_err_t;
-
-typedef struct tmq_topic_vgroup_t {
-  char*   topic;
-  int32_t vgId;
-  int64_t commitOffset;
-} tmq_topic_vgroup_t;
-
-typedef struct tmq_topic_vgroup_list_t {
-  int32_t cnt;
-  int32_t size;
-  tmq_topic_vgroup_t* elems;
-} tmq_topic_vgroup_list_t;
-
-typedef void (tmq_commit_cb(tmq_t*, tmq_resp_err_t, tmq_topic_vgroup_list_t*, void* param));
-
-struct tmq_conf_t {
-  char           clientId[256];
-  char           groupId[256];
-  char*          ip;
-  uint16_t       port;
-  tmq_commit_cb* commit_cb;
-};
-
-tmq_conf_t* tmq_conf_new() {
-  tmq_conf_t* conf = calloc(1, sizeof(tmq_conf_t));
-  return conf;
-}
-
-int32_t tmq_conf_set(tmq_conf_t* conf, const char* key, const char* value) {
-  if (strcmp(key, "group.id") == 0) {
-    strcpy(conf->groupId, value);
-  }
-  if (strcmp(key, "client.id") == 0) {
-    strcpy(conf->clientId, value);
-  }
-  return 0;
-}
-
-struct tmq_t {
-  char           groupId[256];
-  char           clientId[256];
-  int64_t        consumerId;
-  int64_t        status;
-  tsem_t         rspSem;
-  STscObj*       pTscObj;
-  tmq_commit_cb* commit_cb;
-  int32_t        nextTopicIdx;
-  SArray*        clientTopics;  //SArray<SMqClientTopic>
-};
-
-tmq_t* taos_consumer_new(void* conn, tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
-  tmq_t* pTmq = calloc(sizeof(tmq_t), 1);
-  if (pTmq == NULL) {
-    return NULL;
-  }
-  pTmq->pTscObj = (STscObj*)conn;
-  pTmq->status = 0;
-  strcpy(pTmq->clientId, conf->clientId);
-  strcpy(pTmq->groupId, conf->groupId);
-  pTmq->commit_cb = conf->commit_cb;
-  tsem_init(&pTmq->rspSem, 0, 0);
-  pTmq->consumerId = generateRequestId() & ((uint64_t)-1 >> 1);
-  pTmq->clientTopics = taosArrayInit(0, sizeof(SMqClientTopic));
-  return pTmq;
-}
-
-struct tmq_list_t {
-  int32_t cnt;
-  int32_t tot;
-  char*   elems[];
-};
-tmq_list_t* tmq_list_new() {
-  tmq_list_t *ptr = malloc(sizeof(tmq_list_t) + 8 * sizeof(char*));
-  if (ptr == NULL) {
-    return ptr;
-  }
-  ptr->cnt = 0;
-  ptr->tot = 8;
-  return ptr;
-}
-
-int32_t tmq_list_append(tmq_list_t* ptr, char* src) {
-  if (ptr->cnt >= ptr->tot-1) return -1;
-  ptr->elems[ptr->cnt] = strdup(src);
-  ptr->cnt++;
-  return 0;
-}
-
-
-int32_t tmq_null_cb(void* param, const SDataBuf* pMsg, int32_t code)  {
-  if (code == 0) {
-    //
-  }
-  //
-  return 0;
-}
-
-TAOS_RES* tmq_subscribe(tmq_t* tmq, tmq_list_t* topic_list) {
-  SRequestObj *pRequest = NULL;
-  int32_t sz = topic_list->cnt;
-  //destroy ex
-  taosArrayDestroy(tmq->clientTopics);
-  tmq->clientTopics = taosArrayInit(sz, sizeof(SMqClientTopic));
-
-  SCMSubscribeReq req;
-  req.topicNum = sz;
-  req.consumerId = tmq->consumerId;
-  req.consumerGroup = strdup(tmq->groupId);
-  req.topicNames = taosArrayInit(sz, sizeof(void*));
-
-  for (int i = 0; i < sz; i++) {
-    char* topicName = topic_list->elems[i];
-
-    SName name = {0};
-    char* dbName = getDbOfConnection(tmq->pTscObj);
-    tNameSetDbName(&name, tmq->pTscObj->acctId, dbName, strlen(dbName));     
-    tNameFromString(&name, topicName, T_NAME_TABLE);
-
-    char* topicFname = calloc(1, TSDB_TOPIC_FNAME_LEN);
-    if (topicFname == NULL) {
-
-    }
-    tNameExtractFullName(&name, topicFname);
-    tscDebug("subscribe topic: %s", topicFname);
-    SMqClientTopic topic = {
-      .nextVgIdx = 0,
-      .sql = NULL,
-      .sqlLen = 0,
-      .topicId = 0,
-      .topicName = topicFname,
-      .vgs = NULL
-    };
-    topic.vgs = taosArrayInit(0, sizeof(SMqClientVg));
-    taosArrayPush(tmq->clientTopics, &topic); 
-    /*SMqClientTopic topic = {*/
-      /*.*/
-    /*};*/
-    taosArrayPush(req.topicNames, &topicFname);
-  }
-
-  int tlen = tSerializeSCMSubscribeReq(NULL, &req);
-  void* buf = malloc(tlen);
-  if(buf == NULL) {
-    goto _return;
-  }
-
-  void* abuf = buf;
-  tSerializeSCMSubscribeReq(&abuf, &req);
-  /*printf("formatted: %s\n", dagStr);*/
-
-  pRequest = createRequest(tmq->pTscObj, NULL, NULL, TDMT_MND_SUBSCRIBE);
-  if (pRequest == NULL) {
-    tscError("failed to malloc sqlObj");
-  }
-
-  pRequest->body.requestMsg = (SDataBuf){ .pData = buf, .len = tlen };
-
-  SMsgSendInfo* sendInfo = buildMsgInfoImpl(pRequest);
-  /*sendInfo->fp*/
-  SEpSet epSet = getEpSet_s(&tmq->pTscObj->pAppInfo->mgmtEp);
-
-  int64_t transporterId = 0;
-  asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, sendInfo);
-
-  tsem_wait(&pRequest->body.rspSem);
-
-_return:
-  /*if (sendInfo != NULL) {*/
-    /*destroySendMsgInfo(sendInfo);*/
-  /*}*/
-
-  if (pRequest != NULL && terrno != TSDB_CODE_SUCCESS) {
-    pRequest->code = terrno;
-  }
-
-  return pRequest;
-}
-
-void tmq_conf_set_offset_commit_cb(tmq_conf_t* conf, tmq_commit_cb* cb) {
-  conf->commit_cb = cb;
-}
-
-SArray* tmqGetConnInfo(SClientHbKey connKey, void* param) {
-  tmq_t* pTmq = (void*)param;
-  SArray* pArray = taosArrayInit(0, sizeof(SKv));
-  if (pArray == NULL) {
-    return NULL;
-  }
-  SKv kv = {0};
-  kv.key = malloc(256);
-  if (kv.key == NULL) {
-    taosArrayDestroy(pArray);
-    return NULL;
-  }
-  strcpy(kv.key, "mq-tmp");
-  kv.keyLen = strlen("mq-tmp") + 1;
-  SMqHbMsg* pMqHb = malloc(sizeof(SMqHbMsg));
-  if (pMqHb == NULL) {
-    return pArray;
-  }
-  pMqHb->consumerId = connKey.connId;
-  SArray* clientTopics = pTmq->clientTopics;
-  int sz = taosArrayGetSize(clientTopics);
-  for (int i = 0; i < sz; i++) {
-    SMqClientTopic* pCTopic = taosArrayGet(clientTopics, i);
-    /*if (pCTopic->vgId == -1) {*/
-      /*pMqHb->status = 1;*/
-      /*break;*/
-    /*}*/
-  }
-  kv.value = pMqHb;
-  kv.valueLen = sizeof(SMqHbMsg);
-  taosArrayPush(pArray, &kv);
-
-  return pArray;
-}
-
-tmq_t* tmqCreateConsumerImpl(TAOS* conn, tmq_conf_t* conf) {
-  tmq_t* pTmq = malloc(sizeof(tmq_t));
-  if (pTmq == NULL) {
-    return NULL;
-  }
-  strcpy(pTmq->groupId, conf->groupId);
-  strcpy(pTmq->clientId, conf->clientId);
-  pTmq->pTscObj = (STscObj*)conn;
-  pTmq->pTscObj->connType = HEARTBEAT_TYPE_MQ;
-
-  return pTmq;
-}
-
-TAOS_RES *taos_create_topic(TAOS* taos, const char* topicName, const char* sql, int sqlLen) {
-  STscObj     *pTscObj = (STscObj*)taos;
-  SRequestObj *pRequest = NULL;
-  SQueryNode  *pQueryNode = NULL;
-  char        *pStr = NULL;
-
-  terrno = TSDB_CODE_SUCCESS;
-  if (taos == NULL || topicName == NULL || sql == NULL) {
-    tscError("invalid parameters for creating topic, connObj:%p, topic name:%s, sql:%s", taos, topicName, sql);
-    terrno = TSDB_CODE_TSC_INVALID_INPUT;
-    goto _return;
-  }
-
-  if (strlen(topicName) >= TSDB_TOPIC_NAME_LEN) {
-    tscError("topic name too long, max length:%d", TSDB_TOPIC_NAME_LEN - 1);
-    terrno = TSDB_CODE_TSC_INVALID_INPUT;
-    goto _return;
-  }
-
-  if (sqlLen > TSDB_MAX_ALLOWED_SQL_LEN) {
-    tscError("sql string exceeds max length:%d", TSDB_MAX_ALLOWED_SQL_LEN);
-    terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
-    goto _return;
-  }
-
-  tscDebug("start to create topic, %s", topicName);
-
-  CHECK_CODE_GOTO(buildRequest(pTscObj, sql, sqlLen, &pRequest), _return);
-  CHECK_CODE_GOTO(parseSql(pRequest, &pQueryNode), _return);
-
-  SQueryStmtInfo* pQueryStmtInfo = (SQueryStmtInfo* ) pQueryNode;
-  pQueryStmtInfo->info.continueQuery = true;
-
-  // todo check for invalid sql statement and return with error code
-
-  SSchema *schema = NULL;
-  int32_t  numOfCols = 0;
-  CHECK_CODE_GOTO(qCreateQueryDag(pQueryNode, &pRequest->body.pDag, &schema, &numOfCols, NULL, pRequest->requestId), _return);
-
-  pStr = qDagToString(pRequest->body.pDag);
-  if(pStr == NULL) {
-    goto _return;
-  }
-
-  printf("%s\n", pStr);
-
-  // The topic should be related to a database that the queried table is belonged to.
-  SName name = {0};
-  char dbName[TSDB_DB_FNAME_LEN] = {0};
-  tNameGetFullDbName(&((SQueryStmtInfo*) pQueryNode)->pTableMetaInfo[0]->name, dbName);
-
-  tNameFromString(&name, dbName, T_NAME_ACCT|T_NAME_DB);
-  tNameFromString(&name, topicName, T_NAME_TABLE);
-
-  char topicFname[TSDB_TOPIC_FNAME_LEN] = {0};
-  tNameExtractFullName(&name, topicFname);
-
-  SCMCreateTopicReq req = {
-    .name         = (char*) topicFname,
-    .igExists     = 1,
-    .physicalPlan = (char*) pStr,
-    .sql          = (char*) sql,
-    .logicalPlan  = "no logic plan",
-  };
-
-  int tlen = tSerializeSCMCreateTopicReq(NULL, &req);
-  void* buf = malloc(tlen);
-  if(buf == NULL) {
-    goto _return;
-  }
-
-  void* abuf = buf;
-  tSerializeSCMCreateTopicReq(&abuf, &req);
-  /*printf("formatted: %s\n", dagStr);*/
-
-  pRequest->body.requestMsg = (SDataBuf){ .pData = buf, .len = tlen };
-  pRequest->type = TDMT_MND_CREATE_TOPIC;
-
-  SMsgSendInfo* sendInfo = buildMsgInfoImpl(pRequest);
-  SEpSet epSet = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
-
-  int64_t transporterId = 0;
-  asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, sendInfo);
-
-  tsem_wait(&pRequest->body.rspSem);
-
-_return:
-  qDestroyQuery(pQueryNode);
-  /*if (sendInfo != NULL) {*/
-    /*destroySendMsgInfo(sendInfo);*/
-  /*}*/
-
-  if (pRequest != NULL && terrno != TSDB_CODE_SUCCESS) {
-    pRequest->code = terrno;
-  }
-
-  return pRequest;
-}
-
-/*typedef SMqConsumeRsp tmq_message_t;*/
-
-struct tmq_message_t {
-  SMqConsumeRsp rsp;
-};
-
-int32_t tmq_poll_cb_inner(void* param, const SDataBuf* pMsg, int32_t code) {
-  return 0;
-}
-
-int32_t tmq_ask_ep_cb(void* param, const SDataBuf* pMsg, int32_t code) {
-  tmq_t* tmq = (tmq_t*)param;
-  if (code != 0) {
-    tsem_post(&tmq->rspSem);
-    return 0;
-  }
-  tscDebug("tmq ask ep cb called");
-  bool set = false;
-  SMqCMGetSubEpRsp rsp;
-  tDecodeSMqCMGetSubEpRsp(pMsg->pData, &rsp);
-  int32_t sz = taosArrayGetSize(rsp.topics);
-  // TODO: lock
-  tmq->clientTopics = taosArrayInit(sz, sizeof(SMqClientTopic));
-  for (int32_t i = 0; i < sz; i++) {
-    SMqClientTopic topic = {0};
-    SMqSubTopicEp* pTopicEp = taosArrayGet(rsp.topics, i);
-    topic.topicName = strdup(pTopicEp->topic);
-    int32_t vgSz = taosArrayGetSize(pTopicEp->vgs);
-    topic.vgs = taosArrayInit(vgSz, sizeof(SMqClientVg));
-    for (int32_t j = 0; j < vgSz; j++) {
-      SMqSubVgEp* pVgEp = taosArrayGet(pTopicEp->vgs, j);
-      SMqClientVg clientVg = {
-        .pollCnt = 0,
-        .committedOffset = -1,
-        .currentOffset = -1,
-        .vgId = pVgEp->vgId,
-        .epSet = pVgEp->epSet
-      };
-      taosArrayPush(topic.vgs, &clientVg);
-      set = true;
-    }
-    taosArrayPush(tmq->clientTopics, &topic);
-  }
-  if(set) tmq->status = 1;
-  // unlock
-  tsem_post(&tmq->rspSem);
-  return 0;
-}
-
-tmq_message_t* tmq_consume_poll(tmq_t* tmq, int64_t blocking_time) {
-
-  if (taosArrayGetSize(tmq->clientTopics) == 0 || tmq->status == 0) {
-    int32_t tlen = sizeof(SMqCMGetSubEpReq);
-    SMqCMGetSubEpReq* buf = malloc(tlen);
-    if (buf == NULL) {
-      tscError("failed to malloc get subscribe ep buf");
-    }
-    buf->consumerId = htobe64(tmq->consumerId);
-    strcpy(buf->cgroup, tmq->groupId);
-    
-    SRequestObj *pRequest = createRequest(tmq->pTscObj, NULL, NULL, TDMT_MND_GET_SUB_EP);
-    if (pRequest == NULL) {
-      tscError("failed to malloc subscribe ep request");
-    }
-
-    pRequest->body.requestMsg = (SDataBuf){ .pData = buf, .len = tlen };
-
-    SMsgSendInfo* sendInfo = buildMsgInfoImpl(pRequest);
-    sendInfo->requestObjRefId = 0;
-    sendInfo->param = tmq;
-    sendInfo->fp = tmq_ask_ep_cb;
-
-    SEpSet epSet = getEpSet_s(&tmq->pTscObj->pAppInfo->mgmtEp);
-
-    int64_t transporterId = 0;
-    asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, sendInfo);
-
-    tsem_wait(&tmq->rspSem);
-  }
-
-  if (taosArrayGetSize(tmq->clientTopics) == 0) {
-    tscDebug("consumer:%ld poll but not assigned", tmq->consumerId);
-    return NULL;
-  }
-
-  SMqConsumeReq* pReq = malloc(sizeof(SMqConsumeReq));
-  pReq->reqType = 1;
-  pReq->blockingTime = blocking_time;
-  pReq->consumerId = tmq->consumerId;
-  tmq_message_t* tmq_message = NULL;
-  strcpy(pReq->cgroup, tmq->groupId);
-
-  SMqClientTopic* pTopic = taosArrayGet(tmq->clientTopics, tmq->nextTopicIdx);
-  tmq->nextTopicIdx = (tmq->nextTopicIdx + 1) % taosArrayGetSize(tmq->clientTopics);
-  strcpy(pReq->topic, pTopic->topicName);
-  int32_t nextVgIdx = pTopic->nextVgIdx;
-  pTopic->nextVgIdx = (nextVgIdx + 1) % taosArrayGetSize(pTopic->vgs);
-  SMqClientVg* pVg = taosArrayGet(pTopic->vgs, nextVgIdx);
-  pReq->offset = pVg->currentOffset;
-
-  pReq->head.vgId = htonl(pVg->vgId);
-  pReq->head.contLen = htonl(sizeof(SMqConsumeReq));
-
-  SRequestObj* pRequest = createRequest(tmq->pTscObj, NULL, NULL, TDMT_VND_CONSUME);
-  pRequest->body.requestMsg = (SDataBuf){ .pData = pReq, .len = sizeof(SMqConsumeReq) };
-
-  SMsgSendInfo* sendInfo = buildMsgInfoImpl(pRequest);
-  /*sendInfo->requestObjRefId = 0;*/
-  /*sendInfo->param = &tmq_message;*/
-  /*sendInfo->fp = tmq_poll_cb_inner;*/
-
-  int64_t transporterId = 0;
-  asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &pVg->epSet, &transporterId, sendInfo);
-
-  tsem_wait(&pRequest->body.rspSem);
-
-  return tmq_message;
-
-  /*tsem_wait(&pRequest->body.rspSem);*/
-
-  /*if (body != NULL) {*/
-    /*destroySendMsgInfo(body);*/
-  /*}*/
-
-  /*if (pRequest != NULL && terrno != TSDB_CODE_SUCCESS) {*/
-    /*pRequest->code = terrno;*/
-  /*}*/
-
-  /*return pRequest;*/
-}
-
-tmq_resp_err_t* tmq_commit(tmq_t* tmq, tmq_topic_vgroup_list_t* tmq_topic_vgroup_list, int32_t async) {
-  SMqConsumeReq req = {0};
-  return NULL;
-}
-
-void tmq_message_destroy(tmq_message_t* tmq_message) {
-  if (tmq_message == NULL) return;
-}
-
-
 TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
   STscObj *pTscObj = (STscObj *)taos;
   if (sqlLen > (size_t) TSDB_MAX_ALLOWED_SQL_LEN) {
@@ -1043,8 +540,12 @@ void* doFetchRow(SRequestObj* pRequest) {
       tsem_wait(&pRequest->body.rspSem);
 
       pRequest->type = TDMT_VND_SHOW_TABLES_FETCH;
-    } else if (pRequest->type == TDMT_MND_SHOW_RETRIEVE && pResultInfo->pData != NULL) {
-      return NULL;
+    } else if (pRequest->type == TDMT_MND_SHOW_RETRIEVE) {      
+      epSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp);
+      
+      if (pResultInfo->completed) {
+        return NULL;
+      }
     }
 
     SMsgSendInfo* body = buildMsgInfoImpl(pRequest);

source/client/src/clientMain.c

@@ -46,6 +46,8 @@ void taos_cleanup(void) {
   clientConnRefPool = -1;
   taosCloseRef(id);
 
+  hbMgrCleanUp();
+
   rpcCleanup();
   catalogDestroy();
   taosCloseLog();
@@ -76,7 +78,7 @@ void taos_close(TAOS* taos) {
   STscObj *pTscObj = (STscObj *)taos;
   tscDebug("0x%"PRIx64" try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs);
 
-  taosRemoveRef(clientConnRefPool, pTscObj->id);
+  /*taosRemoveRef(clientConnRefPool, pTscObj->id);*/
 }
 
 int taos_errno(TAOS_RES *tres) {
@@ -341,4 +343,4 @@ void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param
 
 void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
   // TODO
-}
+}
\ No newline at end of file

source/client/src/clientMsgHandler.c

@@ -18,6 +18,7 @@
 #include "tname.h"
 #include "clientInt.h"
 #include "clientLog.h"
+#include "catalog.h"
 
 int (*handleRequestRspFp[TDMT_MAX])(void*, const SDataBuf* pMsg, int32_t code);
 
@@ -73,8 +74,9 @@ int processConnectRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   pTscObj->pAppInfo->clusterId = pConnect->clusterId;
   atomic_add_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
 
-  SClientHbKey connKey = {.connId = pConnect->connId, .hbType = HEARTBEAT_TYPE_QUERY};
-  hbRegisterConn(pTscObj->pAppInfo->pAppHbMgr, connKey, NULL);
+  pTscObj->connType = HEARTBEAT_TYPE_QUERY;
+
+  hbRegisterConn(pTscObj->pAppInfo->pAppHbMgr, pConnect->connId, pConnect->clusterId, HEARTBEAT_TYPE_QUERY);
 
   //  pRequest->body.resInfo.pRspMsg = pMsg->pData;
   tscDebug("0x%" PRIx64 " clusterId:%" PRId64 ", totalConn:%" PRId64, pRequest->requestId, pConnect->clusterId,
@@ -199,6 +201,7 @@ int32_t processRetrieveMnodeRsp(void* param, const SDataBuf* pMsg, int32_t code)
   pResInfo->pRspMsg   = pMsg->pData;
   pResInfo->numOfRows = pRetrieve->numOfRows;
   pResInfo->pData     = pRetrieve->data;
+  pResInfo->completed = pRetrieve->completed;
 
   pResInfo->current = 0;
   setResultDataPtr(pResInfo, pResInfo->fields, pResInfo->numOfCols, pResInfo->numOfRows);
@@ -290,7 +293,6 @@ int32_t processCreateTableRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 }
 
 int32_t processDropDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
-  // todo: Remove cache in catalog cache.
   SRequestObj* pRequest = param;
   if (code != TSDB_CODE_SUCCESS) {
     setErrno(pRequest, code);
@@ -298,6 +300,15 @@ int32_t processDropDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
     return code;
   }
 
+  SDropDbRsp *rsp = (SDropDbRsp *)pMsg->pData;
+
+  struct SCatalog *pCatalog = NULL;
+  rsp->uid = be64toh(rsp->uid);
+
+  catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &pCatalog);
+  
+  catalogRemoveDB(pCatalog, rsp->db, rsp->uid);
+
   tsem_post(&pRequest->body.rspSem);
   return code;
 }

source/client/test/CMakeLists.txt

@@ -5,10 +5,16 @@ MESSAGE(STATUS "build parser unit test")
 SET(CMAKE_CXX_STANDARD 11)
 AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 
-ADD_EXECUTABLE(clientTest ${SOURCE_LIST})
+ADD_EXECUTABLE(clientTest clientTests.cpp)
 TARGET_LINK_LIBRARIES(
         clientTest
-        PUBLIC os util common transport gtest taos qcom
+        PUBLIC os util common transport parser catalog scheduler function gtest taos qcom
+)
+
+ADD_EXECUTABLE(tmqTest tmqTest.cpp)
+TARGET_LINK_LIBRARIES(
+        tmqTest
+        PUBLIC os util common transport parser catalog scheduler function gtest taos qcom
 )
 
 TARGET_INCLUDE_DIRECTORIES(
@@ -16,3 +22,9 @@ TARGET_INCLUDE_DIRECTORIES(
         PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/client/"
         PRIVATE "${CMAKE_SOURCE_DIR}/source/libs/client/inc"
 )
+
+TARGET_INCLUDE_DIRECTORIES(
+        tmqTest
+        PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/client/"
+        PRIVATE "${CMAKE_SOURCE_DIR}/source/libs/client/inc"
+)

source/client/test/clientTests.cpp

@@ -562,31 +562,29 @@ TEST(testCase, driverInit_Test) {
 //  taos_close(pConn);
 //}
 //
-//#if 0
-TEST(testCase, create_topic_Test) {
-  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "use abc1");
-  if (taos_errno(pRes) != 0) {
-    printf("error in use db, reason:%s\n", taos_errstr(pRes));
-  }
-  //taos_free_result(pRes);
-
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  ASSERT_TRUE(pFields == nullptr);
-
-  int32_t numOfFields = taos_num_fields(pRes);
-  ASSERT_EQ(numOfFields, 0);
-
-  taos_free_result(pRes);
-
-  char* sql = "select * from st1";
-  pRes = taos_create_topic(pConn, "test_topic_1", sql, strlen(sql));
-  taos_free_result(pRes);
-  taos_close(pConn);
-}
-
+//TEST(testCase, create_topic_Test) {
+//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+//  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  //taos_free_result(pRes);
+//
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  ASSERT_TRUE(pFields == nullptr);
+//
+//  int32_t numOfFields = taos_num_fields(pRes);
+//  ASSERT_EQ(numOfFields, 0);
+//
+//  taos_free_result(pRes);
+//
+//  char* sql = "select * from st1";
+//  pRes = taos_create_topic(pConn, "test_topic_1", sql, strlen(sql));
+//  taos_free_result(pRes);
+//  taos_close(pConn);
+//}
 
 //TEST(testCase, tmq_subscribe_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
@@ -624,7 +622,13 @@ TEST(testCase, projection_query_tables) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   ASSERT_NE(pConn, nullptr);
 
-  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 2");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
   pRes = taos_query(pConn, "create stable st1 (ts timestamp, k int) tags(a int)");
@@ -680,7 +684,7 @@ TEST(testCase, projection_query_stables) {
   TAOS_RES* pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "select ts from st1");
+  pRes = taos_query(pConn, "select ts,k from st1");
   if (taos_errno(pRes) != 0) {
     printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);
@@ -693,8 +697,8 @@ TEST(testCase, projection_query_stables) {
 
   char str[512] = {0};
   while ((pRow = taos_fetch_row(pRes)) != NULL) {
-    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
-    printf("%s\n", str);
+//    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+//    printf("%s\n", str);
   }
 
   taos_free_result(pRes);

source/common/src/tdataformat.c

@@ -20,14 +20,23 @@
 #include "tarray.h"
 
 static void dataColSetNEleNull(SDataCol *pCol, int nEle);
+#if 0
 static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, int limit1, SDataCols *src2, int *iter2,
                                int limit2, int tRows, bool forceSetNull);
-
+#endif
 int tdAllocMemForCol(SDataCol *pCol, int maxPoints) {
   int spaceNeeded = pCol->bytes * maxPoints;
   if(IS_VAR_DATA_TYPE(pCol->type)) {
     spaceNeeded += sizeof(VarDataOffsetT) * maxPoints;
   }
+#ifdef TD_SUPPORT_BITMAP
+  int32_t nBitmapBytes = (int32_t)TD_BITMAP_BYTES(maxPoints);
+  spaceNeeded += (int)nBitmapBytes;
+  // TODO: Currently, the compression of bitmap parts is affiliated to the column data parts, thus allocate 1 more
+  // TYPE_BYTES as to comprise complete TYPE_BYTES. Otherwise, invalid read/write would be triggered.
+  spaceNeeded += TYPE_BYTES[pCol->type];
+#endif
+
   if(pCol->spaceSize < spaceNeeded) {
     void* ptr = realloc(pCol->pData, spaceNeeded);
     if(ptr == NULL) {
@@ -39,9 +48,18 @@ int tdAllocMemForCol(SDataCol *pCol, int maxPoints) {
       pCol->spaceSize = spaceNeeded;
     }
   }
-  if(IS_VAR_DATA_TYPE(pCol->type)) {
+#ifdef TD_SUPPORT_BITMAP
+  if (IS_VAR_DATA_TYPE(pCol->type)) {
+    pCol->pBitmap = POINTER_SHIFT(pCol->pData, pCol->bytes * maxPoints);
+    pCol->dataOff = POINTER_SHIFT(pCol->pBitmap, nBitmapBytes);
+  } else {
+    pCol->pBitmap = POINTER_SHIFT(pCol->pData, pCol->bytes * maxPoints);
+  }
+#else
+  if (IS_VAR_DATA_TYPE(pCol->type)) {
     pCol->dataOff = POINTER_SHIFT(pCol->pData, pCol->bytes * maxPoints);
   }
+#endif
   return 0;
 }
 
@@ -185,11 +203,16 @@ STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder) {
   schemaFLen(pSchema) = pBuilder->flen;
   schemaVLen(pSchema) = pBuilder->vlen;
 
+#ifdef TD_SUPPORT_BITMAP
+  schemaTLen(pSchema) += (int)TD_BITMAP_BYTES(schemaNCols(pSchema));
+#endif
+
   memcpy(schemaColAt(pSchema, 0), pBuilder->columns, sizeof(STColumn) * pBuilder->nCols);
 
   return pSchema;
 }
 
+#if 0
 /**
  * Initialize a data row
  */
@@ -230,12 +253,13 @@ SMemRow tdMemRowDup(SMemRow row) {
   memRowCpy(trow, row);
   return trow;
 }
+#endif
 
 void dataColInit(SDataCol *pDataCol, STColumn *pCol, int maxPoints) {
   pDataCol->type = colType(pCol);
   pDataCol->colId = colColId(pCol);
   pDataCol->bytes = colBytes(pCol);
-  pDataCol->offset = colOffset(pCol) + TD_DATA_ROW_HEAD_SIZE;
+  pDataCol->offset = colOffset(pCol) + 0; //TD_DATA_ROW_HEAD_SIZE;
 
   pDataCol->len = 0;
 }
@@ -311,7 +335,7 @@ static void dataColSetNEleNull(SDataCol *pCol, int nEle) {
   }
 }
 
-void dataColSetOffset(SDataCol *pCol, int nEle) {
+void *dataColSetOffset(SDataCol *pCol, int nEle) {
   ASSERT(((pCol->type == TSDB_DATA_TYPE_BINARY) || (pCol->type == TSDB_DATA_TYPE_NCHAR)));
 
   void *tptr = pCol->pData;
@@ -323,6 +347,7 @@ void dataColSetOffset(SDataCol *pCol, int nEle) {
     offset += varDataTLen(tptr);
     tptr = POINTER_SHIFT(tptr, varDataTLen(tptr));
   }
+  return POINTER_SHIFT(tptr, varDataTLen(tptr));
 }
 
 SDataCols *tdNewDataCols(int maxCols, int maxRows) {
@@ -440,7 +465,7 @@ void tdResetDataCols(SDataCols *pCols) {
     }
   }
 }
-
+#if 0
 static void tdAppendDataRowToDataCol(SDataRow row, STSchema *pSchema, SDataCols *pCols, bool forceSetNull) {
   ASSERT(pCols->numOfRows == 0 || dataColsKeyLast(pCols) < dataRowKey(row));
 
@@ -475,7 +500,7 @@ static void tdAppendDataRowToDataCol(SDataRow row, STSchema *pSchema, SDataCols
   pCols->numOfRows++;
 }
 
-static void tdAppendKvRowToDataCol(SKVRow row, STSchema *pSchema, SDataCols *pCols, bool forceSetNull) {
+static void tdAppendKVRowToDataCol(SKVRow row, STSchema *pSchema, SDataCols *pCols, bool forceSetNull) {
   ASSERT(pCols->numOfRows == 0 || dataColsKeyLast(pCols) < kvRowKey(row));
 
   int rcol = 0;
@@ -516,7 +541,7 @@ void tdAppendMemRowToDataCol(SMemRow row, STSchema *pSchema, SDataCols *pCols, b
   if (isDataRow(row)) {
     tdAppendDataRowToDataCol(memRowDataBody(row), pSchema, pCols, forceSetNull);
   } else if (isKvRow(row)) {
-    tdAppendKvRowToDataCol(memRowKvBody(row), pSchema, pCols, forceSetNull);
+    tdAppendKVRowToDataCol(memRowKvBody(row), pSchema, pCols, forceSetNull);
   } else {
     ASSERT(0);
   }
@@ -613,6 +638,7 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
     ASSERT(target->numOfRows <= target->maxPoints);
   }
 }
+#endif
 
 SKVRow tdKVRowDup(SKVRow row) {
   SKVRow trow = malloc(kvRowLen(row));
@@ -772,7 +798,7 @@ SKVRow tdGetKVRowFromBuilder(SKVRowBuilder *pBuilder) {
 
   return row;
 }
-
+#if 0
 SMemRow mergeTwoMemRows(void *buffer, SMemRow row1, SMemRow row2, STSchema *pSchema1, STSchema *pSchema2) {
 #if 0
   ASSERT(memRowKey(row1) == memRowKey(row2));
@@ -792,7 +818,7 @@ SMemRow mergeTwoMemRows(void *buffer, SMemRow row1, SMemRow row2, STSchema *pSch
   dataRowSetVersion(dataRow, schemaVersion(pSchema1));  // use latest schema version
   dataRowSetLen(dataRow, (TDRowLenT)(TD_DATA_ROW_HEAD_SIZE + pSchema1->flen));
 
-  TDRowTLenT dataLen = 0, kvLen = TD_MEM_ROW_KV_HEAD_SIZE;
+  TDRowLenT dataLen = 0, kvLen = TD_MEM_ROW_KV_HEAD_SIZE;
 
   int32_t  i = 0;  // row1
   int32_t  j = 0;  // row2
@@ -866,3 +892,4 @@ SMemRow mergeTwoMemRows(void *buffer, SMemRow row1, SMemRow row2, STSchema *pSch
   taosArrayDestroy(stashRow);
   return buffer;
 }
+#endif
\ No newline at end of file

source/common/src/ttypes.c

@@ -630,14 +630,6 @@ void operateVal(void *dst, void *s1, void *s2, int32_t optr, int32_t type) {
   }
 }
 
-#define TSWAP(a, b, c)        \
-    do {                     \
-      typeof(a) __tmp = (a); \
-      (a) = (b);             \
-      (b) = __tmp;           \
-    } while (0)
-
-
 void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf) {
   switch (type) {
     case TSDB_DATA_TYPE_INT:

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

@@ -55,7 +55,7 @@ typedef struct {
   SEpSet       mnodeEpSet;
   char        *file;
   SHashObj    *dnodeHash;
-  SDnodeEps   *dnodeEps;
+  SArray      *pDnodeEps;
   pthread_t   *threadId;
   SRWLatch     latch;
   SDnodeWorker mgmtWorker;

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

@@ -23,7 +23,7 @@ extern "C" {
 
 int32_t dndInitVnodes(SDnode *pDnode);
 void    dndCleanupVnodes(SDnode *pDnode);
-void    dndGetVnodeLoads(SDnode *pDnode, SVnodeLoads *pVloads);
+void    dndGetVnodeLoads(SDnode *pDnode, SArray *pLoads);
 void    dndProcessVnodeWriteMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
 void    dndProcessVnodeSyncMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);
 void    dndProcessVnodeQueryMsg(SDnode *pDnode, SRpcMsg *pMsg, SEpSet *pEpSet);

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

@@ -113,35 +113,31 @@ static void dndUpdateMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
 static void dndPrintDnodes(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
 
-  dDebug("print dnode ep list, num:%d", pMgmt->dnodeEps->num);
-  for (int32_t i = 0; i < pMgmt->dnodeEps->num; i++) {
-    SDnodeEp *pEp = &pMgmt->dnodeEps->eps[i];
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pMgmt->pDnodeEps);
+  dDebug("print dnode ep list, num:%d", numOfEps);
+  for (int32_t i = 0; i < numOfEps; i++) {
+    SDnodeEp *pEp = taosArrayGet(pMgmt->pDnodeEps, i);
     dDebug("dnode:%d, fqdn:%s port:%u isMnode:%d", pEp->id, pEp->ep.fqdn, pEp->ep.port, pEp->isMnode);
   }
 }
 
-static void dndResetDnodes(SDnode *pDnode, SDnodeEps *pDnodeEps) {
+static void dndResetDnodes(SDnode *pDnode, SArray *pDnodeEps) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
 
-  int32_t size = sizeof(SDnodeEps) + pDnodeEps->num * sizeof(SDnodeEp);
-  if (pDnodeEps->num > pMgmt->dnodeEps->num) {
-    SDnodeEps *tmp = calloc(1, size);
-    if (tmp == NULL) return;
-
-    tfree(pMgmt->dnodeEps);
-    pMgmt->dnodeEps = tmp;
-  }
-
-  if (pMgmt->dnodeEps != pDnodeEps) {
-    memcpy(pMgmt->dnodeEps, pDnodeEps, size);
+  if (pMgmt->pDnodeEps != pDnodeEps) {
+    SArray *tmp = pMgmt->pDnodeEps;
+    pMgmt->pDnodeEps = taosArrayDup(pDnodeEps);
+    taosArrayDestroy(tmp);
   }
 
   pMgmt->mnodeEpSet.inUse = 0;
   pMgmt->mnodeEpSet.numOfEps = 0;
 
   int32_t mIndex = 0;
-  for (int32_t i = 0; i < pMgmt->dnodeEps->num; i++) {
-    SDnodeEp *pDnodeEp = &pMgmt->dnodeEps->eps[i];
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pDnodeEps);
+
+  for (int32_t i = 0; i < numOfEps; i++) {
+    SDnodeEp *pDnodeEp = taosArrayGet(pDnodeEps, i);
     if (!pDnodeEp->isMnode) continue;
     if (mIndex >= TSDB_MAX_REPLICA) continue;
     pMgmt->mnodeEpSet.numOfEps++;
@@ -150,8 +146,8 @@ static void dndResetDnodes(SDnode *pDnode, SDnodeEps *pDnodeEps) {
     mIndex++;
   }
 
-  for (int32_t i = 0; i < pMgmt->dnodeEps->num; ++i) {
-    SDnodeEp *pDnodeEp = &pMgmt->dnodeEps->eps[i];
+  for (int32_t i = 0; i < numOfEps; i++) {
+    SDnodeEp *pDnodeEp = taosArrayGet(pDnodeEps, i);
     taosHashPut(pMgmt->dnodeHash, &pDnodeEp->id, sizeof(int32_t), pDnodeEp, sizeof(SDnodeEp));
   }
 
@@ -178,6 +174,12 @@ static bool dndIsEpChanged(SDnode *pDnode, int32_t dnodeId, char *pEp) {
 static int32_t dndReadDnodes(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
 
+  pMgmt->pDnodeEps = taosArrayInit(1, sizeof(SDnodeEp));
+  if (pMgmt->pDnodeEps == NULL) {
+    dError("failed to calloc dnodeEp array since %s", strerror(errno));
+    goto PRASE_DNODE_OVER;
+  }
+
   int32_t code = TSDB_CODE_DND_DNODE_READ_FILE_ERROR;
   int32_t len = 0;
   int32_t maxLen = 256 * 1024;
@@ -238,18 +240,11 @@ static int32_t dndReadDnodes(SDnode *pDnode) {
     goto PRASE_DNODE_OVER;
   }
 
-  pMgmt->dnodeEps = calloc(1, numOfDnodes * sizeof(SDnodeEp) + sizeof(SDnodeEps));
-  if (pMgmt->dnodeEps == NULL) {
-    dError("failed to calloc dnodeEpList since %s", strerror(errno));
-    goto PRASE_DNODE_OVER;
-  }
-  pMgmt->dnodeEps->num = numOfDnodes;
-
   for (int32_t i = 0; i < numOfDnodes; ++i) {
     cJSON *node = cJSON_GetArrayItem(dnodes, i);
     if (node == NULL) break;
 
-    SDnodeEp *pDnodeEp = &pMgmt->dnodeEps->eps[i];
+    SDnodeEp dnodeEp = {0};
 
     cJSON *did = cJSON_GetObjectItem(node, "id");
     if (!did || did->type != cJSON_Number) {
@@ -257,14 +252,14 @@ static int32_t dndReadDnodes(SDnode *pDnode) {
       goto PRASE_DNODE_OVER;
     }
 
-    pDnodeEp->id = dnodeId->valueint;
+    dnodeEp.id = dnodeId->valueint;
 
     cJSON *dnodeFqdn = cJSON_GetObjectItem(node, "fqdn");
     if (!dnodeFqdn || dnodeFqdn->type != cJSON_String || dnodeFqdn->valuestring == NULL) {
       dError("failed to read %s since dnodeFqdn not found", pMgmt->file);
       goto PRASE_DNODE_OVER;
     }
-    tstrncpy(pDnodeEp->ep.fqdn, dnodeFqdn->valuestring, TSDB_FQDN_LEN);
+    tstrncpy(dnodeEp.ep.fqdn, dnodeFqdn->valuestring, TSDB_FQDN_LEN);
 
     cJSON *dnodePort = cJSON_GetObjectItem(node, "port");
     if (!dnodePort || dnodePort->type != cJSON_Number) {
@@ -272,14 +267,16 @@ static int32_t dndReadDnodes(SDnode *pDnode) {
       goto PRASE_DNODE_OVER;
     }
 
-    pDnodeEp->ep.port = dnodePort->valueint;
+    dnodeEp.ep.port = dnodePort->valueint;
 
     cJSON *isMnode = cJSON_GetObjectItem(node, "isMnode");
     if (!isMnode || isMnode->type != cJSON_Number) {
       dError("failed to read %s since isMnode not found", pMgmt->file);
       goto PRASE_DNODE_OVER;
     }
-    pDnodeEp->isMnode = isMnode->valueint;
+    dnodeEp.isMnode = isMnode->valueint;
+
+    taosArrayPush(pMgmt->pDnodeEps, &dnodeEp);
   }
 
   code = 0;
@@ -296,15 +293,14 @@ PRASE_DNODE_OVER:
     return -1;
   }
 
-  if (pMgmt->dnodeEps == NULL) {
-    pMgmt->dnodeEps = calloc(1, sizeof(SDnodeEps) + sizeof(SDnodeEp));
-    pMgmt->dnodeEps->num = 1;
-    pMgmt->dnodeEps->eps[0].isMnode = 1;
-
-    taosGetFqdnPortFromEp(pDnode->cfg.firstEp, &(pMgmt->dnodeEps->eps[0].ep));
+  if (taosArrayGetSize(pMgmt->pDnodeEps) == 0) {
+    SDnodeEp dnodeEp = {0};
+    dnodeEp.isMnode = 1;
+    taosGetFqdnPortFromEp(pDnode->cfg.firstEp, &dnodeEp.ep);
+    taosArrayPush(pMgmt->pDnodeEps, &dnodeEp);
   }
 
-  dndResetDnodes(pDnode, pMgmt->dnodeEps);
+  dndResetDnodes(pDnode, pMgmt->pDnodeEps);
 
   terrno = 0;
   return 0;
@@ -329,13 +325,15 @@ static int32_t dndWriteDnodes(SDnode *pDnode) {
   len += snprintf(content + len, maxLen - len, "  \"clusterId\": \"%" PRId64 "\",\n", pMgmt->clusterId);
   len += snprintf(content + len, maxLen - len, "  \"dropped\": %d,\n", pMgmt->dropped);
   len += snprintf(content + len, maxLen - len, "  \"dnodes\": [{\n");
-  for (int32_t i = 0; i < pMgmt->dnodeEps->num; ++i) {
-    SDnodeEp *pDnodeEp = &pMgmt->dnodeEps->eps[i];
+
+  int32_t numOfEps = (int32_t)taosArrayGetSize(pMgmt->pDnodeEps);
+  for (int32_t i = 0; i < numOfEps; ++i) {
+    SDnodeEp *pDnodeEp = taosArrayGet(pMgmt->pDnodeEps, i);
     len += snprintf(content + len, maxLen - len, "    \"id\": %d,\n", pDnodeEp->id);
     len += snprintf(content + len, maxLen - len, "    \"fqdn\": \"%s\",\n", pDnodeEp->ep.fqdn);
     len += snprintf(content + len, maxLen - len, "    \"port\": %u,\n", pDnodeEp->ep.port);
     len += snprintf(content + len, maxLen - len, "    \"isMnode\": %d\n", pDnodeEp->isMnode);
-    if (i < pMgmt->dnodeEps->num - 1) {
+    if (i < numOfEps - 1) {
       len += snprintf(content + len, maxLen - len, "  },{\n");
     } else {
       len += snprintf(content + len, maxLen - len, "  }]\n");
@@ -355,40 +353,39 @@ static int32_t dndWriteDnodes(SDnode *pDnode) {
 }
 
 void dndSendStatusReq(SDnode *pDnode) {
-  int32_t contLen = sizeof(SStatusReq) + TSDB_MAX_VNODES * sizeof(SVnodeLoad);
-
-  SStatusReq *pStatus = rpcMallocCont(contLen);
-  if (pStatus == NULL) {
-    dError("failed to malloc status message");
-    return;
-  }
+  SStatusReq req = {0};
 
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   taosRLockLatch(&pMgmt->latch);
-  pStatus->sver = htonl(pDnode->env.sver);
-  pStatus->dver = htobe64(pMgmt->dver);
-  pStatus->dnodeId = htonl(pMgmt->dnodeId);
-  pStatus->clusterId = htobe64(pMgmt->clusterId);
-  pStatus->rebootTime = htobe64(pMgmt->rebootTime);
-  pStatus->updateTime = htobe64(pMgmt->updateTime);
-  pStatus->numOfCores = htonl(pDnode->env.numOfCores);
-  pStatus->numOfSupportVnodes = htonl(pDnode->cfg.numOfSupportVnodes);
-  tstrncpy(pStatus->dnodeEp, pDnode->cfg.localEp, TSDB_EP_LEN);
-
-  pStatus->clusterCfg.statusInterval = htonl(pDnode->cfg.statusInterval);
-  pStatus->clusterCfg.checkTime = 0;
+  req.sver = pDnode->env.sver;
+  req.dver = pMgmt->dver;
+  req.dnodeId = pMgmt->dnodeId;
+  req.clusterId = pMgmt->clusterId;
+  req.rebootTime = pMgmt->rebootTime;
+  req.updateTime = pMgmt->updateTime;
+  req.numOfCores = pDnode->env.numOfCores;
+  req.numOfSupportVnodes = pDnode->cfg.numOfSupportVnodes;
+  memcpy(req.dnodeEp, pDnode->cfg.localEp, TSDB_EP_LEN);
+
+  req.clusterCfg.statusInterval = pDnode->cfg.statusInterval;
+  req.clusterCfg.checkTime = 0;
   char timestr[32] = "1970-01-01 00:00:00.00";
-  (void)taosParseTime(timestr, &pStatus->clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
-  pStatus->clusterCfg.checkTime = htonl(pStatus->clusterCfg.checkTime);
-  tstrncpy(pStatus->clusterCfg.timezone, pDnode->env.timezone, TSDB_TIMEZONE_LEN);
-  tstrncpy(pStatus->clusterCfg.locale, pDnode->env.locale, TSDB_LOCALE_LEN);
-  tstrncpy(pStatus->clusterCfg.charset, pDnode->env.charset, TSDB_LOCALE_LEN);
+  (void)taosParseTime(timestr, &req.clusterCfg.checkTime, (int32_t)strlen(timestr), TSDB_TIME_PRECISION_MILLI, 0);
+  memcpy(req.clusterCfg.timezone, pDnode->env.timezone, TSDB_TIMEZONE_LEN);
+  memcpy(req.clusterCfg.locale, pDnode->env.locale, TSDB_LOCALE_LEN);
+  memcpy(req.clusterCfg.charset, pDnode->env.charset, TSDB_LOCALE_LEN);
   taosRUnLockLatch(&pMgmt->latch);
 
-  dndGetVnodeLoads(pDnode, &pStatus->vnodeLoads);
-  contLen = sizeof(SStatusReq) + pStatus->vnodeLoads.num * sizeof(SVnodeLoad);
+  req.pVloads = taosArrayInit(TSDB_MAX_VNODES, sizeof(SVnodeLoad));
+  dndGetVnodeLoads(pDnode, req.pVloads);
 
-  SRpcMsg rpcMsg = {.pCont = pStatus, .contLen = contLen, .msgType = TDMT_MND_STATUS, .ahandle = (void *)9527};
+  int32_t contLen = tSerializeSStatusReq(NULL, &req);
+  void   *pHead = rpcMallocCont(contLen);
+  void   *pBuf = pHead;
+  tSerializeSStatusReq(&pBuf, &req);
+  taosArrayDestroy(req.pVloads);
+
+  SRpcMsg rpcMsg = {.pCont = pHead, .contLen = contLen, .msgType = TDMT_MND_STATUS, .ahandle = (void *)9527};
   pMgmt->statusSent = 1;
 
   dTrace("pDnode:%p, send status req to mnode", pDnode);
@@ -407,18 +404,20 @@ static void dndUpdateDnodeCfg(SDnode *pDnode, SDnodeCfg *pCfg) {
   }
 }
 
-static void dndUpdateDnodeEps(SDnode *pDnode, SDnodeEps *pDnodeEps) {
-  if (pDnodeEps == NULL || pDnodeEps->num <= 0) return;
+static void dndUpdateDnodeEps(SDnode *pDnode, SArray *pDnodeEps) {
+  int32_t numOfEps = taosArrayGetSize(pDnodeEps);
+  if (numOfEps <= 0) return;
 
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   taosWLockLatch(&pMgmt->latch);
 
-  if (pDnodeEps->num != pMgmt->dnodeEps->num) {
+  int32_t numOfEpsOld = (int32_t)taosArrayGetSize(pMgmt->pDnodeEps);
+  if (numOfEps != numOfEpsOld) {
     dndResetDnodes(pDnode, pDnodeEps);
     dndWriteDnodes(pDnode);
   } else {
-    int32_t size = pDnodeEps->num * sizeof(SDnodeEp) + sizeof(SDnodeEps);
-    if (memcmp(pMgmt->dnodeEps, pDnodeEps, size) != 0) {
+    int32_t size = numOfEps * sizeof(SDnodeEp);
+    if (memcmp(pMgmt->pDnodeEps->pData, pDnodeEps->pData, size) != 0) {
       dndResetDnodes(pDnode, pDnodeEps);
       dndWriteDnodes(pDnode);
     }
@@ -431,33 +430,21 @@ static void dndProcessStatusRsp(SDnode *pDnode, SRpcMsg *pRsp) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
 
   if (pRsp->code != TSDB_CODE_SUCCESS) {
-    pMgmt->statusSent = 0;
     if (pRsp->code == TSDB_CODE_MND_DNODE_NOT_EXIST && !pMgmt->dropped && pMgmt->dnodeId > 0) {
       dInfo("dnode:%d, set to dropped since not exist in mnode", pMgmt->dnodeId);
       pMgmt->dropped = 1;
       dndWriteDnodes(pDnode);
     }
-    return;
-  }
-
-  if (pRsp->pCont != NULL && pRsp->contLen != 0) {
-    SStatusRsp *pStatus = pRsp->pCont;
-    pMgmt->dver = htobe64(pStatus->dver);
-
-    SDnodeCfg *pCfg = &pStatus->dnodeCfg;
-    pCfg->dnodeId = htonl(pCfg->dnodeId);
-    pCfg->clusterId = htobe64(pCfg->clusterId);
-    dndUpdateDnodeCfg(pDnode, pCfg);
-
-    SDnodeEps *pDnodeEps = &pStatus->dnodeEps;
-    pDnodeEps->num = htonl(pDnodeEps->num);
-    for (int32_t i = 0; i < pDnodeEps->num; ++i) {
-      pDnodeEps->eps[i].id = htonl(pDnodeEps->eps[i].id);
-      pDnodeEps->eps[i].ep.port = htons(pDnodeEps->eps[i].ep.port);
+  } else {
+    SStatusRsp statusRsp = {0};
+    if (pRsp->pCont != NULL && pRsp->contLen != 0 && tDeserializeSStatusRsp(pRsp->pCont, &statusRsp) != NULL) {
+      pMgmt->dver = statusRsp.dver;
+      dndUpdateDnodeCfg(pDnode, &statusRsp.dnodeCfg);
+      dndUpdateDnodeEps(pDnode, statusRsp.pDnodeEps);
     }
-
-    dndUpdateDnodeEps(pDnode, pDnodeEps);
+    taosArrayDestroy(statusRsp.pDnodeEps);
   }
+
   pMgmt->statusSent = 0;
 }
 
@@ -572,9 +559,9 @@ void dndCleanupMgmt(SDnode *pDnode) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   taosWLockLatch(&pMgmt->latch);
 
-  if (pMgmt->dnodeEps != NULL) {
-    free(pMgmt->dnodeEps);
-    pMgmt->dnodeEps = NULL;
+  if (pMgmt->pDnodeEps != NULL) {
+    taosArrayDestroy(pMgmt->pDnodeEps);
+    pMgmt->pDnodeEps = NULL;
   }
 
   if (pMgmt->dnodeHash != NULL) {