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

.gitignore

@@ -88,6 +88,7 @@ tests/examples/JDBC/JDBCDemo/.classpath
 tests/examples/JDBC/JDBCDemo/.project
 tests/examples/JDBC/JDBCDemo/.settings/
 source/libs/parser/inc/sql.*
+tests/script/tmqResult.txt
 
 # Emacs
 # -*- mode: gitignore; -*-

contrib/CMakeLists.txt

@@ -83,11 +83,6 @@ if(${BUILD_WITH_NURAFT})
     cat("${CMAKE_SUPPORT_DIR}/nuraft_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
 endif(${BUILD_WITH_NURAFT})
 
-# iconv
-if(${BUILD_WITH_ICONV})
-    cat("${CMAKE_SUPPORT_DIR}/iconv_CMakeLists.txt.in" ${CONTRIB_TMP_FILE})
-endif(${BUILD_WITH_ICONV})
-
 # download dependencies
 configure_file(${CONTRIB_TMP_FILE} "${CMAKE_CONTRIB_DIR}/deps-download/CMakeLists.txt")
 execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" .
@@ -213,11 +208,9 @@ endif(${BUILD_WITH_TRAFT})
 
 # LIBUV
 if(${BUILD_WITH_UV})
-    add_compile_options(-Wno-sign-compare)
-    if (${TD_WINDOWS})
-        file(READ "libuv/include/uv.h" CONTENTS)
-        string(REGEX REPLACE "/([\r]*)\nstruct uv_tcp_s {" "/\\1\ntypedef BOOL (PASCAL *LPFN_CONNECTEX) (SOCKET s, const struct sockaddr* name, int namelen, PVOID lpSendBuffer, DWORD dwSendDataLength,LPDWORD lpdwBytesSent, LPOVERLAPPED lpOverlapped);\\1\nstruct uv_tcp_s {" CONTENTS_NEW "${CONTENTS}")
-        file(WRITE "libuv/include/uv.h" "${CONTENTS_NEW}")
+    if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+        MESSAGE("Windows need set no-sign-compare")
+        add_compile_options(-Wno-sign-compare)
     endif ()
     add_subdirectory(libuv)
 endif(${BUILD_WITH_UV})
@@ -250,15 +243,7 @@ if(${BUILD_WITH_SQLITE})
 endif(${BUILD_WITH_SQLITE})
 
 # pthread
-if(${BUILD_PTHREAD})
-    add_definitions(-DPTW32_STATIC_LIB)
-    add_subdirectory(pthread)
-endif(${BUILD_PTHREAD})
-
-# iconv
-if(${BUILD_WITH_ICONV})
-    add_subdirectory(iconv)
-endif(${BUILD_WITH_ICONV})
+
 
 # ================================================================================================
 # Build test

example/CMakeLists.txt

-aux_source_directory(src TMQ_DEMO_SRC)
+add_executable(tmq "")
+add_executable(tstream "")
 
-add_executable(tmq ${TMQ_DEMO_SRC})
-target_link_libraries(
-    tmq taos
+target_sources(tmq
+    PRIVATE
+    "src/tmq.c"
 )
-target_include_directories(
-    tmq
+
+target_sources(tstream
+    PRIVATE
+    "src/tstream.c"
+)
+target_link_libraries(tmq
+    taos
+)
+
+target_link_libraries(tstream
+    taos
+)
+
+target_include_directories(tmq
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+
+target_include_directories(tstream
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 
 SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
+SET_TARGET_PROPERTIES(tstream PROPERTIES OUTPUT_NAME tstream)

example/src/tstream.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "taos.h"
+
+int32_t init_env() {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  if (pConn == NULL) {
+    return -1;
+  }
+
+  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create stable if not exists st1 (ts timestamp, k int) tags(a int)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table st1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists tu1 using st1 tags(1)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table tu1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists tu2 using st1 tags(2)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table tu2, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+  return 0;
+}
+
+int32_t create_stream() {
+  printf("create stream\n");
+  TAOS_RES* pRes;
+  TAOS*     pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  if (pConn == NULL) {
+    return -1;
+  }
+
+  pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  /*const char* sql = "select min(k), max(k), sum(k) from tu1";*/
+  const char* sql = "select min(k), max(k), sum(k) from st1";
+  /*const char* sql = "select sum(k) from tu1 interval(10m)";*/
+  pRes = tmq_create_stream(pConn, "stream1", "out1", sql);
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create stream out1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+  taos_close(pConn);
+  return 0;
+}
+
+int main(int argc, char* argv[]) {
+  int code;
+  if (argc > 1) {
+    printf("env init\n");
+    code = init_env();
+  }
+  create_stream();
+#if 0
+  tmq_t*      tmq = build_consumer();
+  tmq_list_t* topic_list = build_topic_list();
+  /*perf_loop(tmq, topic_list);*/
+  /*basic_consume_loop(tmq, topic_list);*/
+  sync_consume_loop(tmq, topic_list);
+#endif
+}

include/client/taos.h

@@ -85,11 +85,7 @@ typedef struct taosField {
   int32_t bytes;
 } TAOS_FIELD;
 
-#ifdef _TD_GO_DLL_
-#define DLL_EXPORT __declspec(dllexport)
-#else
 #define DLL_EXPORT
-#endif
 
 typedef void (*__taos_async_fn_t)(void *param, TAOS_RES *, int code);
 
@@ -218,7 +214,6 @@ typedef void(tmq_commit_cb(tmq_t *, tmq_resp_err_t, tmq_topic_vgroup_list_t *, v
 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);
@@ -262,7 +257,12 @@ int32_t tmqGetSkipLogNum(tmq_message_t *tmq_message);
 DLL_EXPORT TAOS_ROW tmq_get_row(tmq_message_t *message);
 DLL_EXPORT char    *tmq_get_topic_name(tmq_message_t *message);
 
-/* ---------------------- OTHER ---------------------------- */
+/* --------------------TMPORARY INTERFACE FOR TESTING--------------------- */
+DLL_EXPORT TAOS_RES *tmq_create_topic(TAOS *taos, const char *name, const char *sql, int sqlLen);
+
+DLL_EXPORT TAOS_RES *tmq_create_stream(TAOS *taos, const char *streamName, const char *tbName, const char *sql);
+
+/* -------------------------------- OTHER -------------------------------- */
 typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code);
 
 DLL_EXPORT int taos_stmt_affected_rows(TAOS_STMT *stmt);

include/common/taosdef.h

@@ -30,12 +30,13 @@ typedef int64_t tb_uid_t;
 #define IS_TSWINDOW_SPECIFIED(win) (((win).skey != INT64_MIN) || ((win).ekey != INT64_MAX))
 
 typedef enum {
-  TSDB_SUPER_TABLE = 1,   // super table
-  TSDB_CHILD_TABLE = 2,   // table created from super table
-  TSDB_NORMAL_TABLE = 3,  // ordinary table
-  TSDB_STREAM_TABLE = 4,  // table created by stream processing
-  TSDB_TEMP_TABLE = 5,    // temp table created by nest query
-  TSDB_TABLE_MAX = 6
+  TSDB_SUPER_TABLE  = 1,    // super table
+  TSDB_CHILD_TABLE  = 2,    // table created from super table
+  TSDB_NORMAL_TABLE = 3,    // ordinary table
+  TSDB_STREAM_TABLE = 4,    // table created from stream computing
+  TSDB_TEMP_TABLE   = 5,    // temp table created by nest query
+  TSDB_SYSTEM_TABLE = 6,
+  TSDB_TABLE_MAX    = 7
 } ETableType;
 
 typedef enum {

include/common/tcommon.h

@@ -60,19 +60,12 @@ typedef struct SDataBlockInfo {
   int16_t        numOfCols;
   int16_t        hasVarCol;
   union {int64_t uid; int64_t blockId;};
+  int64_t        groupId;     // no need to serialize
 } SDataBlockInfo;
 
-//typedef struct SConstantItem {
-//  SColumnInfo info;
-//  int32_t     startRow;  // run-length-encoding to save the space for multiple rows
-//  int32_t     endRow;
-//  SVariant    value;
-//} SConstantItem;
-
-// info.numOfCols = taosArrayGetSize(pDataBlock) + taosArrayGetSize(pConstantList);
 typedef struct SSDataBlock {
-  SColumnDataAgg *pBlockAgg;
-  SArray         *pDataBlock;    // SArray<SColumnInfoData>
+  SColumnDataAgg* pBlockAgg;
+  SArray*         pDataBlock;  // SArray<SColumnInfoData>
   SDataBlockInfo  info;
 } SSDataBlock;
 
@@ -98,23 +91,40 @@ void*   blockDataDestroy(SSDataBlock* pBlock);
 int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock);
 void*   tDecodeDataBlock(const void* buf, SSDataBlock* pBlock);
 
-static FORCE_INLINE void tDeleteSSDataBlock(SSDataBlock* pBlock) {
-  if (pBlock == NULL) {
-    return;
+int32_t tEncodeDataBlocks(void** buf, const SArray* blocks);
+void*   tDecodeDataBlocks(const void* buf, SArray* blocks);
+
+static FORCE_INLINE void blockDestroyInner(SSDataBlock* pBlock) {
+  // WARNING: do not use info.numOfCols,
+  // sometimes info.numOfCols != array size
+  int32_t numOfOutput = taosArrayGetSize(pBlock->pDataBlock);
+  for (int32_t i = 0; i < numOfOutput; ++i) {
+    SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);
+    if (IS_VAR_DATA_TYPE(pColInfoData->info.type)) {
+      tfree(pColInfoData->varmeta.offset);
+    } else {
+      tfree(pColInfoData->nullbitmap);
+    }
+
+    tfree(pColInfoData->pData);
   }
-  blockDataDestroy(pBlock);
+
+  taosArrayDestroy(pBlock->pDataBlock);
+  tfree(pBlock->pBlockAgg);
 }
 
+static FORCE_INLINE void tDeleteSSDataBlock(SSDataBlock* pBlock) { blockDestroyInner(pBlock); }
+
 static FORCE_INLINE int32_t tEncodeSMqPollRsp(void** buf, const SMqPollRsp* pRsp) {
   int32_t tlen = 0;
   int32_t sz = 0;
-  tlen += taosEncodeFixedI64(buf, pRsp->consumerId);
+  // tlen += taosEncodeFixedI64(buf, pRsp->consumerId);
   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);
+  tlen += tEncodeSSchemaWrapper(buf, pRsp->schema);
   if (pRsp->pBlockData) {
     sz = taosArrayGetSize(pRsp->pBlockData);
   }
@@ -128,15 +138,15 @@ static FORCE_INLINE int32_t tEncodeSMqPollRsp(void** buf, const SMqPollRsp* pRsp
 
 static FORCE_INLINE void* tDecodeSMqPollRsp(void* buf, SMqPollRsp* pRsp) {
   int32_t sz;
-  buf = taosDecodeFixedI64(buf, &pRsp->consumerId);
+  // buf = taosDecodeFixedI64(buf, &pRsp->consumerId);
   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);
+  pRsp->schema = (SSchemaWrapper*)calloc(1, sizeof(SSchemaWrapper));
+  if (pRsp->schema == NULL) return NULL;
+  buf = tDecodeSSchemaWrapper(buf, pRsp->schema);
   buf = taosDecodeFixedI32(buf, &sz);
   pRsp->pBlockData = taosArrayInit(sz, sizeof(SSDataBlock));
   for (int32_t i = 0; i < sz; i++) {
@@ -148,13 +158,13 @@ static FORCE_INLINE void* tDecodeSMqPollRsp(void* buf, SMqPollRsp* pRsp) {
 }
 
 static FORCE_INLINE void tDeleteSMqConsumeRsp(SMqPollRsp* pRsp) {
-  if (pRsp->schemas) {
-    if (pRsp->schemas->nCols) {
-      tfree(pRsp->schemas->pSchema);
+  if (pRsp->schema) {
+    if (pRsp->schema->nCols) {
+      tfree(pRsp->schema->pSchema);
     }
-    free(pRsp->schemas);
+    free(pRsp->schema);
   }
-  taosArrayDestroyEx(pRsp->pBlockData, (void (*)(void*))tDeleteSSDataBlock);
+  taosArrayDestroyEx(pRsp->pBlockData, (void (*)(void*))blockDestroyInner);
   pRsp->pBlockData = NULL;
 }
 
@@ -166,10 +176,8 @@ typedef struct SColumn {
     int64_t  dataBlockId;
   };
 
-  union {
-    int16_t colId;
-    int16_t slotId;
-  };
+  int16_t colId;
+  int16_t slotId;
 
   char    name[TSDB_COL_NAME_LEN];
   int8_t  flag;  // column type: normal column, tag, or user-input column (integer/float/string)
@@ -196,7 +204,7 @@ typedef struct SGroupbyExpr {
 
 typedef struct SFunctParam {
   int32_t  type;
-  SColumn *pCol;
+  SColumn* pCol;
   SVariant param;
 } SFunctParam;
 
@@ -214,12 +222,12 @@ typedef struct SResSchame {
 typedef struct SExprBasicInfo {
   SResSchema   resSchema;
   int16_t      numOfParams;  // argument value of each function
-  SFunctParam *pParam;
+  SFunctParam* pParam;
 } SExprBasicInfo;
 
 typedef struct SExprInfo {
-  struct SExprBasicInfo  base;
-  struct tExprNode      *pExpr;
+  struct SExprBasicInfo base;
+  struct tExprNode*     pExpr;
 } SExprInfo;
 
 typedef struct SStateWindow {

include/common/tdatablock.h

@@ -102,8 +102,8 @@ static FORCE_INLINE bool colDataIsNull(const SColumnInfoData* pColumnInfoData, u
                                         : ((p1_)->pData + ((r_) * (p1_)->info.bytes)))
 
 int32_t colDataAppend(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, bool isNull);
-int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, const SColumnInfoData* pSource,
-                        uint32_t numOfRow2);
+int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, uint32_t numOfRow1, const SColumnInfoData* pSource, uint32_t numOfRow2);
+int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows);
 int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock);
 
 int32_t colDataGetLength(const SColumnInfoData* pColumnInfoData, int32_t numOfRows);
@@ -112,16 +112,15 @@ void    colDataTrim(SColumnInfoData* pColumnInfoData);
 size_t blockDataGetNumOfCols(const SSDataBlock* pBlock);
 size_t blockDataGetNumOfRows(const SSDataBlock* pBlock);
 
-int32_t      blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc);
-int32_t      blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex,
-                                int32_t pageSize);
-SSDataBlock* blockDataExtractBlock(SSDataBlock* pBlock, int32_t startIndex, int32_t rowCount);
-
+int32_t blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc);
+int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex, int32_t pageSize);
 int32_t blockDataToBuf(char* buf, const SSDataBlock* pBlock);
 int32_t blockDataFromBuf(SSDataBlock* pBlock, const char* buf);
 
+SSDataBlock* blockDataExtractBlock(SSDataBlock* pBlock, int32_t startIndex, int32_t rowCount);
+
 size_t blockDataGetSize(const SSDataBlock* pBlock);
-size_t blockDataGetRowSize(const SSDataBlock* pBlock);
+size_t blockDataGetRowSize(SSDataBlock* pBlock);
 double blockDataGetSerialRowSize(const SSDataBlock* pBlock);
 size_t blockDataGetSerialMetaSize(const SSDataBlock* pBlock);
 
@@ -132,7 +131,7 @@ int32_t blockDataSort_rv(SSDataBlock* pDataBlock, SArray* pOrderInfo, bool nullF
 
 int32_t      blockDataEnsureColumnCapacity(SColumnInfoData* pColumn, uint32_t numOfRows);
 int32_t      blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);
-void         blockDataClearup(SSDataBlock* pDataBlock);
+void         blockDataCleanup(SSDataBlock* pDataBlock);
 SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock);
 size_t       blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize);
 void*        blockDataDestroy(SSDataBlock* pBlock);

include/common/tmsg.h

@@ -23,6 +23,7 @@
 #include "tencode.h"
 #include "thash.h"
 #include "tlist.h"
+#include "tname.h"
 #include "trow.h"
 #include "tuuid.h"
 
@@ -471,6 +472,10 @@ typedef struct {
   int32_t code;
 } SQueryTableRsp;
 
+int32_t tSerializeSQueryTableRsp(void* buf, int32_t bufLen, SQueryTableRsp* pRsp);
+
+int32_t tDeserializeSQueryTableRsp(void* buf, int32_t bufLen, SQueryTableRsp* pRsp);
+
 typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
   int32_t numOfVgroups;
@@ -863,6 +868,7 @@ void    tFreeSShowRsp(SShowRsp* pRsp);
 typedef struct {
   int32_t type;
   char    db[TSDB_DB_FNAME_LEN];
+  char    tb[TSDB_TABLE_NAME_LEN];
   int64_t showId;
   int8_t  free;
 } SRetrieveTableReq;
@@ -880,6 +886,17 @@ typedef struct {
   char    data[];
 } SRetrieveTableRsp;
 
+typedef struct {
+  int64_t handle;
+  int64_t useconds;
+  int8_t  completed;  // all results are returned to client
+  int8_t  precision;
+  int8_t  compressed;
+  int32_t compLen;
+  int32_t numOfRows;
+  char    data[];
+} SRetrieveMetaTableRsp;
+
 typedef struct {
   char    fqdn[TSDB_FQDN_LEN];  // end point, hostname:port
   int32_t port;
@@ -1282,7 +1299,7 @@ static FORCE_INLINE SMqRebSubscribe* tNewSMqRebSubscribe(const char* key) {
   if (pRebSub == NULL) {
     goto _err;
   }
-  pRebSub->key = key;
+  pRebSub->key = strdup(key);
   pRebSub->lostConsumers = taosArrayInit(0, sizeof(int64_t));
   if (pRebSub->lostConsumers == NULL) {
     goto _err;
@@ -1345,33 +1362,54 @@ typedef struct {
   int64_t  tuid;
 } SDDropTopicReq;
 
+typedef struct {
+  float    xFilesFactor;
+  int8_t   delayUnit;
+  int8_t   nFuncIds;
+  int32_t* pFuncIds;
+  int64_t  delay;
+} SRSmaParam;
+
 typedef struct SVCreateTbReq {
   int64_t  ver;  // use a general definition
+  char*    dbFName;
   char*    name;
   uint32_t ttl;
   uint32_t keep;
-  uint8_t  type;
   union {
+    uint8_t info;
     struct {
-      tb_uid_t suid;
-      uint32_t nCols;
-      SSchema* pSchema;
-      uint32_t nTagCols;
-      SSchema* pTagSchema;
+      uint8_t rollup : 1;  // 1 means rollup sma
+      uint8_t type : 7;
+    };
+  };
+  union {
+    struct {
+      tb_uid_t    suid;
+      uint32_t    nCols;
+      SSchema*    pSchema;
+      uint32_t    nTagCols;
+      SSchema*    pTagSchema;
+      col_id_t    nBSmaCols;
+      col_id_t*   pBSmaCols;
+      SRSmaParam* pRSmaParam;
     } stbCfg;
     struct {
       tb_uid_t suid;
       SKVRow   pTag;
     } ctbCfg;
     struct {
-      uint32_t nCols;
-      SSchema* pSchema;
+      uint32_t    nCols;
+      SSchema*    pSchema;
+      col_id_t    nBSmaCols;
+      col_id_t*   pBSmaCols;
+      SRSmaParam* pRSmaParam;
     } ntbCfg;
   };
 } SVCreateTbReq, SVUpdateTbReq;
 
 typedef struct {
-  int tmp;  // TODO: to avoid compile error
+  int32_t code;
 } SVCreateTbRsp, SVUpdateTbRsp;
 
 int32_t tSerializeSVCreateTbReq(void** buf, SVCreateTbReq* pReq);
@@ -1382,12 +1420,15 @@ typedef struct {
   SArray* pArray;
 } SVCreateTbBatchReq;
 
+int32_t tSerializeSVCreateTbBatchReq(void** buf, SVCreateTbBatchReq* pReq);
+void*   tDeserializeSVCreateTbBatchReq(void* buf, SVCreateTbBatchReq* pReq);
+
 typedef struct {
-  int tmp;  // TODO: to avoid compile error
+  SArray* rspList;  // SArray<SVCreateTbRsp>
 } SVCreateTbBatchRsp;
 
-int32_t tSerializeSVCreateTbBatchReq(void** buf, SVCreateTbBatchReq* pReq);
-void*   tDeserializeSVCreateTbBatchReq(void* buf, SVCreateTbBatchReq* pReq);
+int32_t tSerializeSVCreateTbBatchRsp(void* buf, int32_t bufLen, SVCreateTbBatchRsp* pRsp);
+int32_t tDeserializeSVCreateTbBatchRsp(void* buf, int32_t bufLen, SVCreateTbBatchRsp* pRsp);
 
 typedef struct {
   int64_t  ver;
@@ -2116,25 +2157,16 @@ typedef struct {
   int8_t  mqMsgType;
   int32_t code;
   int32_t epoch;
+  int64_t consumerId;
 } SMqRspHead;
 
-typedef struct {
-  int64_t         consumerId;
-  SSchemaWrapper* schemas;
-  int64_t         reqOffset;
-  int64_t         rspOffset;
-  int32_t         skipLogNum;
-  int32_t         numOfTopics;
-  SArray*         pBlockData;  // SArray<SSDataBlock>
-} SMqPollRsp;
-
-// one req for one vg+topic
 typedef struct {
   SMsgHead head;
 
   int64_t consumerId;
   int64_t blockingTime;
   int32_t epoch;
+  int8_t  withSchema;
   char    cgroup[TSDB_CGROUP_LEN];
 
   int64_t currentOffset;
@@ -2153,19 +2185,22 @@ typedef struct {
 } SMqSubTopicEp;
 
 typedef struct {
-  int64_t consumerId;
-  char    cgroup[TSDB_CGROUP_LEN];
-  SArray* topics;  // SArray<SMqSubTopicEp>
-} SMqCMGetSubEpRsp;
+  SMqRspHead head;
+  int64_t    reqOffset;
+  int64_t    rspOffset;
+  int32_t    skipLogNum;
+  // TODO: replace with topic name
+  int32_t numOfTopics;
+  // TODO: remove from msg
+  SSchemaWrapper* schema;
+  SArray*         pBlockData;  // SArray<SSDataBlock>
+} SMqPollRsp;
 
 typedef struct {
   SMqRspHead head;
-  union {
-    SMqPollRsp       consumeRsp;
-    SMqCMGetSubEpRsp getEpRsp;
-  };
-  void* extra;
-} SMqMsgWrapper;
+  char       cgroup[TSDB_CGROUP_LEN];
+  SArray*    topics;  // SArray<SMqSubTopicEp>
+} SMqCMGetSubEpRsp;
 
 typedef struct {
   int32_t curBlock;
@@ -2173,11 +2208,13 @@ typedef struct {
   void**  uData;
 } SMqRowIter;
 
-struct tmq_message_t_v1 {
-  SMqPollRsp rsp;
+struct tmq_message_t {
+  SMqPollRsp msg;
+  void*      vg;
   SMqRowIter iter;
 };
 
+#if 0
 struct tmq_message_t {
   SMqRspHead head;
   union {
@@ -2189,6 +2226,7 @@ struct tmq_message_t {
   int32_t curRow;
   void**  uData;
 };
+#endif
 
 static FORCE_INLINE void tDeleteSMqSubTopicEp(SMqSubTopicEp* pSubTopicEp) { taosArrayDestroy(pSubTopicEp->vgs); }
 
@@ -2241,8 +2279,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 += taosEncodeString(buf, pRsp->cgroup);
+  // tlen += taosEncodeString(buf, pRsp->cgroup);
   int32_t sz = taosArrayGetSize(pRsp->topics);
   tlen += taosEncodeFixedI32(buf, sz);
   for (int32_t i = 0; i < sz; i++) {
@@ -2253,8 +2290,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 = taosDecodeStringTo(buf, pRsp->cgroup);
+  // buf = taosDecodeStringTo(buf, pRsp->cgroup);
   int32_t sz;
   buf = taosDecodeFixedI32(buf, &sz);
   pRsp->topics = taosArrayInit(sz, sizeof(SMqSubTopicEp));
@@ -2274,22 +2310,30 @@ enum {
   STREAM_TASK_STATUS__STOP,
 };
 
+enum {
+  STREAM_NEXT_OP_DST__VND = 1,
+  STREAM_NEXT_OP_DST__SND,
+};
+
 typedef struct {
-  void*  inputHandle;
-  void** executor;
-} SStreamTaskParRunner;
+  void* inputHandle;
+  void* executor;
+} SStreamRunner;
 
 typedef struct {
   int64_t streamId;
   int32_t taskId;
   int32_t level;
   int8_t  status;
-  int8_t  pipeEnd;
-  int8_t  parallel;
+  int8_t  pipeSource;
+  int8_t  pipeSink;
+  int8_t  numOfRunners;
+  int8_t  parallelizable;
+  int8_t  nextOpDst;  // vnode or snode
   SEpSet  NextOpEp;
   char*   qmsg;
   // not applied to encoder and decoder
-  SStreamTaskParRunner runner;
+  SStreamRunner runner[8];
   // void*                executor;
   // void*   stateStore;
   //  storage handle
@@ -2301,6 +2345,8 @@ static FORCE_INLINE SStreamTask* streamTaskNew(int64_t streamId, int32_t level)
     return NULL;
   }
   pTask->taskId = tGenIdPI32();
+  pTask->streamId = streamId;
+  pTask->level = level;
   pTask->status = STREAM_TASK_STATUS__RUNNING;
   pTask->qmsg = NULL;
   return pTask;
@@ -2321,7 +2367,7 @@ typedef struct {
 
 typedef struct {
   SStreamExecMsgHead head;
-  // TODO: other info needed by task
+  SArray*            data;  // SArray<SSDataBlock>
 } SStreamTaskExecReq;
 
 typedef struct {
@@ -2330,14 +2376,6 @@ typedef struct {
 
 #pragma pack(pop)
 
-struct SRpcMsg;
-struct SEpSet;
-struct SMgmtWrapper;
-typedef int32_t (*PutToQueueFp)(struct SMgmtWrapper* pWrapper, struct SRpcMsg* pReq);
-typedef int32_t (*SendReqFp)(struct SMgmtWrapper* pWrapper, struct SEpSet* epSet, struct SRpcMsg* pReq);
-typedef int32_t (*SendMnodeReqFp)(struct SMgmtWrapper* pWrapper, struct SRpcMsg* pReq);
-typedef void (*SendRspFp)(struct SMgmtWrapper* pWrapper, struct SRpcMsg* pRsp);
-
 #ifdef __cplusplus
 }
 #endif

include/common/tmsgcb.h

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_COMMON_MSG_CB_H_
+#define _TD_COMMON_MSG_CB_H_
+
+#include "os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SRpcMsg      SRpcMsg;
+typedef struct SEpSet       SEpSet;
+typedef struct SMgmtWrapper SMgmtWrapper;
+typedef enum { QUERY_QUEUE, FETCH_QUEUE, WRITE_QUEUE, APPLY_QUEUE, SYNC_QUEUE, QUEUE_MAX } EQueueType;
+
+typedef int32_t (*PutToQueueFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq);
+typedef int32_t (*GetQueueSizeFp)(SMgmtWrapper* pWrapper, int32_t vgId, EQueueType qtype);
+typedef int32_t (*SendReqFp)(SMgmtWrapper* pWrapper, SEpSet* epSet, SRpcMsg* pReq);
+typedef int32_t (*SendMnodeReqFp)(SMgmtWrapper* pWrapper, SRpcMsg* pReq);
+typedef void (*SendRspFp)(SMgmtWrapper* pWrapper, SRpcMsg* pRsp);
+
+typedef struct {
+  SMgmtWrapper*  pWrapper;
+  PutToQueueFp   queueFps[QUEUE_MAX];
+  GetQueueSizeFp qsizeFp;
+  SendReqFp      sendReqFp;
+  SendMnodeReqFp sendMnodeReqFp;
+  SendRspFp      sendRspFp;
+} SMsgCb;
+
+int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq);
+int32_t tmsgGetQueueSize(const SMsgCb* pMsgCb, int32_t vgId, EQueueType qtype);
+int32_t tmsgSendReq(const SMsgCb* pMsgCb, SEpSet* epSet, SRpcMsg* pReq);
+int32_t tmsgSendMnodeReq(const SMsgCb* pMsgCb, SRpcMsg* pReq);
+void    tmsgSendRsp(const SMsgCb* pMsgCb, SRpcMsg* pRsp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_COMMON_MSG_CB_H_*/

include/common/tmsgdef.h

@@ -191,6 +191,7 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_CONSUME, "vnode-consume", SMqCVConsumeReq, SMqCVConsumeRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_TASK_DEPLOY, "vnode-task-deploy", SStreamTaskDeployReq, SStreamTaskDeployRsp)
   TD_DEF_MSG_TYPE(TDMT_VND_TASK_EXEC, "vnode-task-exec", SStreamTaskExecReq, SStreamTaskExecRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_STREAM_TRIGGER, "vnode-stream-trigger", NULL, NULL)
 
   TD_DEF_MSG_TYPE(TDMT_VND_CREATE_SMA, "vnode-create-sma", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_CANCEL_SMA, "vnode-cancel-sma", NULL, NULL)

include/common/tname.h

@@ -17,7 +17,6 @@
 #define _TD_COMMON_NAME_H_
 
 #include "tdef.h"
-#include "tmsg.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -61,7 +60,8 @@ int32_t tNameFromString(SName* dst, const char* str, uint32_t type);
 
 int32_t tNameSetAcctId(SName* dst, int32_t acctId);
 
-SSchema createSchema(uint8_t type, int32_t bytes, int32_t colId, const char* name);
+bool tNameDBNameEqual(SName* left, SName* right);
+
 
 #ifdef __cplusplus
 }

include/common/trow.h

@@ -166,6 +166,7 @@ typedef struct {
 #define TD_ROW_HEAD_LEN  (sizeof(STSRow))
 #define TD_ROW_NCOLS_LEN (sizeof(col_id_t))
 
+#define TD_ROW_INFO(r)     ((r)->info)
 #define TD_ROW_TYPE(r)     ((r)->type)
 #define TD_ROW_DELETE(r)   ((r)->del)
 #define TD_ROW_ENDIAN(r)   ((r)->endian)
@@ -180,6 +181,7 @@ typedef struct {
 // (int32_t)ceil((double)nCols/TD_VTYPE_PARTS) should be added if TD_SUPPORT_BITMAP defined.
 #define TD_ROW_MAX_BYTES_FROM_SCHEMA(s) (schemaTLen(s) + TD_ROW_HEAD_LEN)
 
+#define TD_ROW_SET_INFO(r, i)  (TD_ROW_INFO(r) = (i))
 #define TD_ROW_SET_TYPE(r, t)  (TD_ROW_TYPE(r) = (t))
 #define TD_ROW_SET_DELETE(r)   (TD_ROW_DELETE(r) = 1)
 #define TD_ROW_SET_SVER(r, v)  (TD_ROW_SVER(r) = (v))
@@ -473,6 +475,7 @@ static int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
     return terrno;
   }
 
+  TD_ROW_SET_INFO(pBuilder->pBuf, 0);
   TD_ROW_SET_TYPE(pBuilder->pBuf, pBuilder->rowType);
 
   uint32_t len = 0;
@@ -968,10 +971,14 @@ static FORCE_INLINE int32_t tdGetColDataOfRow(SCellVal *pVal, SDataCol *pCol, in
 #endif
     return TSDB_CODE_SUCCESS;
   }
-  if (tdGetBitmapValType(pCol->pBitmap, row, &(pVal->valType)) < 0) {
+
+  if (TD_COL_ROWS_NORM(pCol)) {
+    pVal->valType = TD_VTYPE_NORM;
+  } else if (tdGetBitmapValType(pCol->pBitmap, row, &(pVal->valType)) < 0) {
     return terrno;
   }
-  if (TD_COL_ROWS_NORM(pCol) || tdValTypeIsNorm(pVal->valType)) {
+
+  if (tdValTypeIsNorm(pVal->valType)) {
     if (IS_VAR_DATA_TYPE(pCol->type)) {
       pVal->val = POINTER_SHIFT(pCol->pData, pCol->dataOff[row]);
     } else {

include/common/ttokendef.h

@@ -51,130 +51,133 @@
 #define TK_USER                            33
 #define TK_PRIVILEGE                       34
 #define TK_DROP                            35
-#define TK_SHOW                            36
-#define TK_DNODE                           37
-#define TK_PORT                            38
-#define TK_NK_INTEGER                      39
-#define TK_DNODES                          40
-#define TK_NK_IPTOKEN                      41
-#define TK_LOCAL                           42
-#define TK_QNODE                           43
-#define TK_ON                              44
-#define TK_QNODES                          45
-#define TK_DATABASE                        46
-#define TK_DATABASES                       47
-#define TK_USE                             48
-#define TK_IF                              49
-#define TK_NOT                             50
-#define TK_EXISTS                          51
-#define TK_BLOCKS                          52
-#define TK_CACHE                           53
-#define TK_CACHELAST                       54
-#define TK_COMP                            55
-#define TK_DAYS                            56
-#define TK_FSYNC                           57
-#define TK_MAXROWS                         58
-#define TK_MINROWS                         59
-#define TK_KEEP                            60
-#define TK_PRECISION                       61
-#define TK_QUORUM                          62
-#define TK_REPLICA                         63
-#define TK_TTL                             64
-#define TK_WAL                             65
-#define TK_VGROUPS                         66
-#define TK_SINGLE_STABLE                   67
-#define TK_STREAM_MODE                     68
-#define TK_RETENTIONS                      69
-#define TK_FILE_FACTOR                     70
-#define TK_NK_FLOAT                        71
-#define TK_TABLE                           72
-#define TK_NK_LP                           73
-#define TK_NK_RP                           74
-#define TK_STABLE                          75
-#define TK_TABLES                          76
-#define TK_STABLES                         77
-#define TK_ADD                             78
-#define TK_COLUMN                          79
-#define TK_MODIFY                          80
-#define TK_RENAME                          81
-#define TK_TAG                             82
-#define TK_SET                             83
-#define TK_NK_EQ                           84
-#define TK_USING                           85
-#define TK_TAGS                            86
-#define TK_NK_DOT                          87
-#define TK_NK_COMMA                        88
-#define TK_COMMENT                         89
-#define TK_BOOL                            90
-#define TK_TINYINT                         91
-#define TK_SMALLINT                        92
-#define TK_INT                             93
-#define TK_INTEGER                         94
-#define TK_BIGINT                          95
-#define TK_FLOAT                           96
-#define TK_DOUBLE                          97
-#define TK_BINARY                          98
-#define TK_TIMESTAMP                       99
-#define TK_NCHAR                          100
-#define TK_UNSIGNED                       101
-#define TK_JSON                           102
-#define TK_VARCHAR                        103
-#define TK_MEDIUMBLOB                     104
-#define TK_BLOB                           105
-#define TK_VARBINARY                      106
-#define TK_DECIMAL                        107
-#define TK_SMA                            108
-#define TK_ROLLUP                         109
-#define TK_INDEX                          110
-#define TK_FULLTEXT                       111
-#define TK_FUNCTION                       112
-#define TK_INTERVAL                       113
-#define TK_TOPIC                          114
-#define TK_AS                             115
-#define TK_MNODES                         116
-#define TK_NK_BOOL                        117
-#define TK_NK_VARIABLE                    118
-#define TK_BETWEEN                        119
-#define TK_IS                             120
-#define TK_NULL                           121
-#define TK_NK_LT                          122
-#define TK_NK_GT                          123
-#define TK_NK_LE                          124
-#define TK_NK_GE                          125
-#define TK_NK_NE                          126
-#define TK_LIKE                           127
-#define TK_MATCH                          128
-#define TK_NMATCH                         129
-#define TK_IN                             130
-#define TK_FROM                           131
-#define TK_JOIN                           132
-#define TK_INNER                          133
-#define TK_SELECT                         134
-#define TK_DISTINCT                       135
-#define TK_WHERE                          136
-#define TK_PARTITION                      137
-#define TK_BY                             138
-#define TK_SESSION                        139
-#define TK_STATE_WINDOW                   140
-#define TK_SLIDING                        141
-#define TK_FILL                           142
-#define TK_VALUE                          143
-#define TK_NONE                           144
-#define TK_PREV                           145
-#define TK_LINEAR                         146
-#define TK_NEXT                           147
-#define TK_GROUP                          148
-#define TK_HAVING                         149
-#define TK_ORDER                          150
-#define TK_SLIMIT                         151
-#define TK_SOFFSET                        152
-#define TK_LIMIT                          153
-#define TK_OFFSET                         154
-#define TK_ASC                            155
-#define TK_DESC                           156
-#define TK_NULLS                          157
-#define TK_FIRST                          158
-#define TK_LAST                           159
+#define TK_DNODE                           36
+#define TK_PORT                            37
+#define TK_NK_INTEGER                      38
+#define TK_DNODES                          39
+#define TK_NK_IPTOKEN                      40
+#define TK_LOCAL                           41
+#define TK_QNODE                           42
+#define TK_ON                              43
+#define TK_DATABASE                        44
+#define TK_USE                             45
+#define TK_IF                              46
+#define TK_NOT                             47
+#define TK_EXISTS                          48
+#define TK_BLOCKS                          49
+#define TK_CACHE                           50
+#define TK_CACHELAST                       51
+#define TK_COMP                            52
+#define TK_DAYS                            53
+#define TK_FSYNC                           54
+#define TK_MAXROWS                         55
+#define TK_MINROWS                         56
+#define TK_KEEP                            57
+#define TK_PRECISION                       58
+#define TK_QUORUM                          59
+#define TK_REPLICA                         60
+#define TK_TTL                             61
+#define TK_WAL                             62
+#define TK_VGROUPS                         63
+#define TK_SINGLE_STABLE                   64
+#define TK_STREAM_MODE                     65
+#define TK_RETENTIONS                      66
+#define TK_FILE_FACTOR                     67
+#define TK_NK_FLOAT                        68
+#define TK_TABLE                           69
+#define TK_NK_LP                           70
+#define TK_NK_RP                           71
+#define TK_STABLE                          72
+#define TK_ADD                             73
+#define TK_COLUMN                          74
+#define TK_MODIFY                          75
+#define TK_RENAME                          76
+#define TK_TAG                             77
+#define TK_SET                             78
+#define TK_NK_EQ                           79
+#define TK_USING                           80
+#define TK_TAGS                            81
+#define TK_NK_DOT                          82
+#define TK_NK_COMMA                        83
+#define TK_COMMENT                         84
+#define TK_BOOL                            85
+#define TK_TINYINT                         86
+#define TK_SMALLINT                        87
+#define TK_INT                             88
+#define TK_INTEGER                         89
+#define TK_BIGINT                          90
+#define TK_FLOAT                           91
+#define TK_DOUBLE                          92
+#define TK_BINARY                          93
+#define TK_TIMESTAMP                       94
+#define TK_NCHAR                           95
+#define TK_UNSIGNED                        96
+#define TK_JSON                            97
+#define TK_VARCHAR                         98
+#define TK_MEDIUMBLOB                      99
+#define TK_BLOB                           100
+#define TK_VARBINARY                      101
+#define TK_DECIMAL                        102
+#define TK_SMA                            103
+#define TK_ROLLUP                         104
+#define TK_SHOW                           105
+#define TK_DATABASES                      106
+#define TK_TABLES                         107
+#define TK_STABLES                        108
+#define TK_MNODES                         109
+#define TK_MODULES                        110
+#define TK_QNODES                         111
+#define TK_FUNCTIONS                      112
+#define TK_INDEXES                        113
+#define TK_FROM                           114
+#define TK_LIKE                           115
+#define TK_INDEX                          116
+#define TK_FULLTEXT                       117
+#define TK_FUNCTION                       118
+#define TK_INTERVAL                       119
+#define TK_TOPIC                          120
+#define TK_AS                             121
+#define TK_NK_BOOL                        122
+#define TK_NK_VARIABLE                    123
+#define TK_BETWEEN                        124
+#define TK_IS                             125
+#define TK_NULL                           126
+#define TK_NK_LT                          127
+#define TK_NK_GT                          128
+#define TK_NK_LE                          129
+#define TK_NK_GE                          130
+#define TK_NK_NE                          131
+#define TK_MATCH                          132
+#define TK_NMATCH                         133
+#define TK_IN                             134
+#define TK_JOIN                           135
+#define TK_INNER                          136
+#define TK_SELECT                         137
+#define TK_DISTINCT                       138
+#define TK_WHERE                          139
+#define TK_PARTITION                      140
+#define TK_BY                             141
+#define TK_SESSION                        142
+#define TK_STATE_WINDOW                   143
+#define TK_SLIDING                        144
+#define TK_FILL                           145
+#define TK_VALUE                          146
+#define TK_NONE                           147
+#define TK_PREV                           148
+#define TK_LINEAR                         149
+#define TK_NEXT                           150
+#define TK_GROUP                          151
+#define TK_HAVING                         152
+#define TK_ORDER                          153
+#define TK_SLIMIT                         154
+#define TK_SOFFSET                        155
+#define TK_LIMIT                          156
+#define TK_OFFSET                         157
+#define TK_ASC                            158
+#define TK_DESC                           159
+#define TK_NULLS                          160
+#define TK_FIRST                          161
+#define TK_LAST                           162
 
 #define TK_NK_SPACE                       300
 #define TK_NK_COMMENT                     301

include/common/ttypes.h

@@ -46,7 +46,7 @@ typedef struct {
 #define varDataCopy(dst, v)    memcpy((dst), (void *)(v), varDataTLen(v))
 #define varDataLenByData(v)    (*(VarDataLenT *)(((char *)(v)) - VARSTR_HEADER_SIZE))
 #define varDataSetLen(v, _len) (((VarDataLenT *)(v))[0] = (VarDataLenT)(_len))
-#define IS_VAR_DATA_TYPE(t)    (((t) == TSDB_DATA_TYPE_BINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
+#define IS_VAR_DATA_TYPE(t)    (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_NCHAR))
 
 #define varDataNetLen(v)  (htons(((VarDataLenT *)(v))[0]))
 #define varDataNetTLen(v) (sizeof(VarDataLenT) + varDataNetLen(v))

include/dnode/bnode/bnode.h

@@ -16,24 +16,20 @@
 #ifndef _TD_BNODE_H_
 #define _TD_BNODE_H_
 
+#include "tmsgcb.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* ------------------------ TYPES EXPOSED ------------------------ */
-typedef struct SMgmtWrapper SMgmtWrapper;
-typedef struct SBnode       SBnode;
+typedef struct SBnode SBnode;
 
 typedef struct {
 } SBnodeLoad;
 
 typedef struct {
-  int32_t        dnodeId;
-  int64_t        clusterId;
-  SMgmtWrapper  *pWrapper;
-  SendReqFp      sendReqFp;
-  SendMnodeReqFp sendMnodeReqFp;
-  SendRspFp      sendRspFp;
+  SMsgCb msgCb;
 } SBnodeOpt;
 
 /* ------------------------ SBnode ------------------------ */

include/dnode/mnode/mnode.h

@@ -17,27 +17,22 @@
 #define _TD_MND_H_
 
 #include "monitor.h"
+#include "tmsgcb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* ------------------------ TYPES EXPOSED ------------------------ */
-typedef struct SMgmtWrapper SMgmtWrapper;
-typedef struct SMnode       SMnode;
+typedef struct SMnode SMnode;
 
 typedef struct {
-  int32_t        dnodeId;
-  int64_t        clusterId;
-  int8_t         replica;
-  int8_t         selfIndex;
-  SReplica       replicas[TSDB_MAX_REPLICA];
-  SMgmtWrapper  *pWrapper;
-  PutToQueueFp   putToWriteQFp;
-  PutToQueueFp   putToReadQFp;
-  SendReqFp      sendReqFp;
-  SendMnodeReqFp sendMnodeReqFp;
-  SendRspFp      sendRspFp;
+  int32_t  dnodeId;
+  int64_t  clusterId;
+  int8_t   replica;
+  int8_t   selfIndex;
+  SReplica replicas[TSDB_MAX_REPLICA];
+  SMsgCb   msgCb;
 } SMnodeOpt;
 
 /* ------------------------ SMnode ------------------------ */

include/dnode/qnode/qnode.h

@@ -16,13 +16,14 @@
 #ifndef _TD_QNODE_H_
 #define _TD_QNODE_H_
 
+#include "tmsgcb.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* ------------------------ TYPES EXPOSED ------------------------ */
-typedef struct SMgmtWrapper SMgmtWrapper;
-typedef struct SQnode       SQnode;
+typedef struct SQnode SQnode;
 
 typedef struct {
   int64_t numOfStartTask;
@@ -36,12 +37,7 @@ typedef struct {
 } SQnodeLoad;
 
 typedef struct {
-  int32_t        dnodeId;
-  int64_t        clusterId;
-  SMgmtWrapper  *pWrapper;
-  SendReqFp      sendReqFp;
-  SendMnodeReqFp sendMnodeReqFp;
-  SendRspFp      sendRspFp;
+  SMsgCb msgCb;
 } SQnodeOpt;
 
 /* ------------------------ SQnode ------------------------ */
@@ -74,10 +70,9 @@ int32_t qndGetLoad(SQnode *pQnode, SQnodeLoad *pLoad);
  *
  * @param pQnode The qnode object.
  * @param pMsg The request message
- * @param pRsp The response message
- * @return int32_t 0 for success, -1 for failure
  */
-int32_t qndProcessMsg(SQnode *pQnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
+int32_t qndProcessQueryMsg(SQnode *pQnode, SRpcMsg *pMsg);
+int32_t qndProcessFetchMsg(SQnode *pQnode, SRpcMsg *pMsg);
 
 #ifdef __cplusplus
 }

include/dnode/snode/snode.h

@@ -16,7 +16,7 @@
 #ifndef _TD_SNODE_H_
 #define _TD_SNODE_H_
 
-#include "tcommon.h"
+#include "tmsgcb.h"
 #include "tmsg.h"
 #include "trpc.h"
 
@@ -25,20 +25,14 @@ extern "C" {
 #endif
 
 /* ------------------------ TYPES EXPOSED ------------------------ */
-typedef struct SMgmtWrapper SMgmtWrapper;
-typedef struct SSnode       SSnode;
+typedef struct SSnode SSnode;
 
 typedef struct {
   int32_t reserved;
 } SSnodeLoad;
 
 typedef struct {
-  int32_t        dnodeId;
-  int64_t        clusterId;
-  SMgmtWrapper  *pWrapper;
-  SendReqFp      sendReqFp;
-  SendMnodeReqFp sendMnodeReqFp;
-  SendRspFp      sendRspFp;
+  SMsgCb msgCb;
 } SSnodeOpt;
 
 /* ------------------------ SSnode ------------------------ */

include/libs/catalog/catalog.h

@@ -103,16 +103,17 @@ int32_t catalogGetDBVgVersion(SCatalog* pCtg, const char* dbFName, int32_t* vers
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
  * @param pDBName (input, full db name)
- * @param forceUpdate (input, force update db vgroup info from mnode) 
  * @param pVgroupList (output, vgroup info list, element is SVgroupInfo, NEED to simply free the array by caller)
  * @return error code
  */
-int32_t catalogGetDBVgInfo(SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const char* pDBName, bool forceUpdate, SArray** pVgroupList);
+int32_t catalogGetDBVgInfo(SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const char* pDBName, SArray** pVgroupList);
 
 int32_t catalogUpdateDBVgInfo(SCatalog* pCatalog, const char* dbName, uint64_t dbId, SDBVgInfo* dbInfo);
 
 int32_t catalogRemoveDB(SCatalog* pCatalog, const char* dbName, uint64_t dbId);
 
+int32_t catalogRemoveTableMeta(SCatalog* pCtg, SName* pTableName);
+
 int32_t catalogRemoveStbMeta(SCatalog* pCtg, const char* dbFName, uint64_t dbId, const char* stbName, uint64_t suid);
 
 /**
@@ -120,7 +121,7 @@ int32_t catalogRemoveStbMeta(SCatalog* pCtg, const char* dbFName, uint64_t dbId,
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pTableName (input, table name, NOT including db name)
+ * @param pTableName (input, table name)
  * @param pTableMeta(output, table meta data, NEED to free it by calller)
  * @return error code
  */
@@ -131,7 +132,7 @@ int32_t catalogGetTableMeta(SCatalog* pCatalog, void * pTransporter, const SEpSe
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pTableName (input, table name, NOT including db name)
+ * @param pTableName (input, table name)
  * @param pTableMeta(output, table meta data, NEED to free it by calller)
  * @return error code
  */
@@ -140,28 +141,38 @@ int32_t catalogGetSTableMeta(SCatalog* pCatalog, void * pTransporter, const SEpS
 int32_t catalogUpdateSTableMeta(SCatalog* pCatalog, STableMetaRsp *rspMsg);
 
 
+/**
+ * Force refresh DB's local cached vgroup info. 
+ * @param pCtg (input, got with catalogGetHandle)
+ * @param pTrans (input, rpc object)
+ * @param pMgmtEps (input, mnode EPs)
+ * @param dbFName (input, db full name)
+ * @return error code
+ */
+int32_t catalogRefreshDBVgInfo(SCatalog* pCtg, void *pTrans, const SEpSet* pMgmtEps, const char* dbFName);
+
 /**
  * Force refresh a table's local cached meta data. 
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pTableName (input, table name, NOT including db name)
+ * @param pTableName (input, table name)
  * @param isSTable (input, is super table or not, 1:supposed to be stable, 0: supposed not to be stable, -1:not sure) 
  * @return error code
  */
-  int32_t catalogRefreshTableMeta(SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, int32_t isSTable);
+int32_t catalogRefreshTableMeta(SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, int32_t isSTable);
 
 /**
  * Force refresh a table's local cached meta data and get the new one. 
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pTableName (input, table name, NOT including db name)
+ * @param pTableName (input, table name)
  * @param pTableMeta(output, table meta data, NEED to free it by calller) 
  * @param isSTable (input, is super table or not, 1:supposed to be stable, 0: supposed not to be stable, -1:not sure) 
  * @return error code
  */
-  int32_t catalogRefreshGetTableMeta(SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta, int32_t isSTable);
+int32_t catalogRefreshGetTableMeta(SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta, int32_t isSTable);
 
 
 
@@ -170,7 +181,7 @@ int32_t catalogUpdateSTableMeta(SCatalog* pCatalog, STableMetaRsp *rspMsg);
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pTableName (input, table name, NOT including db name)
+ * @param pTableName (input, table name)
  * @param pVgroupList (output, vgroup info list, element is SVgroupInfo, NEED to simply free the array by caller)
  * @return error code
  */
@@ -181,7 +192,7 @@ int32_t catalogGetTableDistVgInfo(SCatalog* pCatalog, void *pTransporter, const
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pTableName (input, table name, NOT including db name)
+ * @param pTableName (input, table name)
  * @param vgInfo (output, vgroup info)
  * @return error code
  */

include/libs/executor/executor.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "tcommon.h"
+#include "query.h"
 
 typedef void* qTaskInfo_t;
 typedef void* DataSinkHandle;
@@ -30,23 +31,28 @@ struct SSubplan;
 typedef struct SReadHandle {
   void* reader;
   void* meta;
+  void* config;
 } SReadHandle;
 
- /**
-  * Create the exec task for streaming mode
-  * @param pMsg
-  * @param streamReadHandle
-  * @return
-  */
-qTaskInfo_t qCreateStreamExecTaskInfo(void *msg, void* streamReadHandle);
+#define STREAM_DATA_TYPE_SUBMIT_BLOCK 0x1
+#define STREAM_DATA_TYPE_SSDATA_BLOCK 0x2
+  
+/**
+ * Create the exec task for streaming mode
+ * @param pMsg
+ * @param streamReadHandle
+ * @return
+ */
+qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, void* streamReadHandle);
 
 /**
  * Set the input data block for the stream scan.
  * @param tinfo
  * @param input
+ * @param type
  * @return
  */
-int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input);
+int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type);
 
 /**
  * Update the table id list, add or remove.
@@ -58,16 +64,17 @@ int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input);
  */
 int32_t qUpdateQualifiedTableId(qTaskInfo_t tinfo, SArray* tableIdList, bool isAdd);
 
- /**
-  * Create the exec task object according to task json
-  * @param readHandle
-  * @param vgId
-  * @param pTaskInfoMsg
-  * @param pTaskInfo
-  * @param qId
-  * @return
-  */
-int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, struct SSubplan* pPlan, qTaskInfo_t* pTaskInfo, DataSinkHandle* handle);
+/**
+ * Create the exec task object according to task json
+ * @param readHandle
+ * @param vgId
+ * @param pTaskInfoMsg
+ * @param pTaskInfo
+ * @param qId
+ * @return
+ */
+int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, struct SSubplan* pPlan,
+                        qTaskInfo_t* pTaskInfo, DataSinkHandle* handle);
 
 /**
  * The main task execution function, including query on both table and multiple tables,
@@ -77,7 +84,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
  * @param handle
  * @return
  */
-int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t *useconds);
+int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds);
 
 /**
  * Retrieve the produced results information, if current query is not paused or completed,
@@ -140,7 +147,8 @@ int32_t qGetQualifiedTableIdList(void* pTableList, const char* tagCond, int32_t
  * @param numOfIndex
  * @return
  */
-//int32_t qCreateTableGroupByGroupExpr(SArray* pTableIdList, TSKEY skey, STableGroupInfo groupInfo, SColIndex* groupByIndex, int32_t numOfIndex);
+// int32_t qCreateTableGroupByGroupExpr(SArray* pTableIdList, TSKEY skey, STableGroupInfo groupInfo, SColIndex*
+// groupByIndex, int32_t numOfIndex);
 
 /**
  * Update the table id list of a given query.
@@ -163,19 +171,19 @@ void* qOpenTaskMgmt(int32_t vgId);
  * broadcast the close information and wait for all query stop.
  * @param pExecutor
  */
-void  qTaskMgmtNotifyClosing(void* pExecutor);
+void qTaskMgmtNotifyClosing(void* pExecutor);
 
 /**
  * Re-open the query handle management module when opening the vnode again.
  * @param pExecutor
  */
-void  qQueryMgmtReOpen(void *pExecutor);
+void qQueryMgmtReOpen(void* pExecutor);
 
 /**
  * Close query mgmt and clean up resources.
  * @param pExecutor
  */
-void  qCleanupTaskMgmt(void* pExecutor);
+void qCleanupTaskMgmt(void* pExecutor);
 
 /**
  * Add the query into the query mgmt object
@@ -184,7 +192,7 @@ void  qCleanupTaskMgmt(void* pExecutor);
  * @param qInfo
  * @return
  */
-void** qRegisterTask(void* pMgmt, uint64_t qId, void *qInfo);
+void** qRegisterTask(void* pMgmt, uint64_t qId, void* qInfo);
 
 /**
  * acquire the query handle according to the key from query mgmt object.

include/libs/function/function.h

@@ -163,7 +163,7 @@ typedef struct SInputColumnInfoData {
 typedef struct SqlFunctionCtx {
   SInputColumnInfoData input;
   SResultDataInfo      resDataInfo;
-  uint32_t             order;  // asc|desc
+  uint32_t             order;  // data block scanner order: asc|desc
   ////////////////////////////////////////////////////////////////
   int32_t          startRow;   // start row index
   int32_t          size;       // handled processed row number

include/libs/nodes/cmdnodes.h

@@ -179,7 +179,8 @@ typedef struct SAlterDnodeStmt {
 
 typedef struct SShowStmt {
   ENodeType type;
-  char dbName[TSDB_DB_NAME_LEN];
+  SNode* pDbName;        // SValueNode
+  SNode* pTbNamePattern; // SValueNode
 } SShowStmt;
 
 typedef enum EIndexType {

include/libs/nodes/nodes.h

@@ -78,7 +78,6 @@ typedef enum ENodeType {
   QUERY_NODE_CREATE_DATABASE_STMT,
   QUERY_NODE_DROP_DATABASE_STMT,
   QUERY_NODE_ALTER_DATABASE_STMT,
-  QUERY_NODE_SHOW_DATABASES_STMT, // temp
   QUERY_NODE_CREATE_TABLE_STMT,
   QUERY_NODE_CREATE_SUBTABLE_CLAUSE,
   QUERY_NODE_CREATE_MULTI_TABLE_STMT,
@@ -86,20 +85,13 @@ typedef enum ENodeType {
   QUERY_NODE_DROP_TABLE_STMT,
   QUERY_NODE_DROP_SUPER_TABLE_STMT,
   QUERY_NODE_ALTER_TABLE_STMT,
-  QUERY_NODE_SHOW_TABLES_STMT, // temp
-  QUERY_NODE_SHOW_STABLES_STMT,
   QUERY_NODE_CREATE_USER_STMT,
   QUERY_NODE_ALTER_USER_STMT,
   QUERY_NODE_DROP_USER_STMT,
-  QUERY_NODE_SHOW_USERS_STMT,
   QUERY_NODE_USE_DATABASE_STMT,
   QUERY_NODE_CREATE_DNODE_STMT,
   QUERY_NODE_DROP_DNODE_STMT,
   QUERY_NODE_ALTER_DNODE_STMT,
-  QUERY_NODE_SHOW_DNODES_STMT,
-  QUERY_NODE_SHOW_VGROUPS_STMT,
-  QUERY_NODE_SHOW_MNODES_STMT,
-  QUERY_NODE_SHOW_QNODES_STMT,
   QUERY_NODE_CREATE_INDEX_STMT,
   QUERY_NODE_DROP_INDEX_STMT,
   QUERY_NODE_CREATE_QNODE_STMT,
@@ -107,6 +99,18 @@ typedef enum ENodeType {
   QUERY_NODE_CREATE_TOPIC_STMT,
   QUERY_NODE_DROP_TOPIC_STMT,
   QUERY_NODE_ALTER_LOCAL_STMT,
+  QUERY_NODE_SHOW_DATABASES_STMT,
+  QUERY_NODE_SHOW_TABLES_STMT,
+  QUERY_NODE_SHOW_STABLES_STMT,
+  QUERY_NODE_SHOW_USERS_STMT,
+  QUERY_NODE_SHOW_DNODES_STMT,
+  QUERY_NODE_SHOW_VGROUPS_STMT,
+  QUERY_NODE_SHOW_MNODES_STMT,
+  QUERY_NODE_SHOW_MODULES_STMT,
+  QUERY_NODE_SHOW_QNODES_STMT,
+  QUERY_NODE_SHOW_FUNCTIONS_STMT,
+  QUERY_NODE_SHOW_INDEXES_STMT,
+  QUERY_NODE_SHOW_STREAMS_STMT,
 
   // logic plan node
   QUERY_NODE_LOGIC_PLAN_SCAN,

include/libs/nodes/plannodes.h

@@ -35,8 +35,7 @@ typedef struct SLogicNode {
 typedef enum EScanType {
   SCAN_TYPE_TAG,
   SCAN_TYPE_TABLE,
-  SCAN_TYPE_STABLE,
-  SCAN_TYPE_TOPIC,
+  SCAN_TYPE_SYSTEM_TABLE,
   SCAN_TYPE_STREAM
 } EScanType;
 
@@ -165,10 +164,14 @@ typedef struct SScanPhysiNode {
   SName tableName;
 } SScanPhysiNode;
 
-typedef SScanPhysiNode SSystemTableScanPhysiNode;
 typedef SScanPhysiNode STagScanPhysiNode;
 typedef SScanPhysiNode SStreamScanPhysiNode;
 
+typedef struct SSystemTableScanPhysiNode {
+  SScanPhysiNode scan;
+  SEpSet mgmtEpSet;
+} SSystemTableScanPhysiNode;
+
 typedef struct STableScanPhysiNode {
   SScanPhysiNode scan;
   uint8_t scanFlag;         // denotes reversed scan of data or not
@@ -244,6 +247,7 @@ typedef struct SSubplan {
   ESubplanType subplanType;
   int32_t msgType;      // message type for subplan, used to denote the send message type to vnode.
   int32_t level;        // the execution level of current subplan, starting from 0 in a top-down manner.
+  char dbFName[TSDB_DB_FNAME_LEN];
   SQueryNodeAddr execNode;    // for the scan/modify subplan, the optional execution node
   SQueryNodeStat execNodeStat; // only for scan subplan
   SNodeList* pChildren;    // the datasource subplan,from which to fetch the result

include/libs/nodes/querynodes.h

@@ -130,6 +130,7 @@ typedef struct SRealTableNode {
   STableNode table; // QUERY_NODE_REAL_TABLE
   struct STableMeta* pMeta;
   SVgroupsInfo* pVgroupList;
+  char useDbName[TSDB_DB_NAME_LEN];
 } SRealTableNode;
 
 typedef struct STempTableNode {

include/libs/parser/parser.h

@@ -52,7 +52,8 @@ typedef struct SQuery {
   SSchema* pResSchema;
   SCmdMsgInfo* pCmdMsg;
   int32_t msgType;
-  bool streamQuery;
+  SArray* pDbList;
+  SArray* pTableList;
 } SQuery;
 
 int32_t qParseQuerySql(SParseContext* pCxt, SQuery** pQuery);

include/libs/planner/planner.h

@@ -25,6 +25,7 @@ extern "C" {
 typedef struct SPlanContext {
   uint64_t queryId;
   int32_t acctId;
+  SEpSet mgmtEpSet;
   SNode* pAstRoot;
   bool topicQuery;
   bool streamQuery;

include/libs/qcom/query.h

@@ -25,7 +25,7 @@ extern "C" {
 #include "tlog.h"
 #include "tmsg.h"
 
-enum {
+typedef enum {
   JOB_TASK_STATUS_NULL = 0,
   JOB_TASK_STATUS_NOT_START = 1,
   JOB_TASK_STATUS_EXECUTING,
@@ -35,12 +35,12 @@ enum {
   JOB_TASK_STATUS_CANCELLING,
   JOB_TASK_STATUS_CANCELLED,
   JOB_TASK_STATUS_DROPPING,
-};
+} EJobTaskType;
 
-enum {
+typedef enum {
   TASK_TYPE_PERSISTENT = 1,
   TASK_TYPE_TEMP,
-};
+} ETaskType;
 
 typedef struct STableComInfo {
   uint8_t numOfTags;     // the number of tags in schema
@@ -169,6 +169,9 @@ const SSchema* tGetTbnameColumnSchema();
 bool           tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags);
 
 int32_t queryCreateTableMetaFromMsg(STableMetaRsp* msg, bool isSuperTable, STableMeta** pMeta);
+char *jobTaskStatusStr(int32_t status);
+
+SSchema createSchema(uint8_t type, int32_t bytes, int32_t colId, const char* name);
 
 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);
@@ -178,6 +181,15 @@ extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t
 #define SET_META_TYPE_TABLE(t)      (t) = META_TYPE_TABLE
 #define SET_META_TYPE_BOTH_TABLE(t) (t) = META_TYPE_BOTH_TABLE
 
+#define NEED_CLIENT_RM_TBLMETA_ERROR(_code) ((_code) == TSDB_CODE_TDB_INVALID_TABLE_ID || (_code) == TSDB_CODE_VND_TB_NOT_EXIST)
+#define NEED_CLIENT_REFRESH_VG_ERROR(_code) ((_code) == TSDB_CODE_VND_HASH_MISMATCH || (_code) == TSDB_CODE_VND_INVALID_VGROUP_ID)
+#define NEED_CLIENT_REFRESH_TBLMETA_ERROR(_code) ((_code) == TSDB_CODE_TDB_TABLE_RECREATED)
+#define NEED_CLIENT_HANDLE_ERROR(_code) (NEED_CLIENT_RM_TBLMETA_ERROR(_code) || NEED_CLIENT_REFRESH_VG_ERROR(_code) || NEED_CLIENT_REFRESH_TBLMETA_ERROR(_code))
+
+#define NEED_SCHEDULER_RETRY_ERROR(_code) ((_code) == TSDB_CODE_RPC_REDIRECT || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL)
+
+#define REQUEST_MAX_TRY_TIMES 5
+
 #define qFatal(...)                                                     \
   do {                                                                  \
     if (qDebugFlag & DEBUG_FATAL) {                                     \

include/libs/qworker/qworker.h

@@ -20,6 +20,7 @@
 extern "C" {
 #endif
 
+#include "tmsgcb.h"
 #include "trpc.h"
 
 
@@ -48,11 +49,7 @@ typedef struct {
   uint64_t numOfErrors;
 } SQWorkerStat;
 
-typedef int32_t (*putReqToQueryQFp)(void *, struct SRpcMsg *);
-typedef int32_t (*sendReqFp)(void *, struct SEpSet *, struct SRpcMsg *);
-
-int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, SQWorkerCfg *cfg, void **qWorkerMgmt, void *nodeObj,
-                    putReqToQueryQFp fp1, sendReqFp fp2);
+int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, SQWorkerCfg *cfg, void **qWorkerMgmt, const SMsgCb *pMsgCb);
 
 int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg);
 

include/libs/scheduler/scheduler.h

@@ -52,10 +52,10 @@ typedef struct SQueryProfileSummary {
 } SQueryProfileSummary;
 
 typedef struct SQueryResult {
-  int32_t  code;
-  uint64_t numOfRows;
-  int32_t  msgSize;
-  char    *msg;
+  int32_t         code;
+  uint64_t        numOfRows;
+  int32_t         msgSize;
+  char           *msg;
 } SQueryResult;
 
 typedef struct STaskInfo {

include/os/osDir.h

@@ -17,6 +17,7 @@
 #define _TD_OS_DIR_H_
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define opendir OPENDIR_FUNC_TAOS_FORBID
     #define readdir READDIR_FUNC_TAOS_FORBID

include/os/osFile.h

@@ -23,6 +23,7 @@ extern "C" {
 #include "osSocket.h"
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following sectio
 #ifndef ALLOW_FORBID_FUNC
     #define open OPEN_FUNC_TAOS_FORBID
     #define fopen FOPEN_FUNC_TAOS_FORBID

include/os/osLocale.h

@@ -23,6 +23,7 @@ extern "C" {
 #endif
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define setlocale SETLOCALE_FUNC_TAOS_FORBID
 #endif

include/os/osRand.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define rand RAND_FUNC_TAOS_FORBID
     #define srand SRAND_FUNC_TAOS_FORBID

include/os/osSleep.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define Sleep SLEEP_FUNC_TAOS_FORBID
     #define sleep SLEEP_FUNC_TAOS_FORBID

include/os/osSocket.h

@@ -17,6 +17,7 @@
 #define _TD_OS_SOCKET_H_
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define socket SOCKET_FUNC_TAOS_FORBID
     #define bind   BIND_FUNC_TAOS_FORBID
@@ -52,9 +53,6 @@ extern "C" {
 
 #if (defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)) 
   #define htobe64 htonll
-  #if defined(_TD_GO_DLL_)
-    uint64_t htonll(uint64_t val);
-  #endif
 #endif
 
 #if defined(_TD_DARWIN_64)

include/os/osString.h

@@ -24,6 +24,7 @@ typedef wchar_t TdWchar;
 typedef int32_t TdUcs4;
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define iconv_open ICONV_OPEN_FUNC_TAOS_FORBID
     #define iconv_close ICONV_CLOSE_FUNC_TAOS_FORBID

include/os/osSystem.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define popen POPEN_FUNC_TAOS_FORBID
     #define pclose PCLOSE_FUNC_TAOS_FORBID
@@ -28,7 +29,6 @@ extern "C" {
     #define tcgetattr TCGETATTR_FUNC_TAOS_FORBID
 #endif
 
-int32_t taosSystem(const char *cmd, char *buf, int32_t bufSize);
 void* taosLoadDll(const char* filename);
 void* taosLoadSym(void* handle, char* name);
 void  taosCloseDll(void* handle);

include/os/osThread.h

@@ -37,6 +37,7 @@ typedef pthread_condattr_t TdThreadCondAttr;
 #define taosThreadCleanupPop pthread_cleanup_pop
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define pthread_t PTHREAD_T_TYPE_TAOS_FORBID
     #define pthread_spinlock_t PTHREAD_SPINLOCK_T_TYPE_TAOS_FORBID

include/os/osTime.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define strptime STRPTIME_FUNC_TAOS_FORBID
     #define gettimeofday GETTIMEOFDAY_FUNC_TAOS_FORBID
@@ -33,11 +34,7 @@ extern "C" {
 
   #define CLOCK_REALTIME 	0
 
-  #ifdef _TD_GO_DLL_
-    #define MILLISECOND_PER_SECOND (1000LL)
-  #else
-    #define MILLISECOND_PER_SECOND (1000i64)
-  #endif
+  #define MILLISECOND_PER_SECOND (1000i64)
 #else
   #define MILLISECOND_PER_SECOND ((int64_t)1000L)
 #endif

include/os/osTimer.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define timer_create TIMER_CREATE_FUNC_TAOS_FORBID
     #define timer_settime TIMER_SETTIME_FUNC_TAOS_FORBID

include/os/osTimezone.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 // If the error is in a third-party library, place this header file under the third-party library header file.
+// When you want to use this feature, you should find or add the same function in the following section.
 #ifndef ALLOW_FORBID_FUNC
     #define tzset TZSET_FUNC_TAOS_FORBID
 #endif

include/util/taoserror.h

@@ -309,6 +309,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_VND_IS_SYNCING                TAOS_DEF_ERROR_CODE(0, 0x0513)
 #define TSDB_CODE_VND_INVALID_TSDB_STATE        TAOS_DEF_ERROR_CODE(0, 0x0514)
 #define TSDB_CODE_VND_TB_NOT_EXIST              TAOS_DEF_ERROR_CODE(0, 0x0515)
+#define TSDB_CODE_VND_HASH_MISMATCH             TAOS_DEF_ERROR_CODE(0, 0x0516)
 
 // tsdb
 #define TSDB_CODE_TDB_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0600)
@@ -334,8 +335,9 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_TDB_MESSED_MSG                TAOS_DEF_ERROR_CODE(0, 0x0614)
 #define TSDB_CODE_TDB_IVLD_TAG_VAL              TAOS_DEF_ERROR_CODE(0, 0x0615)
 #define TSDB_CODE_TDB_NO_CACHE_LAST_ROW         TAOS_DEF_ERROR_CODE(0, 0x0616)
-#define TSDB_CODE_TDB_NO_SMA_INDEX_IN_META      TAOS_DEF_ERROR_CODE(0, 0x0617)
-#define TSDB_CODE_TDB_TDB_ENV_OPEN_ERROR        TAOS_DEF_ERROR_CODE(0, 0x0618)
+#define TSDB_CODE_TDB_TABLE_RECREATED           TAOS_DEF_ERROR_CODE(0, 0x0617)
+#define TSDB_CODE_TDB_NO_SMA_INDEX_IN_META      TAOS_DEF_ERROR_CODE(0, 0x0618)
+#define TSDB_CODE_TDB_TDB_ENV_OPEN_ERROR        TAOS_DEF_ERROR_CODE(0, 0x0619)
 
 // query
 #define TSDB_CODE_QRY_INVALID_QHANDLE           TAOS_DEF_ERROR_CODE(0, 0x0700)
@@ -437,10 +439,12 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_CTG_SYS_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x2404)
 #define TSDB_CODE_CTG_DB_DROPPED                TAOS_DEF_ERROR_CODE(0, 0x2405)
 #define TSDB_CODE_CTG_OUT_OF_SERVICE            TAOS_DEF_ERROR_CODE(0, 0x2406)
+#define TSDB_CODE_CTG_VG_META_MISMATCH          TAOS_DEF_ERROR_CODE(0, 0x2407)
 
-//scheduler
+//scheduler&qworker
 #define TSDB_CODE_SCH_STATUS_ERROR              TAOS_DEF_ERROR_CODE(0, 0x2501)
 #define TSDB_CODE_SCH_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x2502)
+#define TSDB_CODE_QW_MSG_ERROR                  TAOS_DEF_ERROR_CODE(0, 0x2503)
 
 //parser
 #define TSDB_CODE_PAR_SYNTAX_ERROR              TAOS_DEF_ERROR_CODE(0, 0x2600)

include/util/tdef.h

@@ -99,7 +99,7 @@ extern const int32_t TYPE_BYTES[15];
 #define TSDB_INS_TABLE_MNODES                 "mnodes"
 #define TSDB_INS_TABLE_MODULES                "modules"
 #define TSDB_INS_TABLE_QNODES                 "qnodes"
-#define TSDB_INS_TABLE_USER_DATABASE          "user_database"
+#define TSDB_INS_TABLE_USER_DATABASES         "user_databases"
 #define TSDB_INS_TABLE_USER_FUNCTIONS         "user_functions"
 #define TSDB_INS_TABLE_USER_INDEXES           "user_indexes"
 #define TSDB_INS_TABLE_USER_STABLES           "user_stables"

include/util/thash.h

@@ -86,7 +86,7 @@ int32_t taosHashGetSize(const SHashObj *pHashObj);
  * @param size
  * @return
  */
-int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *data, size_t size);
+int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const void *data, size_t size);
 
 /**
  * return the payload data with the specified key

include/util/tqueue.h

@@ -42,8 +42,14 @@ shall be used to set up the protection.
 typedef struct STaosQueue STaosQueue;
 typedef struct STaosQset  STaosQset;
 typedef struct STaosQall  STaosQall;
-typedef void (*FItem)(void *ahandle, void *pItem);
-typedef void (*FItems)(void *ahandle, STaosQall *qall, int32_t numOfItems);
+typedef struct {
+  void   *ahandle;
+  int32_t workerId;
+  int32_t threadNum;
+} SQueueInfo;
+
+typedef void (*FItem)(SQueueInfo *pInfo, void *pItem);
+typedef void (*FItems)(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfItems);
 
 STaosQueue *taosOpenQueue();
 void        taosCloseQueue(STaosQueue *queue);
@@ -70,10 +76,7 @@ int32_t    taosGetQueueNumber(STaosQset *qset);
 
 int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, void **ahandle, FItem *itemFp);
 int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, void **ahandle, FItems *itemsFp);
-
-int32_t taosReadQitemFromQsetByThread(STaosQset *qset, void **ppItem, void **ahandle, FItem *itemFp, int32_t threadId);
 void    taosResetQsetThread(STaosQset *qset, void *pItem);
-
 int32_t taosGetQueueItemsNumber(STaosQueue *queue);
 int32_t taosGetQsetItemsNumber(STaosQset *qset);
 

include/util/tworker.h

@@ -27,33 +27,34 @@ typedef struct SWWorkerPool SWWorkerPool;
 
 typedef struct SQWorker {
   int32_t       id;      // worker ID
-  TdThread     thread;  // thread
+  TdThread      thread;  // thread
   SQWorkerPool *pool;
-} SQWorker, SFWorker;
+} SQWorker;
 
 typedef struct SQWorkerPool {
-  int32_t         max;  // max number of workers
-  int32_t         min;  // min number of workers
-  int32_t         num;  // current number of workers
-  STaosQset      *qset;
-  const char     *name;
-  SQWorker       *workers;
+  int32_t       max;  // max number of workers
+  int32_t       min;  // min number of workers
+  int32_t       num;  // current number of workers
+  STaosQset    *qset;
+  const char   *name;
+  SQWorker     *workers;
   TdThreadMutex mutex;
-} SQWorkerPool, SFWorkerPool;
+} SQWorkerPool;
 
 typedef struct SWWorker {
   int32_t       id;      // worker id
-  TdThread     thread;  // thread
+  TdThread      thread;  // thread
   STaosQall    *qall;
   STaosQset    *qset;  // queue set
   SWWorkerPool *pool;
 } SWWorker;
 
 typedef struct SWWorkerPool {
-  int32_t         max;     // max number of workers
-  int32_t         nextId;  // from 0 to max-1, cyclic
-  const char     *name;
-  SWWorker       *workers;
+  int32_t       max;  // max number of workers
+  int32_t       num;
+  int32_t       nextId;  // from 0 to max-1, cyclic
+  const char   *name;
+  SWWorker     *workers;
   TdThreadMutex mutex;
 } SWWorkerPool;
 
@@ -62,16 +63,43 @@ void        tQWorkerCleanup(SQWorkerPool *pool);
 STaosQueue *tQWorkerAllocQueue(SQWorkerPool *pool, void *ahandle, FItem fp);
 void        tQWorkerFreeQueue(SQWorkerPool *pool, STaosQueue *queue);
 
-int32_t     tFWorkerInit(SFWorkerPool *pool);
-void        tFWorkerCleanup(SFWorkerPool *pool);
-STaosQueue *tFWorkerAllocQueue(SFWorkerPool *pool, void *ahandle, FItem fp);
-void        tFWorkerFreeQueue(SFWorkerPool *pool, STaosQueue *queue);
-
 int32_t     tWWorkerInit(SWWorkerPool *pool);
 void        tWWorkerCleanup(SWWorkerPool *pool);
 STaosQueue *tWWorkerAllocQueue(SWWorkerPool *pool, void *ahandle, FItems fp);
 void        tWWorkerFreeQueue(SWWorkerPool *pool, STaosQueue *queue);
 
+typedef struct {
+  const char *name;
+  int32_t     minNum;
+  int32_t     maxNum;
+  FItem       fp;
+  void       *param;
+} SSingleWorkerCfg;
+
+typedef struct {
+  const char  *name;
+  STaosQueue  *queue;
+  SQWorkerPool pool;
+} SSingleWorker;
+
+typedef struct {
+  const char *name;
+  int32_t     maxNum;
+  FItems      fp;
+  void       *param;
+} SMultiWorkerCfg;
+
+typedef struct {
+  const char  *name;
+  STaosQueue  *queue;
+  SWWorkerPool pool;
+} SMultiWorker;
+
+int32_t tSingleWorkerInit(SSingleWorker *pWorker, const SSingleWorkerCfg *pCfg);
+void    tSingleWorkerCleanup(SSingleWorker *pWorker);
+int32_t tMultiWorkerInit(SMultiWorker *pWorker, const SMultiWorkerCfg *pCfg);
+void    tMultiWorkerCleanup(SMultiWorker *pWorker);
+
 #ifdef __cplusplus
 }
 #endif

source/client/inc/clientInt.h

@@ -37,9 +37,8 @@ extern "C" {
 
 #define CHECK_CODE_GOTO(expr, label) \
   do {                               \
-    int32_t code = expr;             \
+    code = expr;                     \
     if (TSDB_CODE_SUCCESS != code) { \
-      terrno = code;                 \
       goto label;                    \
     }                                \
   } while (0)
@@ -142,18 +141,27 @@ typedef struct STscObj {
   SAppInstInfo*   pAppInfo;
 } STscObj;
 
+typedef struct SResultColumn {
+  union {
+    char*       nullbitmap;  // bitmap, one bit for each item in the list
+    int32_t*    offset;
+  };
+  char*         pData;
+} SResultColumn;
+
 typedef struct SReqResultInfo {
-  const char* pRspMsg;
-  const char* pData;
-  TAOS_FIELD* fields;
-  uint32_t    numOfCols;
-  int32_t*    length;
-  TAOS_ROW    row;
-  char**      pCol;
-  uint32_t    numOfRows;
-  uint64_t    totalRows;
-  uint32_t    current;
-  bool        completed;
+  const char*    pRspMsg;
+  const char*    pData;
+  TAOS_FIELD*    fields;
+  uint32_t       numOfCols;
+  int32_t*       length;
+  TAOS_ROW       row;
+  SResultColumn* pCol;
+  uint32_t       numOfRows;
+  uint64_t       totalRows;
+  uint32_t       current;
+  bool           completed;
+  int32_t        payloadLen;
 } SReqResultInfo;
 
 typedef struct SShowReqInfo {
@@ -186,6 +194,8 @@ typedef struct SRequestObj {
   char*                msgBuf;
   void*                pInfo;  // sql parse info, generated by parser module
   int32_t              code;
+  SArray*              dbList;
+  SArray*              tableList;
   SQueryExecMetric     metric;
   SRequestSendRecvBody body;
 } SRequestObj;
@@ -226,7 +236,7 @@ TAOS* taos_connect_internal(const char* ip, const char* user, const char* pass,
 
 void* doFetchRow(SRequestObj* pRequest);
 
-void setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows);
+int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows);
 
 int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj** pRequest);
 

source/client/src/clientEnv.c

@@ -48,8 +48,8 @@ static void registerRequest(SRequestObj *pRequest) {
   if (pTscObj->pAppInfo) {
     SInstanceSummary *pSummary = &pTscObj->pAppInfo->summary;
 
-    int32_t total = atomic_add_fetch_32(&pSummary->totalRequests, 1);
-    int32_t currentInst = atomic_add_fetch_32(&pSummary->currentRequests, 1);
+    int32_t total = atomic_add_fetch_64(&pSummary->totalRequests, 1);
+    int32_t currentInst = atomic_add_fetch_64(&pSummary->currentRequests, 1);
     tscDebug("0x%" PRIx64 " new Request from connObj:0x%" PRIx64
              ", current:%d, app current:%d, total:%d, reqId:0x%" PRIx64,
              pRequest->self, pRequest->pTscObj->id, num, currentInst, total, pRequest->requestId);
@@ -62,7 +62,7 @@ static void deregisterRequest(SRequestObj *pRequest) {
   STscObj *         pTscObj = pRequest->pTscObj;
   SInstanceSummary *pActivity = &pTscObj->pAppInfo->summary;
 
-  int32_t currentInst = atomic_sub_fetch_32(&pActivity->currentRequests, 1);
+  int32_t currentInst = atomic_sub_fetch_64(&pActivity->currentRequests, 1);
   int32_t num = atomic_sub_fetch_32(&pTscObj->numOfReqs, 1);
 
   int64_t duration = taosGetTimestampMs() - pRequest->metric.start;

source/client/src/clientImpl.c

@@ -12,7 +12,7 @@
 static int32_t       initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSet);
 static SMsgSendInfo* buildConnectMsg(SRequestObj* pRequest);
 static void          destroySendMsgInfo(SMsgSendInfo* pMsgBody);
-static void          setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp);
+static int32_t       setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp);
 
 static bool stringLengthCheck(const char* str, size_t maxsize) {
   if (str == NULL) {
@@ -159,8 +159,12 @@ int32_t parseSql(SRequestObj* pRequest, bool topicQuery, SQuery** pQuery) {
   }
 
   code = qParseQuerySql(&cxt, pQuery);
-  if (TSDB_CODE_SUCCESS == code && ((*pQuery)->haveResultSet)) {
-    setResSchemaInfo(&pRequest->body.resInfo, (*pQuery)->pResSchema, (*pQuery)->numOfResCols);
+  if (TSDB_CODE_SUCCESS == code) {
+    if ((*pQuery)->haveResultSet) {
+      setResSchemaInfo(&pRequest->body.resInfo, (*pQuery)->pResSchema, (*pQuery)->numOfResCols);
+    }
+    TSWAP(pRequest->dbList, (*pQuery)->pDbList, SArray*);
+    TSWAP(pRequest->tableList, (*pQuery)->pTableList, SArray*);
   }
 
   return code;
@@ -191,8 +195,17 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQuery* pQuery) {
 
 int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArray* pNodeList) {
   pRequest->type = pQuery->msgType;
-  SPlanContext cxt = { .queryId = pRequest->requestId, .pAstRoot = pQuery->pRoot, .acctId = pRequest->pTscObj->acctId };
-  return qCreateQueryPlan(&cxt, pPlan, pNodeList);
+  SPlanContext cxt = {
+    .queryId = pRequest->requestId,
+    .acctId = pRequest->pTscObj->acctId,
+    .mgmtEpSet = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp),
+    .pAstRoot = pQuery->pRoot
+  };
+  int32_t  code = qCreateQueryPlan(&cxt, pPlan, pNodeList);
+  if (code != 0) {
+    return code;
+  }
+  return code;
 }
 
 void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols) {
@@ -219,6 +232,7 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
     }
 
     pRequest->code = code;
+    terrno = code;
     return pRequest->code;
   }
 
@@ -231,22 +245,16 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryPlan* pDag, SArray* pNodeList
   }
 
   pRequest->code = res.code;
+  terrno = res.code;  
   return pRequest->code;
 }
 
-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) {
-    tscError("sql string exceeds max length:%d", TSDB_MAX_ALLOWED_SQL_LEN);
-    terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
-    return NULL;
-  }
-
+SRequestObj* execQueryImpl(STscObj* pTscObj, const char* sql, int sqlLen) {
   SRequestObj* pRequest = NULL;
   SQuery* pQuery = NULL;
+  int32_t code = 0;
   SArray* pNodeList = taosArrayInit(4, sizeof(struct SQueryNodeAddr));
 
-  terrno = TSDB_CODE_SUCCESS;
   CHECK_CODE_GOTO(buildRequest(pTscObj, sql, sqlLen, &pRequest), _return);
   CHECK_CODE_GOTO(parseSql(pRequest, false, &pQuery), _return);
 
@@ -255,19 +263,89 @@ TAOS_RES* taos_query_l(TAOS* taos, const char* sql, int sqlLen) {
   } else {
     CHECK_CODE_GOTO(getPlan(pRequest, pQuery, &pRequest->body.pDag, pNodeList), _return);
     CHECK_CODE_GOTO(scheduleQuery(pRequest, pRequest->body.pDag, pNodeList), _return);
-    pRequest->code = terrno;
   }
 
 _return:
   taosArrayDestroy(pNodeList);
   qDestroyQuery(pQuery);
-  if (NULL != pRequest && TSDB_CODE_SUCCESS != terrno) {
+  if (NULL != pRequest && TSDB_CODE_SUCCESS != code) {
     pRequest->code = terrno;
   }
 
   return pRequest;
 }
 
+int32_t refreshMeta(STscObj* pTscObj, SRequestObj* pRequest) {
+  SCatalog *pCatalog = NULL;
+  int32_t code = 0;
+  int32_t dbNum = taosArrayGetSize(pRequest->dbList);
+  int32_t tblNum = taosArrayGetSize(pRequest->tableList);
+
+  if (dbNum <= 0 && tblNum <= 0) {
+    return TSDB_CODE_QRY_APP_ERROR;
+  }
+  
+  code = catalogGetHandle(pTscObj->pAppInfo->clusterId, &pCatalog);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  SEpSet epset = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
+
+  for (int32_t i = 0; i < dbNum; ++i) {
+    char *dbFName = taosArrayGet(pRequest->dbList, i);
+    
+    code = catalogRefreshDBVgInfo(pCatalog, pTscObj->pAppInfo->pTransporter, &epset, dbFName);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+  }
+
+  for (int32_t i = 0; i < tblNum; ++i) {
+    SName *tableName = taosArrayGet(pRequest->tableList, i);
+
+    code = catalogRefreshTableMeta(pCatalog, pTscObj->pAppInfo->pTransporter, &epset, tableName, -1);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+  }
+
+  return code;
+}
+
+
+SRequestObj* execQuery(STscObj* pTscObj, const char* sql, int sqlLen) {
+  SRequestObj* pRequest = NULL;
+  int32_t retryNum = 0;
+  int32_t code = 0;
+
+  while (retryNum++ < REQUEST_MAX_TRY_TIMES) {
+    pRequest = execQueryImpl(pTscObj, sql, sqlLen);
+    if (TSDB_CODE_SUCCESS == pRequest->code || !NEED_CLIENT_HANDLE_ERROR(pRequest->code)) {
+      break;
+    }
+
+    code = refreshMeta(pTscObj, pRequest);
+    if (code) {
+      pRequest->code = code;
+      break;
+    }
+  }
+  
+  return pRequest;
+}
+
+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) {
+    tscError("sql string exceeds max length:%d", TSDB_MAX_ALLOWED_SQL_LEN);
+    terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
+    return NULL;
+  }
+
+  return execQuery(pTscObj, sql, sqlLen);
+}
+
 int initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSet) {
   pEpSet->version = 0;
 
@@ -384,7 +462,7 @@ static void destroySendMsgInfo(SMsgSendInfo* pMsgBody) {
   tfree(pMsgBody);
 }
 bool persistConnForSpecificMsg(void* parenct, tmsg_t msgType) {
-  return msgType == TDMT_VND_QUERY_RSP || msgType == TDMT_VND_FETCH_RSP || msgType == TDMT_VND_RES_READY_RSP;
+  return msgType == TDMT_VND_QUERY_RSP || msgType == TDMT_VND_FETCH_RSP || msgType == TDMT_VND_RES_READY_RSP || msgType == TDMT_VND_QUERY_HEARTBEAT_RSP;
 }
 void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
   SMsgSendInfo* pSendInfo = (SMsgSendInfo*)pMsg->ahandle;
@@ -395,7 +473,6 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
     assert(pRequest->self == pSendInfo->requestObjRefId);
 
     pRequest->metric.rsp = taosGetTimestampMs();
-    pRequest->code = pMsg->code;
 
     STscObj* pTscObj = pRequest->pTscObj;
     if (pEpSet) {
@@ -479,13 +556,16 @@ void* doFetchRow(SRequestObj* pRequest) {
       }
 
       SReqResultInfo* pResInfo = &pRequest->body.resInfo;
-      int32_t         code = schedulerFetchRows(pRequest->body.queryJob, (void**)&pResInfo->pData);
-      if (code != TSDB_CODE_SUCCESS) {
-        pRequest->code = code;
+      pRequest->code = schedulerFetchRows(pRequest->body.queryJob, (void**)&pResInfo->pData);
+      if (pRequest->code != TSDB_CODE_SUCCESS) {
+        return NULL;
+      }
+
+      pRequest->code = setQueryResultFromRsp(&pRequest->body.resInfo, (SRetrieveTableRsp*)pResInfo->pData);
+      if (pRequest->code != TSDB_CODE_SUCCESS) {
         return NULL;
       }
 
-      setQueryResultFromRsp(&pRequest->body.resInfo, (SRetrieveTableRsp*)pResInfo->pData);
       tscDebug("0x%" PRIx64 " fetch results, numOfRows:%d total Rows:%" PRId64 ", complete:%d, reqId:0x%" PRIx64,
                pRequest->self, pResInfo->numOfRows, pResInfo->totalRows, pResInfo->completed, pRequest->requestId);
 
@@ -552,10 +632,23 @@ void* doFetchRow(SRequestObj* pRequest) {
 _return:
 
   for (int32_t i = 0; i < pResultInfo->numOfCols; ++i) {
-    pResultInfo->row[i] = pResultInfo->pCol[i] + pResultInfo->fields[i].bytes * pResultInfo->current;
+    SResultColumn* pCol = &pResultInfo->pCol[i];
+
     if (IS_VAR_DATA_TYPE(pResultInfo->fields[i].type)) {
-      pResultInfo->length[i] = varDataLen(pResultInfo->row[i]);
-      pResultInfo->row[i] = varDataVal(pResultInfo->row[i]);
+      if (pCol->offset[pResultInfo->current] != -1) {
+        char* pStart = pResultInfo->pCol[i].offset[pResultInfo->current] + pResultInfo->pCol[i].pData;
+
+        pResultInfo->length[i] = varDataLen(pStart);
+        pResultInfo->row[i] = varDataVal(pStart);
+      } else {
+        pResultInfo->row[i] = NULL;
+      }
+    } else {
+      if (!colDataIsNull_f(pCol->nullbitmap, pResultInfo->current)) {
+        pResultInfo->row[i] = pResultInfo->pCol[i].pData + pResultInfo->fields[i].bytes * pResultInfo->current;
+      } else {
+        pResultInfo->row[i] = NULL;
+      }
     }
   }
 
@@ -563,30 +656,52 @@ _return:
   return pResultInfo->row;
 }
 
-static void doPrepareResPtr(SReqResultInfo* pResInfo) {
+static int32_t doPrepareResPtr(SReqResultInfo* pResInfo) {
   if (pResInfo->row == NULL) {
-    pResInfo->row = calloc(pResInfo->numOfCols, POINTER_BYTES);
-    pResInfo->pCol = calloc(pResInfo->numOfCols, POINTER_BYTES);
+    pResInfo->row    = calloc(pResInfo->numOfCols, POINTER_BYTES);
+    pResInfo->pCol   = calloc(pResInfo->numOfCols, sizeof(SResultColumn));
     pResInfo->length = calloc(pResInfo->numOfCols, sizeof(int32_t));
   }
+
+  if (pResInfo->row == NULL || pResInfo->pCol == NULL || pResInfo->length == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  } else {
+    return TSDB_CODE_SUCCESS;
+  }
 }
 
-void setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows) {
+int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows) {
   assert(numOfCols > 0 && pFields != NULL && pResultInfo != NULL);
   if (numOfRows == 0) {
-    return;
+    return TSDB_CODE_SUCCESS;
   }
 
-  // todo check for the failure of malloc
-  doPrepareResPtr(pResultInfo);
+  int32_t code = doPrepareResPtr(pResultInfo);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
 
-  int32_t offset = 0;
+  int32_t* colLength = (int32_t*)pResultInfo->pData;
+  char*    pStart = ((char*)pResultInfo->pData) + sizeof(int32_t) * numOfCols;
   for (int32_t i = 0; i < numOfCols; ++i) {
+    colLength[i] = htonl(colLength[i]);
+
+    if (IS_VAR_DATA_TYPE(pResultInfo->fields[i].type)) {
+      pResultInfo->pCol[i].offset = (int32_t*)pStart;
+      pStart += numOfRows * sizeof(int32_t);
+    } else {
+      pResultInfo->pCol[i].nullbitmap = pStart;
+      pStart += BitmapLen(pResultInfo->numOfRows);
+    }
+
+    pResultInfo->pCol[i].pData = pStart;
     pResultInfo->length[i] = pResultInfo->fields[i].bytes;
-    pResultInfo->row[i] = (char*)(pResultInfo->pData + offset * pResultInfo->numOfRows);
-    pResultInfo->pCol[i] = pResultInfo->row[i];
-    offset += pResultInfo->fields[i].bytes;
+    pResultInfo->row[i] = pResultInfo->pCol[i].pData;
+
+    pStart += colLength[i];
   }
+
+  return TSDB_CODE_SUCCESS;
 }
 
 char* getDbOfConnection(STscObj* pObj) {
@@ -608,15 +723,17 @@ void setConnectionDB(STscObj* pTscObj, const char* db) {
   taosThreadMutexUnlock(&pTscObj->mutex);
 }
 
-void setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp) {
+int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp) {
   assert(pResultInfo != NULL && pRsp != NULL);
 
-  pResultInfo->pRspMsg = (const char*)pRsp;
-  pResultInfo->pData = (void*)pRsp->data;
-  pResultInfo->numOfRows = htonl(pRsp->numOfRows);
-  pResultInfo->current = 0;
-  pResultInfo->completed = (pRsp->completed == 1);
+  pResultInfo->pRspMsg    = (const char*)pRsp;
+  pResultInfo->pData      = (void*)pRsp->data;
+  pResultInfo->numOfRows  = htonl(pRsp->numOfRows);
+  pResultInfo->current    = 0;
+  pResultInfo->completed  = (pRsp->completed == 1);
+  pResultInfo->payloadLen = htonl(pRsp->compLen);
 
+  // TODO handle the compressed case
   pResultInfo->totalRows += pResultInfo->numOfRows;
-  setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows);
+  return setResultDataPtr(pResultInfo, pResultInfo->fields, pResultInfo->numOfCols, pResultInfo->numOfRows);
 }

source/client/src/clientMsgHandler.c

@@ -238,7 +238,11 @@ int32_t processCreateDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   // todo rsp with the vnode id list
   SRequestObj* pRequest = param;
   free(pMsg->pData);
+  if (code != TSDB_CODE_SUCCESS) {
+    setErrno(pRequest, code);
+  }
   tsem_post(&pRequest->body.rspSem);
+  return code;
 }
 
 int32_t processUseDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {

source/client/src/tmq.c

@@ -471,8 +471,8 @@ TAOS_RES* tmq_create_stream(TAOS* taos, const char* streamName, const char* tbNa
   }
   sqlLen = strlen(sql);
 
-  if (strlen(streamName) >= TSDB_TABLE_NAME_LEN) {
-    tscError("stream name too long, max length:%d", TSDB_TABLE_NAME_LEN - 1);
+  if (strlen(tbName) >= TSDB_TABLE_NAME_LEN) {
+    tscError("output tb name too long, max length:%d", TSDB_TABLE_NAME_LEN - 1);
     terrno = TSDB_CODE_TSC_INVALID_INPUT;
     goto _return;
   }
@@ -485,6 +485,7 @@ TAOS_RES* tmq_create_stream(TAOS* taos, const char* streamName, const char* tbNa
 
   tscDebug("start to create stream: %s", streamName);
 
+  int32_t code = 0;
   CHECK_CODE_GOTO(buildRequest(pTscObj, sql, sqlLen, &pRequest), _return);
   CHECK_CODE_GOTO(parseSql(pRequest, false, &pQueryNode), _return);
 
@@ -571,6 +572,7 @@ TAOS_RES* tmq_create_topic(TAOS* taos, const char* topicName, const char* sql, i
 
   tscDebug("start to create topic: %s", topicName);
 
+  int32_t code = TSDB_CODE_SUCCESS;
   CHECK_CODE_GOTO(buildRequest(pTscObj, sql, sqlLen, &pRequest), _return);
   CHECK_CODE_GOTO(parseSql(pRequest, true, &pQueryNode), _return);
 
@@ -681,7 +683,7 @@ static char* formatTimestamp(char* buf, int64_t val, int precision) {
 
 int32_t tmqGetSkipLogNum(tmq_message_t* tmq_message) {
   if (tmq_message == NULL) return 0;
-  SMqPollRsp* pRsp = &tmq_message->consumeRsp;
+  SMqPollRsp* pRsp = &tmq_message->msg;
   return pRsp->skipLogNum;
 }
 
@@ -690,15 +692,15 @@ void tmqShowMsg(tmq_message_t* tmq_message) {
 
   static bool noPrintSchema;
   char        pBuf[128];
-  SMqPollRsp* pRsp = &tmq_message->consumeRsp;
-  int32_t     colNum = pRsp->schemas->nCols;
+  SMqPollRsp* pRsp = &tmq_message->msg;
+  int32_t     colNum = pRsp->schema->nCols;
   if (!noPrintSchema) {
     printf("|");
     for (int32_t i = 0; i < colNum; i++) {
       if (i == 0)
-        printf(" %25s |", pRsp->schemas->pSchema[i].name);
+        printf(" %25s |", pRsp->schema->pSchema[i].name);
       else
-        printf(" %15s |", pRsp->schemas->pSchema[i].name);
+        printf(" %15s |", pRsp->schema->pSchema[i].name);
     }
     printf("\n");
     printf("===============================================\n");
@@ -735,7 +737,7 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
   SMqClientVg*    pVg = pParam->pVg;
   tmq_t*          tmq = pParam->tmq;
   if (code != 0) {
-    printf("msg discard\n");
+    printf("msg discard %x\n", code);
     goto WRITE_QUEUE_FAIL;
   }
 
@@ -778,19 +780,19 @@ int32_t tmqPollCb(void* param, const SDataBuf* pMsg, int32_t code) {
     goto WRITE_QUEUE_FAIL;
   }
   memcpy(pRsp, pMsg->pData, sizeof(SMqRspHead));
-  tDecodeSMqPollRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pRsp->consumeRsp);
-  pRsp->curBlock = 0;
-  pRsp->curRow = 0;
+  tDecodeSMqPollRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pRsp->msg);
+  pRsp->iter.curBlock = 0;
+  pRsp->iter.curRow = 0;
   // TODO: alloc mem
   /*pRsp->*/
   /*printf("rsp commit off:%ld rsp off:%ld has data:%d\n", pRsp->committedOffset, pRsp->rspOffset, pRsp->numOfTopics);*/
-  if (pRsp->consumeRsp.numOfTopics == 0) {
+  if (pRsp->msg.numOfTopics == 0) {
     /*printf("no data\n");*/
     taosFreeQitem(pRsp);
     goto WRITE_QUEUE_FAIL;
   }
 
-  pRsp->extra = pParam->pVg;
+  pRsp->vg = pParam->pVg;
   taosWriteQitem(tmq->mqueue, pRsp);
   atomic_add_fetch_32(&tmq->readyRequest, 1);
   tsem_post(&tmq->rspSem);
@@ -860,14 +862,14 @@ int32_t tmqAskEpCb(void* param, const SDataBuf* pMsg, int32_t code) {
     }
     tDeleteSMqCMGetSubEpRsp(&rsp);
   } else {
-    tmq_message_t* pRsp = taosAllocateQitem(sizeof(tmq_message_t));
+    SMqCMGetSubEpRsp* pRsp = taosAllocateQitem(sizeof(SMqCMGetSubEpRsp));
     if (pRsp == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       code = -1;
       goto END;
     }
     memcpy(pRsp, pMsg->pData, sizeof(SMqRspHead));
-    tDecodeSMqCMGetSubEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pRsp->getEpRsp);
+    tDecodeSMqCMGetSubEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), pRsp);
 
     taosWriteQitem(tmq->mqueue, pRsp);
     tsem_post(&tmq->rspSem);
@@ -983,6 +985,7 @@ SMqPollReq* tmqBuildConsumeReqImpl(tmq_t* tmq, int64_t blockingTime, SMqClientTo
   return pReq;
 }
 
+#if 0
 tmq_message_t* tmqSyncPollImpl(tmq_t* tmq, int64_t blockingTime) {
   tmq_message_t* msg = NULL;
   for (int i = 0; i < taosArrayGetSize(tmq->clientTopics); i++) {
@@ -1050,6 +1053,7 @@ tmq_message_t* tmqSyncPollImpl(tmq_t* tmq, int64_t blockingTime) {
   }
   return NULL;
 }
+#endif
 
 int32_t tmqPollImpl(tmq_t* tmq, int64_t blockingTime) {
   /*printf("call poll\n");*/
@@ -1111,11 +1115,12 @@ int32_t tmqPollImpl(tmq_t* tmq, int64_t blockingTime) {
 }
 
 // return
-int32_t tmqHandleRes(tmq_t* tmq, tmq_message_t* rspMsg, bool* pReset) {
-  if (rspMsg->head.mqMsgType == TMQ_MSG_TYPE__EP_RSP) {
+int32_t tmqHandleRes(tmq_t* tmq, SMqRspHead* rspHead, bool* pReset) {
+  if (rspHead->mqMsgType == TMQ_MSG_TYPE__EP_RSP) {
     /*printf("ep %d %d\n", rspMsg->head.epoch, tmq->epoch);*/
-    if (rspMsg->head.epoch > atomic_load_32(&tmq->epoch)) {
-      tmqUpdateEp(tmq, rspMsg->head.epoch, &rspMsg->getEpRsp);
+    if (rspHead->epoch > atomic_load_32(&tmq->epoch)) {
+      SMqCMGetSubEpRsp* rspMsg = (SMqCMGetSubEpRsp*)rspHead;
+      tmqUpdateEp(tmq, rspHead->epoch, rspMsg);
       tmqClearUnhandleMsg(tmq);
       *pReset = true;
     } else {
@@ -1129,21 +1134,22 @@ int32_t tmqHandleRes(tmq_t* tmq, tmq_message_t* rspMsg, bool* pReset) {
 
 tmq_message_t* tmqHandleAllRsp(tmq_t* tmq, int64_t blockingTime, bool pollIfReset) {
   while (1) {
-    tmq_message_t* rspMsg = NULL;
-    taosGetQitem(tmq->qall, (void**)&rspMsg);
-    if (rspMsg == NULL) {
+    SMqRspHead* rspHead = NULL;
+    taosGetQitem(tmq->qall, (void**)&rspHead);
+    if (rspHead == NULL) {
       taosReadAllQitems(tmq->mqueue, tmq->qall);
-      taosGetQitem(tmq->qall, (void**)&rspMsg);
-      if (rspMsg == NULL) return NULL;
+      taosGetQitem(tmq->qall, (void**)&rspHead);
+      if (rspHead == NULL) return NULL;
     }
 
-    if (rspMsg->head.mqMsgType == TMQ_MSG_TYPE__POLL_RSP) {
+    if (rspHead->mqMsgType == TMQ_MSG_TYPE__POLL_RSP) {
+      tmq_message_t* rspMsg = (tmq_message_t*)rspHead;
       atomic_sub_fetch_32(&tmq->readyRequest, 1);
       /*printf("handle poll rsp %d\n", rspMsg->head.mqMsgType);*/
-      if (rspMsg->head.epoch == atomic_load_32(&tmq->epoch)) {
+      if (rspMsg->msg.head.epoch == atomic_load_32(&tmq->epoch)) {
         /*printf("epoch match\n");*/
-        SMqClientVg* pVg = rspMsg->extra;
-        pVg->currentOffset = rspMsg->consumeRsp.rspOffset;
+        SMqClientVg* pVg = rspMsg->vg;
+        pVg->currentOffset = rspMsg->msg.rspOffset;
         atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
         return rspMsg;
       } else {
@@ -1153,8 +1159,8 @@ tmq_message_t* tmqHandleAllRsp(tmq_t* tmq, int64_t blockingTime, bool pollIfRese
     } else {
       /*printf("handle ep rsp %d\n", rspMsg->head.mqMsgType);*/
       bool reset = false;
-      tmqHandleRes(tmq, rspMsg, &reset);
-      taosFreeQitem(rspMsg);
+      tmqHandleRes(tmq, rspHead, &reset);
+      taosFreeQitem(rspHead);
       if (pollIfReset && reset) {
         printf("reset and repoll\n");
         tmqPollImpl(tmq, blockingTime);
@@ -1163,6 +1169,7 @@ tmq_message_t* tmqHandleAllRsp(tmq_t* tmq, int64_t blockingTime, bool pollIfRese
   }
 }
 
+#if 0
 tmq_message_t* tmq_consumer_poll_v1(tmq_t* tmq, int64_t blocking_time) {
   tmq_message_t* rspMsg = NULL;
   int64_t        startTime = taosGetTimestampMs();
@@ -1185,6 +1192,7 @@ tmq_message_t* tmq_consumer_poll_v1(tmq_t* tmq, int64_t blocking_time) {
       return NULL;
   }
 }
+#endif
 
 tmq_message_t* tmq_consumer_poll(tmq_t* tmq, int64_t blocking_time) {
   tmq_message_t* rspMsg;
@@ -1350,7 +1358,7 @@ tmq_resp_err_t tmq_commit(tmq_t* tmq, const tmq_topic_vgroup_list_t* tmq_topic_v
 
 void tmq_message_destroy(tmq_message_t* tmq_message) {
   if (tmq_message == NULL) return;
-  SMqPollRsp* pRsp = &tmq_message->consumeRsp;
+  SMqPollRsp* pRsp = &tmq_message->msg;
   tDeleteSMqConsumeRsp(pRsp);
   /*free(tmq_message);*/
   taosFreeQitem(tmq_message);
@@ -1366,24 +1374,24 @@ const char* tmq_err2str(tmq_resp_err_t err) {
 }
 
 TAOS_ROW tmq_get_row(tmq_message_t* message) {
-  SMqPollRsp* rsp = &message->consumeRsp;
+  SMqPollRsp* rsp = &message->msg;
   while (1) {
-    if (message->curBlock < taosArrayGetSize(rsp->pBlockData)) {
-      SSDataBlock* pBlock = taosArrayGet(rsp->pBlockData, message->curBlock);
-      if (message->curRow < pBlock->info.rows) {
+    if (message->iter.curBlock < taosArrayGetSize(rsp->pBlockData)) {
+      SSDataBlock* pBlock = taosArrayGet(rsp->pBlockData, message->iter.curBlock);
+      if (message->iter.curRow < pBlock->info.rows) {
         for (int i = 0; i < pBlock->info.numOfCols; i++) {
           SColumnInfoData* pData = taosArrayGet(pBlock->pDataBlock, i);
-          if (colDataIsNull_s(pData, message->curRow))
-            message->uData[i] = NULL;
+          if (colDataIsNull_s(pData, message->iter.curRow))
+            message->iter.uData[i] = NULL;
           else {
-            message->uData[i] = colDataGetData(pData, message->curRow);
+            message->iter.uData[i] = colDataGetData(pData, message->iter.curRow);
           }
         }
-        message->curRow++;
-        return message->uData;
+        message->iter.curRow++;
+        return message->iter.uData;
       } else {
-        message->curBlock++;
-        message->curRow = 0;
+        message->iter.curBlock++;
+        message->iter.curRow = 0;
         continue;
       }
     }

source/client/test/clientTests.cpp

@@ -271,6 +271,8 @@ TEST(testCase, create_stable_Test) {
   }
   taos_free_result(pRes);
 
+  pRes = taos_query(pConn, "use abc1");
+
   pRes = taos_query(pConn, "create table if not exists abc1.st1(ts timestamp, k int) tags(a int)");
   if (taos_errno(pRes) != 0) {
     printf("error in create stable, reason:%s\n", taos_errstr(pRes));
@@ -283,17 +285,17 @@ TEST(testCase, create_stable_Test) {
   ASSERT_EQ(numOfFields, 0);
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "create stable if not exists abc1.`123_$^)` (ts timestamp, `abc` int) tags(a int)");
-  if (taos_errno(pRes) != 0) {
-    printf("failed to create super table 123_$^), reason:%s\n", taos_errstr(pRes));
-  }
-
-  pRes = taos_query(pConn, "use abc1");
-  taos_free_result(pRes);
-  pRes = taos_query(pConn, "drop stable `123_$^)`");
-  if (taos_errno(pRes) != 0) {
-    printf("failed to drop super table 123_$^), reason:%s\n", taos_errstr(pRes));
-  }
+//  pRes = taos_query(pConn, "create stable if not exists abc1.`123_$^)` (ts timestamp, `abc` int) tags(a int)");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to create super table 123_$^), reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  pRes = taos_query(pConn, "use abc1");
+//  taos_free_result(pRes);
+//  pRes = taos_query(pConn, "drop stable `123_$^)`");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to drop super table 123_$^), reason:%s\n", taos_errstr(pRes));
+//  }
 
   taos_close(pConn);
 }
@@ -333,7 +335,7 @@ TEST(testCase, create_ctable_Test) {
   }
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "create table tu using sts tags('2021-10-10 1:1:1');");
+  pRes = taos_query(pConn, "create table tu using st1 tags('2021-10-10 1:1:1');");
   if (taos_errno(pRes) != 0) {
     printf("failed to create child table tm0, reason:%s\n", taos_errstr(pRes));
   }
@@ -483,7 +485,9 @@ TEST(testCase, show_table_Test) {
 
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "show abc1.tables");
+  taos_query(pConn, "use abc1");
+
+  pRes = taos_query(pConn, "show tables");
   if (taos_errno(pRes) != 0) {
     printf("failed to show tables, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);
@@ -656,13 +660,7 @@ TEST(testCase, agg_query_tables) {
   TAOS_RES* pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "create table tx using st1 tags(111111111111111)");
-  if (taos_errno(pRes) != 0) {
-    printf("failed to create table, reason:%s\n", taos_errstr(pRes));
-  }
-  taos_free_result(pRes);
-
-  pRes = taos_query(pConn, "select count(*) from t_x_19");
+  pRes = taos_query(pConn, "select count(*), sum(k),min(k),max(k) from tu");
   if (taos_errno(pRes) != 0) {
     printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);

source/common/src/tdataformat.c

@@ -421,6 +421,7 @@ SDataCols *tdFreeDataCols(SDataCols *pCols) {
   return NULL;
 }
 
+#if 0
 SDataCols *tdDupDataCols(SDataCols *pDataCols, bool keepData) {
   SDataCols *pRet = tdNewDataCols(pDataCols->maxCols, pDataCols->maxPoints);
   if (pRet == NULL) return NULL;
@@ -431,6 +432,7 @@ SDataCols *tdDupDataCols(SDataCols *pDataCols, bool keepData) {
 
   for (int i = 0; i < pDataCols->numOfCols; i++) {
     pRet->cols[i].type = pDataCols->cols[i].type;
+    pRet->cols[i].bitmap = pDataCols->cols[i].bitmap;
     pRet->cols[i].colId = pDataCols->cols[i].colId;
     pRet->cols[i].bytes = pDataCols->cols[i].bytes;
     pRet->cols[i].offset = pDataCols->cols[i].offset;
@@ -453,6 +455,7 @@ SDataCols *tdDupDataCols(SDataCols *pDataCols, bool keepData) {
 
   return pRet;
 }
+#endif
 
 void tdResetDataCols(SDataCols *pCols) {
   if (pCols != NULL) {

source/common/src/tglobal.c

@@ -132,6 +132,9 @@ bool tsdbForceKeepFile = false;
 int32_t  tsDiskCfgNum = 0;
 SDiskCfg tsDiskCfg[TFS_MAX_DISKS] = {0};
 
+// stream scheduler
+bool tsStreamSchedV = true;
+
 /*
  * minimum scale for whole system, millisecond by default
  * for TSDB_TIME_PRECISION_MILLI: 86400000L
@@ -585,4 +588,4 @@ void taosCfgDynamicOptions(const char *option, const char *value) {
     taosResetLog();
     cfgDumpCfg(tsCfg, 1, false);
   }
-}
+}
\ No newline at end of file

source/common/src/tmsg.c

@@ -290,7 +290,7 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
   tlen += taosEncodeString(buf, pReq->name);
   tlen += taosEncodeFixedU32(buf, pReq->ttl);
   tlen += taosEncodeFixedU32(buf, pReq->keep);
-  tlen += taosEncodeFixedU8(buf, pReq->type);
+  tlen += taosEncodeFixedU8(buf, pReq->info);
 
   switch (pReq->type) {
     case TD_SUPER_TABLE:
@@ -309,6 +309,20 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
         tlen += taosEncodeFixedI32(buf, pReq->stbCfg.pTagSchema[i].bytes);
         tlen += taosEncodeString(buf, pReq->stbCfg.pTagSchema[i].name);
       }
+      tlen += taosEncodeFixedI16(buf, pReq->stbCfg.nBSmaCols);
+      for (col_id_t i = 0; i < pReq->stbCfg.nBSmaCols; ++i) {
+        tlen += taosEncodeFixedI16(buf, pReq->stbCfg.pBSmaCols[i]);
+      }
+      if (pReq->rollup && NULL != pReq->stbCfg.pRSmaParam) {
+        SRSmaParam *param = pReq->stbCfg.pRSmaParam;
+        tlen += taosEncodeFixedU32(buf, (uint32_t)param->xFilesFactor);
+        tlen += taosEncodeFixedI8(buf, param->delayUnit);
+        tlen += taosEncodeFixedI8(buf, param->nFuncIds);
+        for (int8_t i = 0; i < param->nFuncIds; ++i) {
+          tlen += taosEncodeFixedI32(buf, param->pFuncIds[i]);
+        }
+        tlen += taosEncodeFixedI64(buf, param->delay);
+      }
       break;
     case TD_CHILD_TABLE:
       tlen += taosEncodeFixedI64(buf, pReq->ctbCfg.suid);
@@ -322,6 +336,20 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
         tlen += taosEncodeFixedI32(buf, pReq->ntbCfg.pSchema[i].bytes);
         tlen += taosEncodeString(buf, pReq->ntbCfg.pSchema[i].name);
       }
+      tlen += taosEncodeFixedI16(buf, pReq->stbCfg.nBSmaCols);
+      for (col_id_t i = 0; i < pReq->stbCfg.nBSmaCols; ++i) {
+        tlen += taosEncodeFixedI16(buf, pReq->stbCfg.pBSmaCols[i]);
+      }
+      if (pReq->rollup && NULL != pReq->stbCfg.pRSmaParam) {
+        SRSmaParam *param = pReq->stbCfg.pRSmaParam;
+        tlen += taosEncodeFixedU32(buf, (uint32_t)param->xFilesFactor);
+        tlen += taosEncodeFixedI8(buf, param->delayUnit);
+        tlen += taosEncodeFixedI8(buf, param->nFuncIds);
+        for (int8_t i = 0; i < param->nFuncIds; ++i) {
+          tlen += taosEncodeFixedI32(buf, param->pFuncIds[i]);
+        }
+        tlen += taosEncodeFixedI64(buf, param->delay);
+      }
       break;
     default:
       ASSERT(0);
@@ -335,7 +363,7 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
   buf = taosDecodeString(buf, &(pReq->name));
   buf = taosDecodeFixedU32(buf, &(pReq->ttl));
   buf = taosDecodeFixedU32(buf, &(pReq->keep));
-  buf = taosDecodeFixedU8(buf, &(pReq->type));
+  buf = taosDecodeFixedU8(buf, &(pReq->info));
 
   switch (pReq->type) {
     case TD_SUPER_TABLE:
@@ -356,6 +384,32 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
         buf = taosDecodeFixedI32(buf, &pReq->stbCfg.pTagSchema[i].bytes);
         buf = taosDecodeStringTo(buf, pReq->stbCfg.pTagSchema[i].name);
       }
+      buf = taosDecodeFixedI16(buf, &(pReq->stbCfg.nBSmaCols));
+      if (pReq->stbCfg.nBSmaCols > 0) {
+        pReq->stbCfg.pBSmaCols = (col_id_t *)malloc(pReq->stbCfg.nBSmaCols * sizeof(col_id_t));
+        for (col_id_t i = 0; i < pReq->stbCfg.nBSmaCols; ++i) {
+          buf = taosDecodeFixedI16(buf, pReq->stbCfg.pBSmaCols + i);
+        }
+      } else {
+        pReq->stbCfg.pBSmaCols = NULL;
+      }
+      if (pReq->rollup) {
+        pReq->stbCfg.pRSmaParam = (SRSmaParam *)malloc(sizeof(SRSmaParam));
+        SRSmaParam *param = pReq->stbCfg.pRSmaParam;
+        buf = taosDecodeFixedU32(buf, (uint32_t *)&param->xFilesFactor);
+        buf = taosDecodeFixedI8(buf, &param->delayUnit);
+        buf = taosDecodeFixedI8(buf, &param->nFuncIds);
+        if (param->nFuncIds > 0) {
+          for (int8_t i = 0; i < param->nFuncIds; ++i) {
+            buf = taosDecodeFixedI32(buf, param->pFuncIds + i);
+          }
+        } else {
+          param->pFuncIds = NULL;
+        }
+        buf = taosDecodeFixedI64(buf, &param->delay);
+      } else {
+        pReq->stbCfg.pRSmaParam = NULL;
+      }
       break;
     case TD_CHILD_TABLE:
       buf = taosDecodeFixedI64(buf, &pReq->ctbCfg.suid);
@@ -370,6 +424,32 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
         buf = taosDecodeFixedI32(buf, &pReq->ntbCfg.pSchema[i].bytes);
         buf = taosDecodeStringTo(buf, pReq->ntbCfg.pSchema[i].name);
       }
+      buf = taosDecodeFixedI16(buf, &(pReq->stbCfg.nBSmaCols));
+      if (pReq->stbCfg.nBSmaCols > 0) {
+        pReq->stbCfg.pBSmaCols = (col_id_t *)malloc(pReq->stbCfg.nBSmaCols * sizeof(col_id_t));
+        for (col_id_t i = 0; i < pReq->stbCfg.nBSmaCols; ++i) {
+          buf = taosDecodeFixedI16(buf, pReq->stbCfg.pBSmaCols + i);
+        }
+      } else {
+        pReq->stbCfg.pBSmaCols = NULL;
+      }
+      if (pReq->rollup) {
+        pReq->stbCfg.pRSmaParam = (SRSmaParam *)malloc(sizeof(SRSmaParam));
+        SRSmaParam *param = pReq->stbCfg.pRSmaParam;
+        buf = taosDecodeFixedU32(buf, (uint32_t *)&param->xFilesFactor);
+        buf = taosDecodeFixedI8(buf, &param->delayUnit);
+        buf = taosDecodeFixedI8(buf, &param->nFuncIds);
+        if (param->nFuncIds > 0) {
+          for (int8_t i = 0; i < param->nFuncIds; ++i) {
+            buf = taosDecodeFixedI32(buf, param->pFuncIds + i);
+          }
+        } else {
+          param->pFuncIds = NULL;
+        }
+        buf = taosDecodeFixedI64(buf, &param->delay);
+      } else {
+        pReq->stbCfg.pRSmaParam = NULL;
+      }
       break;
     default:
       ASSERT(0);
@@ -1733,7 +1813,10 @@ int32_t tSerializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq
 
   if (tStartEncode(&encoder) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->showId) < 0) return -1;
+  if (tEncodeI32(&encoder, pReq->type) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->free) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->tb) < 0) return -1;
   tEndEncode(&encoder);
 
   int32_t tlen = encoder.pos;
@@ -1747,8 +1830,10 @@ int32_t tDeserializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableR
 
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->showId) < 0) return -1;
+  if (tDecodeI32(&decoder, &pReq->type) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->free) < 0) return -1;
-
+  if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->tb) < 0) return -1;
   tEndDecode(&decoder);
   tCoderClear(&decoder);
   return 0;
@@ -2619,6 +2704,77 @@ int32_t tDeserializeSSchedulerHbRsp(void *buf, int32_t bufLen, SSchedulerHbRsp *
 
 void tFreeSSchedulerHbRsp(SSchedulerHbRsp *pRsp) { taosArrayDestroy(pRsp->taskStatus); }
 
+int32_t tSerializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pRsp) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->code) < 0) return -1;
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSQueryTableRsp(void *buf, int32_t bufLen, SQueryTableRsp *pRsp) {
+  SCoder decoder = {0};
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->code) < 0) return -1;
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
+int32_t tSerializeSVCreateTbBatchRsp(void *buf, int32_t bufLen, SVCreateTbBatchRsp *pRsp) {
+  SCoder encoder = {0};
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_ENCODER);
+
+  if (tStartEncode(&encoder) < 0) return -1;
+  if (pRsp->rspList) {
+    int32_t num = taosArrayGetSize(pRsp->rspList);
+    if (tEncodeI32(&encoder, num) < 0) return -1;
+    for (int32_t i = 0; i < num; ++i) {
+      SVCreateTbRsp *rsp = taosArrayGet(pRsp->rspList, i);
+      if (tEncodeI32(&encoder, rsp->code) < 0) return -1;
+    }
+  } else {
+    if (tEncodeI32(&encoder, 0) < 0) return -1;
+  }
+  tEndEncode(&encoder);
+
+  int32_t tlen = encoder.pos;
+  tCoderClear(&encoder);
+  return tlen;
+}
+
+int32_t tDeserializeSVCreateTbBatchRsp(void *buf, int32_t bufLen, SVCreateTbBatchRsp *pRsp) {
+  SCoder  decoder = {0};
+  int32_t num = 0;
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf, bufLen, TD_DECODER);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI32(&decoder, &num) < 0) return -1;
+  if (num > 0) {
+    pRsp->rspList = taosArrayInit(num, sizeof(SVCreateTbRsp));
+    if (NULL == pRsp->rspList) return -1;
+    for (int32_t i = 0; i < num; ++i) {
+      SVCreateTbRsp rsp = {0};
+      if (tDecodeI32(&decoder, &rsp.code) < 0) return -1;
+      if (NULL == taosArrayPush(pRsp->rspList, &rsp)) return -1;
+    }
+  } else {
+    pRsp->rspList = NULL;
+  }
+  tEndDecode(&decoder);
+
+  tCoderClear(&decoder);
+  return 0;
+}
+
 int32_t tSerializeSVCreateTSmaReq(void **buf, SVCreateTSmaReq *pReq) {
   int32_t tlen = 0;
 
@@ -2667,7 +2823,8 @@ int32_t tSerializeSCMCreateStreamReq(void *buf, int32_t bufLen, const SCMCreateS
   if (tEncodeCStr(&encoder, pReq->name) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->outputTbName) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->igExists) < 0) return -1;
-  if (tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
+  if (tEncodeI32(&encoder, sqlLen) < 0) return -1;
+  if (tEncodeI32(&encoder, astLen) < 0) return -1;
   if (sqlLen > 0 && tEncodeCStr(&encoder, pReq->sql) < 0) return -1;
   if (astLen > 0 && tEncodeCStr(&encoder, pReq->ast) < 0) return -1;
 
@@ -2715,26 +2872,36 @@ void tFreeSCMCreateStreamReq(SCMCreateStreamReq *pReq) {
 }
 
 int32_t tEncodeSStreamTask(SCoder *pEncoder, const SStreamTask *pTask) {
-  if (tStartEncode(pEncoder) < 0) return -1;
+  /*if (tStartEncode(pEncoder) < 0) return -1;*/
   if (tEncodeI64(pEncoder, pTask->streamId) < 0) return -1;
   if (tEncodeI32(pEncoder, pTask->taskId) < 0) return -1;
   if (tEncodeI32(pEncoder, pTask->level) < 0) return -1;
   if (tEncodeI8(pEncoder, pTask->status) < 0) return -1;
+  if (tEncodeI8(pEncoder, pTask->pipeSource) < 0) return -1;
+  if (tEncodeI8(pEncoder, pTask->pipeSink) < 0) return -1;
+  if (tEncodeI8(pEncoder, pTask->parallelizable) < 0) return -1;
+  if (tEncodeI8(pEncoder, pTask->nextOpDst) < 0) return -1;
+  // if (tEncodeI8(pEncoder, pTask->numOfRunners) < 0) return -1;
   if (tEncodeSEpSet(pEncoder, &pTask->NextOpEp) < 0) return -1;
   if (tEncodeCStr(pEncoder, pTask->qmsg) < 0) return -1;
-  tEndEncode(pEncoder);
+  /*tEndEncode(pEncoder);*/
   return pEncoder->pos;
 }
 
 int32_t tDecodeSStreamTask(SCoder *pDecoder, SStreamTask *pTask) {
-  if (tStartDecode(pDecoder) < 0) return -1;
+  /*if (tStartDecode(pDecoder) < 0) return -1;*/
   if (tDecodeI64(pDecoder, &pTask->streamId) < 0) return -1;
   if (tDecodeI32(pDecoder, &pTask->taskId) < 0) return -1;
   if (tDecodeI32(pDecoder, &pTask->level) < 0) return -1;
   if (tDecodeI8(pDecoder, &pTask->status) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pTask->pipeSource) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pTask->pipeSink) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pTask->parallelizable) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pTask->nextOpDst) < 0) return -1;
+  // if (tDecodeI8(pDecoder, &pTask->numOfRunners) < 0) return -1;
   if (tDecodeSEpSet(pDecoder, &pTask->NextOpEp) < 0) return -1;
   if (tDecodeCStrAlloc(pDecoder, &pTask->qmsg) < 0) return -1;
-  tEndDecode(pDecoder);
+  /*tEndDecode(pDecoder);*/
   return 0;
 }
 

source/dnode/vnode/inc/tq.h → source/common/src/tmsgcb.c

@@ -13,54 +13,23 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _TQ_H_
-#define _TQ_H_
+#define _DEFAULT_SOURCE
+#include "tmsgcb.h"
 
-#include "executor.h"
-#include "meta.h"
-#include "taoserror.h"
-#include "tcommon.h"
-#include "tmallocator.h"
-#include "tmsg.h"
-#include "trpc.h"
-#include "ttimer.h"
-#include "tutil.h"
-#include "vnode.h"
-#include "wal.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct STQ STQ;
-
-// memory allocator provided by vnode
-typedef struct {
-  SMemAllocatorFactory* pAllocatorFactory;
-  SMemAllocator*        pAllocator;
-} STqMemRef;
-
-// init once
-int  tqInit();
-void tqCleanUp();
-
-// open in each vnode
-STQ* tqOpen(const char* path, SWal* pWal, SMeta* pMeta, STqCfg* tqConfig, SMemAllocatorFactory* allocFac);
-void tqClose(STQ*);
-
-// required by vnode
-int tqPushMsg(STQ*, void* msg, tmsg_t msgType, int64_t version);
-int tqCommit(STQ*);
+int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq) {
+  return (*pMsgCb->queueFps[qtype])(pMsgCb->pWrapper, pReq);
+}
 
-int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg);
-int32_t tqProcessSetConnReq(STQ* pTq, char* msg);
-int32_t tqProcessRebReq(STQ* pTq, char* msg);
-int32_t tqProcessTaskExec(STQ* pTq, SRpcMsg* msg);
+int32_t tmsgGetQueueSize(const SMsgCb* pMsgCb, int32_t vgId, EQueueType qtype) {
+  return (*pMsgCb->qsizeFp)(pMsgCb->pWrapper, vgId, qtype);
+}
 
-int32_t tqProcessTaskDeploy(STQ* pTq, char* msg, int32_t msgLen);
+int32_t tmsgSendReq(const SMsgCb* pMsgCb, SEpSet* epSet, SRpcMsg* pReq) {
+  return (*pMsgCb->sendReqFp)(pMsgCb->pWrapper, epSet, pReq);
+}
 
-#ifdef __cplusplus
+int32_t tmsgSendMnodeReq(const SMsgCb* pMsgCb, SRpcMsg* pReq) {
+  return (*pMsgCb->sendMnodeReqFp)(pMsgCb->pWrapper, pReq);
 }
-#endif
 
-#endif /*_TQ_H_*/
+void tmsgSendRsp(const SMsgCb* pMsgCb, SRpcMsg* pRsp) { return (*pMsgCb->sendRspFp)(pMsgCb->pWrapper, pRsp); }

source/common/src/tname.c

@@ -222,6 +222,27 @@ int32_t tNameSetAcctId(SName* dst, int32_t acctId) {
   return 0;
 }
 
+bool tNameDBNameEqual(SName* left, SName* right) {
+  if (NULL == left) {
+    if (NULL == right) {
+      return true;
+    }
+
+    return false;
+  }
+
+  if (NULL == right) {
+    return false;
+  }
+
+  if (left->acctId != right->acctId) {
+    return false;
+  }
+
+  return (0 == strcmp(left->dbname, right->dbname));
+}
+
+
 int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
   assert(dst != NULL && str != NULL && strlen(str) > 0);
 
@@ -273,13 +294,4 @@ int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
   return 0;
 }
 
-SSchema createSchema(uint8_t type, int32_t bytes, int32_t colId, const char* name) {
-  SSchema s = {0};
-  s.type  = type;
-  s.bytes = bytes;
-  s.colId = colId;
-
-  tstrncpy(s.name, name, tListLen(s.name));
-  return s;
-}
 

source/common/src/trow.c

@@ -78,7 +78,7 @@ static FORCE_INLINE void dataColSetNoneAt(SDataCol *pCol, int index, bool setBit
     setNull(POINTER_SHIFT(pCol->pData, TYPE_BYTES[pCol->type] * index), pCol->type, pCol->bytes);
     pCol->len += TYPE_BYTES[pCol->type];
   }
-  if(setBitmap) {
+  if (setBitmap) {
     tdSetBitmapValType(pCol->pBitmap, index, TD_VTYPE_NONE);
   }
 }
@@ -118,8 +118,8 @@ int trbWriteCol(SRowBuilder *pRB, void *pData, col_id_t cid) {
 
 #endif
 
-STSRow* tdRowDup(STSRow *row) {
-  STSRow* trow = malloc(TD_ROW_LEN(row));
+STSRow *tdRowDup(STSRow *row) {
+  STSRow *trow = malloc(TD_ROW_LEN(row));
   if (trow == NULL) return NULL;
 
   tdRowCpy(trow, row);
@@ -176,7 +176,7 @@ static int32_t tdAppendTpRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols
 
   SDataCol *pDataCol = &(pCols->cols[0]);
   if (pDataCol->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
-    tdAppendValToDataCol(pDataCol, TD_VTYPE_NORM, &pRow->ts,  pCols->numOfRows, pCols->maxPoints);
+    tdAppendValToDataCol(pDataCol, TD_VTYPE_NORM, &pRow->ts, pCols->numOfRows, pCols->maxPoints);
   }
 
   while (dcol < pCols->numOfCols) {
@@ -378,9 +378,7 @@ static void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, i
   }
 }
 
-
-
-STSRow* mergeTwoRows(void *buffer, STSRow* row1, STSRow *row2, STSchema *pSchema1, STSchema *pSchema2) {
+STSRow *mergeTwoRows(void *buffer, STSRow *row1, STSRow *row2, STSchema *pSchema1, STSchema *pSchema2) {
 #if 0
   ASSERT(TD_ROW_KEY(row1) == TD_ROW_KEY(row2));
   ASSERT(schemaVersion(pSchema1) == TD_ROW_SVER(row1));
@@ -473,6 +471,44 @@ STSRow* mergeTwoRows(void *buffer, STSRow* row1, STSRow *row2, STSchema *pSchema
   }
   taosArrayDestroy(stashRow);
   return buffer;
-  #endif
+#endif
   return NULL;
 }
+
+SDataCols *tdDupDataCols(SDataCols *pDataCols, bool keepData) {
+  SDataCols *pRet = tdNewDataCols(pDataCols->maxCols, pDataCols->maxPoints);
+  if (pRet == NULL) return NULL;
+
+  pRet->numOfCols = pDataCols->numOfCols;
+  pRet->sversion = pDataCols->sversion;
+  if (keepData) pRet->numOfRows = pDataCols->numOfRows;
+
+  for (int i = 0; i < pDataCols->numOfCols; i++) {
+    pRet->cols[i].type = pDataCols->cols[i].type;
+    pRet->cols[i].bitmap = pDataCols->cols[i].bitmap;
+    pRet->cols[i].colId = pDataCols->cols[i].colId;
+    pRet->cols[i].bytes = pDataCols->cols[i].bytes;
+    pRet->cols[i].offset = pDataCols->cols[i].offset;
+
+    if (keepData) {
+      if (pDataCols->cols[i].len > 0) {
+        if (tdAllocMemForCol(&pRet->cols[i], pRet->maxPoints) < 0) {
+          tdFreeDataCols(pRet);
+          return NULL;
+        }
+        pRet->cols[i].len = pDataCols->cols[i].len;
+        memcpy(pRet->cols[i].pData, pDataCols->cols[i].pData, pDataCols->cols[i].len);
+        if (IS_VAR_DATA_TYPE(pRet->cols[i].type)) {
+          int dataOffSize = sizeof(VarDataOffsetT) * pDataCols->maxPoints;
+          memcpy(pRet->cols[i].dataOff, pDataCols->cols[i].dataOff, dataOffSize);
+        }
+        if (!TD_COL_ROWS_NORM(pRet->cols + i)) {
+          int32_t nBitmapBytes = (int32_t)TD_BITMAP_BYTES(pDataCols->maxPoints);
+          memcpy(pRet->cols[i].pBitmap, pDataCols->cols[i].pBitmap, nBitmapBytes);
+        }
+      }
+    }
+  }
+
+  return pRet;
+}
\ No newline at end of file

source/dnode/bnode/inc/bndInt.h

@@ -30,7 +30,7 @@ extern "C" {
 #endif
 
 typedef struct SBnode {
-  SBnodeOpt opt;
+  SMsgCb msgCb;
 } SBnode;
 
 #ifdef __cplusplus

source/dnode/bnode/src/bnode.c

@@ -17,6 +17,7 @@
 
 SBnode *bndOpen(const char *path, const SBnodeOpt *pOption) {
   SBnode *pBnode = calloc(1, sizeof(SBnode));
+  pBnode->msgCb = pOption->msgCb;
   return pBnode;
 }
 

source/dnode/mgmt/bnode/inc/bmInt.h

@@ -28,7 +28,7 @@ typedef struct SBnodeMgmt {
   SDnode       *pDnode;
   SMgmtWrapper *pWrapper;
   const char   *path;
-  SDnodeWorker  writeWorker;
+  SMultiWorker  writeWorker;
 } SBnodeMgmt;
 
 // bmInt.c

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

@@ -19,13 +19,12 @@
 static int32_t bmRequire(SMgmtWrapper *pWrapper, bool *required) { return dndReadFile(pWrapper, required); }
 
 static void bmInitOption(SBnodeMgmt *pMgmt, SBnodeOpt *pOption) {
-  SDnode *pDnode = pMgmt->pDnode;
-  pOption->pWrapper = pMgmt->pWrapper;
-  pOption->sendReqFp = dndSendReqToDnode;
-  pOption->sendMnodeReqFp = dndSendReqToMnode;
-  pOption->sendRspFp = dndSendRsp;
-  pOption->dnodeId = pDnode->dnodeId;
-  pOption->clusterId = pDnode->clusterId;
+  SMsgCb msgCb = {0};
+  msgCb.pWrapper = pMgmt->pWrapper;
+  msgCb.sendReqFp = dndSendReqToDnode;
+  msgCb.sendMnodeReqFp = dndSendReqToMnode;
+  msgCb.sendRspFp = dndSendRsp;
+  pOption->msgCb = msgCb;
 }
 
 static int32_t bmOpenImp(SBnodeMgmt *pMgmt) {

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

@@ -33,7 +33,8 @@ static void bmSendErrorRsps(SMgmtWrapper *pWrapper, STaosQall *qall, int32_t num
   }
 }
 
-static void bmProcessQueue(SBnodeMgmt *pMgmt, STaosQall *qall, int32_t numOfMsgs) {
+static void bmProcessQueue(SQueueInfo *pInfo, STaosQall *qall, int32_t numOfMsgs) {
+  SBnodeMgmt   *pMgmt = pInfo->ahandle;
   SMgmtWrapper *pWrapper = pMgmt->pWrapper;
 
   SArray *pArray = taosArrayInit(numOfMsgs, sizeof(SNodeMsg *));
@@ -63,14 +64,15 @@ static void bmProcessQueue(SBnodeMgmt *pMgmt, STaosQall *qall, int32_t numOfMsgs
 }
 
 int32_t bmProcessWriteMsg(SBnodeMgmt *pMgmt, SNodeMsg *pMsg) {
-  SDnodeWorker *pWorker = &pMgmt->writeWorker;
+  SMultiWorker *pWorker = &pMgmt->writeWorker;
 
   dTrace("msg:%p, put into worker:%s", pMsg, pWorker->name);
-  return dndWriteMsgToWorker(pWorker, pMsg);
+  return taosWriteQitem(pWorker->queue, pMsg);
 }
 
 int32_t bmStartWorker(SBnodeMgmt *pMgmt) {
-  if (dndInitWorker(pMgmt, &pMgmt->writeWorker, DND_WORKER_MULTI, "bnode-write", 0, 1, bmProcessQueue) != 0) {
+  SMultiWorkerCfg cfg = {.maxNum = 1, .name = "bnode-write", .fp = (FItems)bmProcessQueue, .param = pMgmt};
+  if (tMultiWorkerInit(&pMgmt->writeWorker, &cfg) != 0) {
     dError("failed to start bnode write worker since %s", terrstr());
     return -1;
   }
@@ -78,4 +80,4 @@ int32_t bmStartWorker(SBnodeMgmt *pMgmt) {
   return 0;
 }
 
-void bmStopWorker(SBnodeMgmt *pMgmt) { dndCleanupWorker(&pMgmt->writeWorker); }
+void bmStopWorker(SBnodeMgmt *pMgmt) { tMultiWorkerCleanup(&pMgmt->writeWorker); }

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

@@ -74,21 +74,10 @@ typedef int32_t (*CreateNodeFp)(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
 typedef int32_t (*DropNodeFp)(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
 typedef int32_t (*RequireNodeFp)(SMgmtWrapper *pWrapper, bool *required);
 
-typedef struct {
-  EWorkerType type;
-  const char *name;
-  int32_t     minNum;
-  int32_t     maxNum;
-  void       *queueFp;
-  void       *param;
-  STaosQueue *queue;
-  union {
-    SQWorkerPool pool;
-    SWWorkerPool mpool;
-  };
-} SDnodeWorker;
-
 typedef struct SMsgHandle {
+  int32_t       vgId;
+  NodeMsgFp     vgIdMsgFp;
+  SMgmtWrapper *pVgIdWrapper;  // Handle the case where the same message type is distributed to qnode or vnode
   NodeMsgFp     msgFp;
   SMgmtWrapper *pWrapper;
 } SMsgHandle;
@@ -114,6 +103,7 @@ typedef struct SMgmtWrapper {
   void       *pMgmt;
   SDnode     *pDnode;
   NodeMsgFp   msgFps[TDMT_MAX];
+  int32_t     msgVgIds[TDMT_MAX];  // Handle the case where the same message type is distributed to qnode or vnode
   SMgmtFp     fp;
 } SMgmtWrapper;
 
@@ -149,7 +139,7 @@ typedef struct SDnode {
 EDndStatus    dndGetStatus(SDnode *pDnode);
 void          dndSetStatus(SDnode *pDnode, EDndStatus stat);
 SMgmtWrapper *dndAcquireWrapper(SDnode *pDnode, ENodeType nodeType);
-void          dndSetMsgHandle(SMgmtWrapper *pWrapper, int32_t msgType, NodeMsgFp nodeMsgFp);
+void          dndSetMsgHandle(SMgmtWrapper *pWrapper, int32_t msgType, NodeMsgFp nodeMsgFp, int32_t vgId);
 void          dndReportStartup(SDnode *pDnode, char *pName, char *pDesc);
 void          dndSendMonitorReport(SDnode *pDnode);
 
@@ -157,11 +147,6 @@ int32_t dndSendReqToMnode(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
 int32_t dndSendReqToDnode(SMgmtWrapper *pWrapper, SEpSet *pEpSet, SRpcMsg *pMsg);
 void    dndSendRsp(SMgmtWrapper *pWrapper, SRpcMsg *pRsp);
 
-int32_t dndInitWorker(void *param, SDnodeWorker *pWorker, EWorkerType type, const char *name, int32_t minNum,
-                      int32_t maxNum, void *queueFp);
-void    dndCleanupWorker(SDnodeWorker *pWorker);
-int32_t dndWriteMsgToWorker(SDnodeWorker *pWorker, void *pMsg);
-
 int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg);
 
 int32_t dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed);

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

@@ -65,8 +65,9 @@ void dndCleanup() {
   dInfo("dnode env is cleaned up");
 }
 
-void dndSetMsgHandle(SMgmtWrapper *pWrapper, int32_t msgType, NodeMsgFp nodeMsgFp) {
+void dndSetMsgHandle(SMgmtWrapper *pWrapper, int32_t msgType, NodeMsgFp nodeMsgFp, int32_t vgId) {
   pWrapper->msgFps[TMSG_INDEX(msgType)] = nodeMsgFp;
+  pWrapper->msgVgIds[TMSG_INDEX(msgType)] = vgId;
 }
 
 EDndStatus dndGetStatus(SDnode *pDnode) { return pDnode->status; }

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

@@ -20,13 +20,26 @@
 #define INTERNAL_CKEY   "_key"
 #define INTERNAL_SECRET "_pwd"
 
+static inline void dndProcessQVnodeRpcMsg(SMsgHandle *pHandle, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  SMsgHead *pHead = pMsg->pCont;
+  int32_t   vgId = htonl(pHead->vgId);
+
+  SMgmtWrapper *pWrapper = pHandle->pWrapper;
+  if (vgId == pHandle->vgId && pHandle->pVgIdWrapper != NULL) {
+    pWrapper = pHandle->pVgIdWrapper;
+  }
+
+  dTrace("msg:%s will be processed by %s, handle:%p app:%p vgId:%d", TMSG_INFO(pMsg->msgType), pWrapper->name,
+         pMsg->handle, pMsg->ahandle, vgId);
+  dndProcessRpcMsg(pWrapper, pMsg, pEpSet);
+}
+
 static void dndProcessResponse(void *parent, SRpcMsg *pRsp, SEpSet *pEpSet) {
   SDnode     *pDnode = parent;
   STransMgmt *pMgmt = &pDnode->trans;
   tmsg_t      msgType = pRsp->msgType;
 
   if (dndGetStatus(pDnode) != DND_STAT_RUNNING) {
-    // if (pRsp == NULL || pRsp->pCont == NULL) return;
     dTrace("rsp:%s ignored since dnode not running, handle:%p app:%p", TMSG_INFO(msgType), pRsp->handle, pRsp->ahandle);
     rpcFreeCont(pRsp->pCont);
     return;
@@ -34,9 +47,13 @@ static void dndProcessResponse(void *parent, SRpcMsg *pRsp, SEpSet *pEpSet) {
 
   SMsgHandle *pHandle = &pMgmt->msgHandles[TMSG_INDEX(msgType)];
   if (pHandle->msgFp != NULL) {
-    dTrace("rsp:%s will be processed by %s, handle:%p app:%p code:0x%04x:%s", TMSG_INFO(msgType),
-           pHandle->pWrapper->name, pRsp->handle, pRsp->ahandle, pRsp->code & 0XFFFF, tstrerror(pRsp->code));
-    dndProcessRpcMsg(pHandle->pWrapper, pRsp, pEpSet);
+    if (pHandle->vgId == 0) {
+      dTrace("rsp:%s will be processed by %s, handle:%p app:%p code:0x%04x:%s", TMSG_INFO(msgType),
+             pHandle->pWrapper->name, pRsp->handle, pRsp->ahandle, pRsp->code & 0XFFFF, tstrerror(pRsp->code));
+      dndProcessRpcMsg(pHandle->pWrapper, pRsp, pEpSet);
+    } else {
+      dndProcessQVnodeRpcMsg(pHandle, pRsp, pEpSet);
+    }
   } else {
     dError("rsp:%s not processed since no handle, handle:%p app:%p", TMSG_INFO(msgType), pRsp->handle, pRsp->ahandle);
     rpcFreeCont(pRsp->pCont);
@@ -110,9 +127,13 @@ static void dndProcessRequest(void *param, SRpcMsg *pReq, SEpSet *pEpSet) {
 
   SMsgHandle *pHandle = &pMgmt->msgHandles[TMSG_INDEX(msgType)];
   if (pHandle->msgFp != NULL) {
-    dTrace("req:%s will be processed by %s, handle:%p app:%p", TMSG_INFO(msgType), pHandle->pWrapper->name,
-           pReq->handle, pReq->ahandle);
-    dndProcessRpcMsg(pHandle->pWrapper, pReq, pEpSet);
+    if (pHandle->vgId == 0) {
+      dTrace("req:%s will be processed by %s, handle:%p app:%p", TMSG_INFO(msgType), pHandle->pWrapper->name,
+             pReq->handle, pReq->ahandle);
+      dndProcessRpcMsg(pHandle->pWrapper, pReq, pEpSet);
+    } else {
+      dndProcessQVnodeRpcMsg(pHandle, pReq, pEpSet);
+    }
   } else {
     dError("req:%s not processed since no handle, handle:%p app:%p", TMSG_INFO(msgType), pReq->handle, pReq->ahandle);
     SRpcMsg rspMsg = {.handle = pReq->handle, .code = TSDB_CODE_MSG_NOT_PROCESSED, .ahandle = pReq->ahandle};
@@ -245,17 +266,24 @@ int32_t dndInitMsgHandle(SDnode *pDnode) {
 
     for (int32_t msgIndex = 0; msgIndex < TDMT_MAX; ++msgIndex) {
       NodeMsgFp msgFp = pWrapper->msgFps[msgIndex];
+      int32_t   vgId = pWrapper->msgVgIds[msgIndex];
       if (msgFp == NULL) continue;
 
       SMsgHandle *pHandle = &pMgmt->msgHandles[msgIndex];
-      if (pHandle->msgFp != NULL) {
-        dError("msg:%s has multiple process nodes, prev node:%s, curr node:%s", tMsgInfo[msgIndex],
-               pHandle->pWrapper->name, pWrapper->name);
+      if (pHandle->msgFp != NULL && pHandle->vgId == vgId) {
+        dError("msg:%s has multiple process nodes, prev node:%s:%d, curr node:%s:%d", tMsgInfo[msgIndex],
+               pHandle->pWrapper->name, pHandle->pWrapper->msgVgIds[msgIndex], pWrapper->name, vgId);
         return -1;
       } else {
-        dTrace("msg:%s will be processed by %s", tMsgInfo[msgIndex], pWrapper->name);
-        pHandle->msgFp = msgFp;
-        pHandle->pWrapper = pWrapper;
+        dTrace("msg:%s will be processed by %s, vgId:%d", tMsgInfo[msgIndex], pWrapper->name, vgId);
+        if (vgId == 0) {
+          pHandle->msgFp = msgFp;
+          pHandle->pWrapper = pWrapper;
+        } else {
+          pHandle->vgId = vgId;
+          pHandle->vgIdMsgFp = msgFp;
+          pHandle->pVgIdWrapper = pWrapper;
+        }
       }
     }
   }

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

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http:www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "dndInt.h"
-
-int32_t dndInitWorker(void *param, SDnodeWorker *pWorker, EWorkerType type, const char *name, int32_t minNum,
-                      int32_t maxNum, void *queueFp) {
-  if (pWorker == NULL || name == NULL || minNum < 0 || maxNum <= 0 || queueFp == NULL) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    return -1;
-  }
-
-  pWorker->type = type;
-  pWorker->name = name;
-  pWorker->minNum = minNum;
-  pWorker->maxNum = maxNum;
-  pWorker->queueFp = queueFp;
-  pWorker->param = param;
-
-  if (pWorker->type == DND_WORKER_SINGLE) {
-    SQWorkerPool *pPool = &pWorker->pool;
-    pPool->name = name;
-    pPool->min = minNum;
-    pPool->max = maxNum;
-    if (tQWorkerInit(pPool) != 0) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
-    }
-    pWorker->queue = tQWorkerAllocQueue(pPool, param, (FItem)queueFp);
-    if (pWorker->queue == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
-    }
-  } else if (pWorker->type == DND_WORKER_MULTI) {
-    SWWorkerPool *pPool = &pWorker->mpool;
-    pPool->name = name;
-    pPool->max = maxNum;
-    if (tWWorkerInit(pPool) != 0) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
-    }
-    pWorker->queue = tWWorkerAllocQueue(pPool, param, (FItems)queueFp);
-    if (pWorker->queue == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
-    }
-  } else {
-    terrno = TSDB_CODE_INVALID_PARA;
-  }
-
-  return 0;
-}
-
-void dndCleanupWorker(SDnodeWorker *pWorker) {
-  if (pWorker->queue == NULL) return;
-
-  while (!taosQueueEmpty(pWorker->queue)) {
-    taosMsleep(10);
-  }
-
-  if (pWorker->type == DND_WORKER_SINGLE) {
-    tQWorkerCleanup(&pWorker->pool);
-    tQWorkerFreeQueue(&pWorker->pool, pWorker->queue);
-  } else if (pWorker->type == DND_WORKER_MULTI) {
-    tWWorkerCleanup(&pWorker->mpool);
-    tWWorkerFreeQueue(&pWorker->mpool, pWorker->queue);
-  } else {
-  }
-}
-
-int32_t dndWriteMsgToWorker(SDnodeWorker *pWorker, void *pMsg) {
-  if (pWorker == NULL || pWorker->queue == NULL) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    return -1;
-  }
-
-  if (taosWriteQitem(pWorker->queue, pMsg) != 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  return 0;
-}

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

@@ -29,10 +29,10 @@ typedef struct SDnodeMgmt {
   SEpSet        mnodeEpSet;
   SHashObj     *dnodeHash;
   SArray       *dnodeEps;
-  TdThread    *threadId;
+  TdThread     *threadId;
   SRWLatch      latch;
-  SDnodeWorker  mgmtWorker;
-  SDnodeWorker  statusWorker;
+  SSingleWorker mgmtWorker;
+  SSingleWorker statusWorker;
   const char   *path;
   SDnode       *pDnode;
   SMgmtWrapper *pWrapper;

source/dnode/mgmt/dnode/src/dmMsg.c

@@ -114,19 +114,19 @@ int32_t dmProcessConfigReq(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
 
 void dmInitMsgHandles(SMgmtWrapper *pWrapper) {
   // Requests handled by DNODE
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_DND_NETWORK_TEST, (NodeMsgFp)dmProcessMgmtMsg);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_MNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_MNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_QNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_QNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_SNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_SNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CREATE_BNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_DROP_BNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_CONFIG_DNODE, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_DND_NETWORK_TEST, (NodeMsgFp)dmProcessMgmtMsg, 0);
 
   // Requests handled by MNODE
-  dndSetMsgHandle(pWrapper, TDMT_MND_STATUS_RSP, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, (NodeMsgFp)dmProcessMgmtMsg);
-  dndSetMsgHandle(pWrapper, TDMT_MND_AUTH_RSP, (NodeMsgFp)dmProcessMgmtMsg);
+  dndSetMsgHandle(pWrapper, TDMT_MND_STATUS_RSP, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, (NodeMsgFp)dmProcessMgmtMsg, 0);
+  dndSetMsgHandle(pWrapper, TDMT_MND_AUTH_RSP, (NodeMsgFp)dmProcessMgmtMsg, 0);
 }

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

@@ -52,10 +52,12 @@ static void *dmThreadRoutine(void *param) {
   }
 }
 
-static void dmProcessQueue(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
-  SDnode *pDnode = pMgmt->pDnode;
+static void dmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+  SDnodeMgmt *pMgmt = pInfo->ahandle;
+
+  SDnode  *pDnode = pMgmt->pDnode;
   SRpcMsg *pRpc = &pMsg->rpcMsg;
-  int32_t code = -1;
+  int32_t  code = -1;
   dTrace("msg:%p, will be processed in dnode queue", pMsg);
 
   switch (pRpc->msgType) {
@@ -98,13 +100,17 @@ static void dmProcessQueue(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
 }
 
 int32_t dmStartWorker(SDnodeMgmt *pMgmt) {
-  if (dndInitWorker(pMgmt, &pMgmt->mgmtWorker, DND_WORKER_SINGLE, "dnode-mgmt", 1, 1, dmProcessQueue) != 0) {
+  SSingleWorkerCfg mgmtCfg = {
+      .minNum = 1, .maxNum = 1, .name = "dnode-mgmt", .fp = (FItem)dmProcessQueue, .param = pMgmt};
+  if (tSingleWorkerInit(&pMgmt->mgmtWorker, &mgmtCfg) != 0) {
     dError("failed to start dnode mgmt worker since %s", terrstr());
     return -1;
   }
 
-  if (dndInitWorker(pMgmt, &pMgmt->statusWorker, DND_WORKER_SINGLE, "dnode-status", 1, 1, dmProcessQueue) != 0) {
-    dError("failed to start dnode mgmt worker since %s", terrstr());
+  SSingleWorkerCfg statusCfg = {
+      .minNum = 1, .maxNum = 1, .name = "dnode-status", .fp = (FItem)dmProcessQueue, .param = pMgmt};
+  if (tSingleWorkerInit(&pMgmt->statusWorker, &statusCfg) != 0) {
+    dError("failed to start dnode status worker since %s", terrstr());
     return -1;
   }
 
@@ -123,8 +129,8 @@ int32_t dmStartThread(SDnodeMgmt *pMgmt) {
 }
 
 void dmStopWorker(SDnodeMgmt *pMgmt) {
-  dndCleanupWorker(&pMgmt->mgmtWorker);
-  dndCleanupWorker(&pMgmt->statusWorker);
+  tSingleWorkerCleanup(&pMgmt->mgmtWorker);
+  tSingleWorkerCleanup(&pMgmt->statusWorker);
 
   if (pMgmt->threadId != NULL) {
     taosDestoryThread(pMgmt->threadId);
@@ -133,11 +139,11 @@ void dmStopWorker(SDnodeMgmt *pMgmt) {
 }
 
 int32_t dmProcessMgmtMsg(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
-  SDnodeWorker *pWorker = &pMgmt->mgmtWorker;
+  SSingleWorker *pWorker = &pMgmt->mgmtWorker;
   if (pMsg->rpcMsg.msgType == TDMT_MND_STATUS_RSP) {
     pWorker = &pMgmt->statusWorker;
   }
 
   dTrace("msg:%p, will be written to worker %s", pMsg, pWorker->name);
-  return dndWriteMsgToWorker(pWorker, pMsg);
+  return taosWriteQitem(pWorker->queue, pMsg);
 }

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

@@ -28,9 +28,9 @@ typedef struct SMnodeMgmt {
   SDnode       *pDnode;
   SMgmtWrapper *pWrapper;
   const char   *path;
-  SDnodeWorker  readWorker;
-  SDnodeWorker  writeWorker;
-  SDnodeWorker  syncWorker;
+  SSingleWorker readWorker;
+  SSingleWorker writeWorker;
+  SSingleWorker syncWorker;
   SReplica      replicas[TSDB_MAX_REPLICA];
   int8_t        replica;
   int8_t        selfIndex;

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

@@ -39,14 +39,17 @@ static int32_t mmRequire(SMgmtWrapper *pWrapper, bool *required) {
 
 static void mmInitOption(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {
   SDnode *pDnode = pMgmt->pDnode;
-  pOption->pWrapper = pMgmt->pWrapper;
-  pOption->putToWriteQFp = mmPutMsgToWriteQueue;
-  pOption->putToReadQFp = mmPutMsgToReadQueue;
-  pOption->sendReqFp = dndSendReqToDnode;
-  pOption->sendMnodeReqFp = dndSendReqToMnode;
-  pOption->sendRspFp = dndSendRsp;
   pOption->dnodeId = pDnode->dnodeId;
   pOption->clusterId = pDnode->clusterId;
+
+  SMsgCb msgCb = {0};
+  msgCb.pWrapper = pMgmt->pWrapper;
+  msgCb.queueFps[QUERY_QUEUE] = mmPutMsgToReadQueue;
+  msgCb.queueFps[WRITE_QUEUE] = mmPutMsgToWriteQueue;
+  msgCb.sendReqFp = dndSendReqToDnode;
+  msgCb.sendMnodeReqFp = dndSendReqToMnode;
+  msgCb.sendRspFp = dndSendRsp;
+  pOption->msgCb = msgCb;
 }
 
 static void mmBuildOptionForDeploy(SMnodeMgmt *pMgmt, SMnodeOpt *pOption) {

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

@@ -16,7 +16,9 @@
 #define _DEFAULT_SOURCE
 #include "mmInt.h"
 
-static void mmProcessQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+static void mmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
+  SMnodeMgmt *pMgmt = pInfo->ahandle;
+
   dTrace("msg:%p, will be processed in mnode queue", pMsg);
   SRpcMsg *pRpc = &pMsg->rpcMsg;
   int32_t  code = -1;
@@ -42,34 +44,9 @@ static void mmProcessQueue(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   taosFreeQitem(pMsg);
 }
 
-int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
-  if (dndInitWorker(pMgmt, &pMgmt->readWorker, DND_WORKER_SINGLE, "mnode-read", 0, 1, mmProcessQueue) != 0) {
-    dError("failed to start mnode read worker since %s", terrstr());
-    return -1;
-  }
-
-  if (dndInitWorker(pMgmt, &pMgmt->writeWorker, DND_WORKER_SINGLE, "mnode-write", 0, 1, mmProcessQueue) != 0) {
-    dError("failed to start mnode write worker since %s", terrstr());
-    return -1;
-  }
-
-  if (dndInitWorker(pMgmt, &pMgmt->syncWorker, DND_WORKER_SINGLE, "mnode-sync", 0, 1, mmProcessQueue) != 0) {
-    dError("failed to start mnode sync worker since %s", terrstr());
-    return -1;
-  }
-
-  return 0;
-}
-
-void mmStopWorker(SMnodeMgmt *pMgmt) {
-  dndCleanupWorker(&pMgmt->readWorker);
-  dndCleanupWorker(&pMgmt->writeWorker);
-  dndCleanupWorker(&pMgmt->syncWorker);
-}
-
-static int32_t mmPutMsgToWorker(SMnodeMgmt *pMgmt, SDnodeWorker *pWorker, SNodeMsg *pMsg) {
+static int32_t mmPutMsgToWorker(SMnodeMgmt *pMgmt, SSingleWorker *pWorker, SNodeMsg *pMsg) {
   dTrace("msg:%p, put into worker %s", pMsg, pWorker->name);
-  return dndWriteMsgToWorker(pWorker, pMsg);
+  return taosWriteQitem(pWorker->queue, pMsg);
 }
 
 int32_t mmProcessWriteMsg(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
@@ -84,16 +61,16 @@ int32_t mmProcessReadMsg(SMnodeMgmt *pMgmt, SNodeMsg *pMsg) {
   return mmPutMsgToWorker(pMgmt, &pMgmt->readWorker, pMsg);
 }
 
-static int32_t mmPutRpcMsgToWorker(SMnodeMgmt *pMgmt, SDnodeWorker *pWorker, SRpcMsg *pRpc) {
+static int32_t mmPutRpcMsgToWorker(SMnodeMgmt *pMgmt, SSingleWorker *pWorker, SRpcMsg *pRpc) {
   SNodeMsg *pMsg = taosAllocateQitem(sizeof(SNodeMsg));
   if (pMsg == NULL) {
     return -1;
   }
 
-  dTrace("msg:%p, is created, type:%s", pMsg, TMSG_INFO(pRpc->msgType));
+  dTrace("msg:%p, is created and put into worker:%s, type:%s", pMsg, pWorker->name, TMSG_INFO(pRpc->msgType));
   pMsg->rpcMsg = *pRpc;
 
-  int32_t code = mmPutMsgToWorker(pMgmt, pWorker, pMsg);
+  int32_t code = taosWriteQitem(pWorker->queue, pMsg);
   if (code != 0) {
     dTrace("msg:%p, is freed", pMsg);
     taosFreeQitem(pMsg);
@@ -112,3 +89,30 @@ int32_t mmPutMsgToReadQueue(SMgmtWrapper *pWrapper, SRpcMsg *pRpc) {
   SMnodeMgmt *pMgmt = pWrapper->pMgmt;
   return mmPutRpcMsgToWorker(pMgmt, &pMgmt->readWorker, pRpc);
 }
+
+int32_t mmStartWorker(SMnodeMgmt *pMgmt) {
+  SSingleWorkerCfg cfg = {.minNum = 0, .maxNum = 1, .name = "mnode-read", .fp = (FItem)mmProcessQueue, .param = pMgmt};
+
+  if (tSingleWorkerInit(&pMgmt->readWorker, &cfg) != 0) {
+    dError("failed to start mnode-read worker since %s", terrstr());
+    return -1;
+  }
+
+  if (tSingleWorkerInit(&pMgmt->writeWorker, &cfg) != 0) {
+    dError("failed to start mnode-write worker since %s", terrstr());
+    return -1;
+  }
+
+  if (tSingleWorkerInit(&pMgmt->syncWorker, &cfg) != 0) {
+    dError("failed to start mnode sync-worker since %s", terrstr());
+    return -1;
+  }
+
+  return 0;
+}
+
+void mmStopWorker(SMnodeMgmt *pMgmt) {
+  tSingleWorkerCleanup(&pMgmt->readWorker);
+  tSingleWorkerCleanup(&pMgmt->writeWorker);
+  tSingleWorkerCleanup(&pMgmt->syncWorker);
+}

source/dnode/mgmt/qnode/inc/qmInt.h

@@ -28,8 +28,8 @@ typedef struct SQnodeMgmt {
   SDnode       *pDnode;
   SMgmtWrapper *pWrapper;
   const char   *path;
-  SDnodeWorker  queryWorker;
-  SDnodeWorker  fetchWorker;
+  SSingleWorker queryWorker;
+  SSingleWorker fetchWorker;
 } SQnodeMgmt;
 
 // qmInt.c
@@ -42,6 +42,10 @@ int32_t qmProcessCreateReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
 int32_t qmProcessDropReq(SMgmtWrapper *pWrapper, SNodeMsg *pMsg);
 
 // qmWorker.c
+int32_t qmPutMsgToQueryQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
+int32_t qmPutMsgToFetchQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg);
+int32_t qmGetQueueSize(SMgmtWrapper *pWrapper, int32_t vgId, EQueueType qtype);
+
 int32_t qmStartWorker(SQnodeMgmt *pMgmt);
 void    qmStopWorker(SQnodeMgmt *pMgmt);
 int32_t qmProcessQueryMsg(SQnodeMgmt *pMgmt, SNodeMsg *pMsg);