Merge branch '3.0' into feature/vnode

.devcontainer/Dockerfile

+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.209.3/containers/cpp/.devcontainer/base.Dockerfile
+
+# [Choice] Debian / Ubuntu version (use Debian 11/9, Ubuntu 18.04/21.04 on local arm64/Apple Silicon): debian-11, debian-10, debian-9, ubuntu-21.04, ubuntu-20.04, ubuntu-18.04
+ARG VARIANT="bullseye"
+FROM mcr.microsoft.com/vscode/devcontainers/cpp:0-${VARIANT}
+
+# [Optional] Uncomment this section to install additional packages.
+# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+#     && apt-get -y install --no-install-recommends <your-package-list-here>

.devcontainer/devcontainer.json

+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.209.3/containers/cpp
+{
+	"name": "C++",
+	"build": {
+		"dockerfile": "Dockerfile",
+		// Update 'VARIANT' to pick an Debian / Ubuntu OS version: debian-11, debian-10, debian-9, ubuntu-21.04, ubuntu-20.04, ubuntu-18.04
+		// Use Debian 11, Debian 9, Ubuntu 18.04 or Ubuntu 21.04 on local arm64/Apple Silicon
+		"args": { "VARIANT": "ubuntu-21.04" }
+	},
+	"runArgs": ["--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined"],
+
+	// Set *default* container specific settings.json values on container create.
+	"settings": {},
+
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"ms-vscode.cpptools",
+		"ms-vscode.cmake-tools",
+		"austin.code-gnu-global",
+		"visualstudioexptteam.vscodeintel"
+	],
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "gcc -v",
+
+	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "vscode"
+}

include/client/taos.h

@@ -39,7 +39,7 @@ typedef void **TAOS_ROW;
 #define TSDB_DATA_TYPE_BIGINT     5     // 8 bytes
 #define TSDB_DATA_TYPE_FLOAT      6     // 4 bytes
 #define TSDB_DATA_TYPE_DOUBLE     7     // 8 bytes
-#define TSDB_DATA_TYPE_BINARY     8     // string
+#define TSDB_DATA_TYPE_BINARY     8     // string, alias for varchar
 #define TSDB_DATA_TYPE_TIMESTAMP  9     // 8 bytes
 #define TSDB_DATA_TYPE_NCHAR      10    // unicode string
 #define TSDB_DATA_TYPE_UTINYINT   11    // 1 byte
@@ -47,10 +47,10 @@ typedef void **TAOS_ROW;
 #define TSDB_DATA_TYPE_UINT       13    // 4 bytes
 #define TSDB_DATA_TYPE_UBIGINT    14    // 8 bytes
 #define TSDB_DATA_TYPE_VARCHAR    15    // string
-#define TSDB_DATA_TYPE_JSON       16    // json
-#define TSDB_DATA_TYPE_DECIMAL    17    // decimal
-#define TSDB_DATA_TYPE_BLOB       18    // binary string
-#define TSDB_DATA_TYPE_LONGBLOB   19    // long binary string
+#define TSDB_DATA_TYPE_VARBINARY  16    // binary
+#define TSDB_DATA_TYPE_JSON       17    // json
+#define TSDB_DATA_TYPE_DECIMAL    18    // decimal
+#define TSDB_DATA_TYPE_BLOB       19    // binary
 
 typedef enum {
   TSDB_OPTION_LOCALE,
@@ -61,10 +61,27 @@ typedef enum {
   TSDB_MAX_OPTIONS
 } TSDB_OPTION;
 
+typedef enum {
+  TSDB_SML_UNKNOWN_PROTOCOL = 0,
+  TSDB_SML_LINE_PROTOCOL    = 1,
+  TSDB_SML_TELNET_PROTOCOL  = 2,
+  TSDB_SML_JSON_PROTOCOL    = 3,
+} TSDB_SML_PROTOCOL_TYPE;
+
+typedef enum {
+  TSDB_SML_TIMESTAMP_NOT_CONFIGURED = 0,
+  TSDB_SML_TIMESTAMP_HOURS,
+  TSDB_SML_TIMESTAMP_MINUTES,
+  TSDB_SML_TIMESTAMP_SECONDS,
+  TSDB_SML_TIMESTAMP_MILLI_SECONDS,
+  TSDB_SML_TIMESTAMP_MICRO_SECONDS,
+  TSDB_SML_TIMESTAMP_NANO_SECONDS,
+} TSDB_SML_TIMESTAMP_TYPE;
+
 typedef struct taosField {
   char     name[65];
-  uint8_t  type;
-  int16_t  bytes;
+  int8_t   type;
+  int32_t  bytes;
 } TAOS_FIELD;
 
 #ifdef _TD_GO_DLL_
@@ -136,12 +153,15 @@ DLL_EXPORT int        taos_stmt_close(TAOS_STMT *stmt);
 DLL_EXPORT char *     taos_stmt_errstr(TAOS_STMT *stmt);
 
 DLL_EXPORT TAOS_RES *taos_query(TAOS *taos, const char *sql);
+DLL_EXPORT TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen);
+
 DLL_EXPORT TAOS_ROW taos_fetch_row(TAOS_RES *res);
 DLL_EXPORT int  taos_result_precision(TAOS_RES *res);  // get the time precision of result
 DLL_EXPORT void taos_free_result(TAOS_RES *res);
 DLL_EXPORT int  taos_field_count(TAOS_RES *res);
 DLL_EXPORT int  taos_num_fields(TAOS_RES *res);
 DLL_EXPORT int  taos_affected_rows(TAOS_RES *res);
+
 DLL_EXPORT TAOS_FIELD *taos_fetch_fields(TAOS_RES *res);
 DLL_EXPORT int  taos_select_db(TAOS *taos, const char *db);
 DLL_EXPORT int  taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
@@ -152,21 +172,17 @@ DLL_EXPORT int taos_validate_sql(TAOS *taos, const char *sql);
 
 DLL_EXPORT int* taos_fetch_lengths(TAOS_RES *res);
 
-// TAOS_RES   *taos_list_tables(TAOS *mysql, const char *wild);
-// TAOS_RES   *taos_list_dbs(TAOS *mysql, const char *wild);
-
-// TODO: the return value should be `const`
 DLL_EXPORT const char *taos_get_server_info(TAOS *taos);
 DLL_EXPORT const char *taos_get_client_info();
-DLL_EXPORT const char *taos_errstr(TAOS_RES *tres);
 
+DLL_EXPORT const char *taos_errstr(TAOS_RES *tres);
 DLL_EXPORT int   taos_errno(TAOS_RES *tres);
 
 DLL_EXPORT void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param);
 DLL_EXPORT void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param);
 
-typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code);
-DLL_EXPORT TAOS_SUB *taos_subscribe(TAOS* taos, int restart, const char* topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp, void *param, int interval);
+typedef void (*__taos_sub_fn_t)(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code);
+DLL_EXPORT TAOS_SUB *taos_subscribe(TAOS* taos, int restart, const char* topic, const char *sql, __taos_sub_fn_t fp, void *param, int interval);
 DLL_EXPORT TAOS_RES *taos_consume(TAOS_SUB *tsub);
 DLL_EXPORT void      taos_unsubscribe(TAOS_SUB *tsub, int keepProgress);
 
@@ -175,8 +191,7 @@ DLL_EXPORT TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sql, void (*fp)
 DLL_EXPORT void taos_close_stream(TAOS_STREAM *tstr);
 
 DLL_EXPORT int taos_load_table_info(TAOS *taos, const char* tableNameList);
-
-DLL_EXPORT int taos_insert_lines(TAOS* taos, char* lines[], int numLines);
+DLL_EXPORT TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int protocol, int precision);
 
 #ifdef __cplusplus
 }

include/common/taosmsg.h

@@ -50,8 +50,7 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_CONSUME, "mq-consume" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_QUERY, "mq-query" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_CONNECT, "mq-connect" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_DISCONNECT, "mq-disconnect" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_ACK, "mq-ack" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_RESET, "mq-reset" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_MQ_SET, "mq-set" )
 // message from client to mnode
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CONNECT, "connect" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CREATE_ACCT, "create-acct" )	
@@ -221,11 +220,9 @@ typedef struct SBuildTableMetaInput {
 
 typedef struct SBuildUseDBInput {
   char    db[TSDB_TABLE_FNAME_LEN];
-  int32_t vgroupVersion;
-  int32_t dbGroupVersion;
+  int32_t vgVersion;
 } SBuildUseDBInput;
 
-
 #pragma pack(push, 1)
 
 // null-terminated string instead of char array to avoid too many memory consumption in case of more than 1M tableMeta
@@ -235,7 +232,7 @@ typedef struct {
 } SEpAddrMsg;
 
 typedef struct {
-  char*    fqdn;
+  char    *fqdn;
   uint16_t port;
 } SEpAddr1;
 
@@ -407,8 +404,10 @@ typedef struct {
 } SDropUserMsg, SDropAcctMsg;
 
 typedef struct {
+  int8_t  type;
   char    user[TSDB_USER_LEN];
   char    pass[TSDB_PASSWORD_LEN];
+  int8_t  superUser;      // denote if it is a super user or not
   int32_t reserve[8];
 } SCreateUserMsg, SAlterUserMsg;
 
@@ -457,7 +456,7 @@ typedef struct SColumnFilterInfo {
 
 typedef struct SColumnFilterList {
   int16_t numOfFilters;
-  union{
+  union {
     int64_t            placeholder;
     SColumnFilterInfo *filterInfo;
   };
@@ -509,7 +508,7 @@ typedef struct {
   bool interpQuery;        // interp query or not
   bool groupbyColumn;      // denote if this is a groupby normal column query
   bool hasTagResults;      // if there are tag values in final result or not
-  bool        timeWindowInterpo;// if the time window start/end required interpolation
+  bool timeWindowInterpo;  // if the time window start/end required interpolation
   bool queryBlockDist;     // if query data block distribution
   bool stabledev;          // super table stddev query
   bool tsCompQuery;        // is tscomp query
@@ -524,7 +523,7 @@ typedef struct {
   int16_t     orderColId;
   int16_t     numOfCols;  // the number of columns will be load from vnode
   SInterval   interval;
-//  SSessionWindow sw;            // session window
+  //  SSessionWindow sw;            // session window
   int16_t tagCondLen;      // tag length in current query
   int16_t colCondLen;      // column length in current query
   int16_t numOfGroupCols;  // num of group by columns
@@ -544,7 +543,7 @@ typedef struct {
   int32_t     sqlstrLen;      // sql query string
   int32_t     prevResultLen;  // previous result length
   int32_t     numOfOperator;
-  int32_t     tableScanOperator;// table scan operator. -1 means no scan operator
+  int32_t     tableScanOperator;  // table scan operator. -1 means no scan operator
   int32_t     udfNum;             // number of udf function
   int32_t     udfContentOffset;
   int32_t     udfContentLen;
@@ -571,19 +570,19 @@ typedef struct {
 } SRetrieveTableMsg;
 
 typedef struct SRetrieveTableRsp {
-  int32_t numOfRows;
-  int64_t offset;  // updated offset value for multi-vnode projection query
   int64_t useconds;
   int8_t  completed;  // all results are returned to client
   int8_t  precision;
   int8_t  compressed;
-  int8_t  reserved;
   int32_t compLen;
+
+  int32_t numOfRows;
   char    data[];
 } SRetrieveTableRsp;
 
 typedef struct {
   char    db[TSDB_FULL_DB_NAME_LEN];
+  int32_t numOfVgroups;
   int32_t cacheBlockSize;  // MB
   int32_t totalBlocks;
   int32_t daysPerFile;
@@ -626,9 +625,7 @@ typedef struct {
 
 typedef struct {
   char    db[TSDB_TABLE_FNAME_LEN];
-  int8_t  ignoreNotExists;
-  int32_t vgroupVersion;
-  int32_t dbGroupVersion;
+  int32_t vgVersion;
   int32_t reserve[8];
 } SUseDbMsg;
 
@@ -808,6 +805,9 @@ typedef struct SSTableVgroupMsg {
 
 typedef struct SVgroupInfo {
   int32_t    vgId;
+  uint32_t   hashBegin;
+  uint32_t   hashEnd;
+  int8_t     inUse;
   int8_t     numOfEps;
   SEpAddrMsg epAddr[TSDB_MAX_REPLICA];
 } SVgroupInfo;
@@ -830,7 +830,7 @@ typedef struct {
 } SVgroupsMsg, SVgroupsInfo;
 
 typedef struct {
-  char       tbFname[TSDB_TABLE_FNAME_LEN];  // table id
+  char     tbFname[TSDB_TABLE_FNAME_LEN];  // table full name
   char     stbFname[TSDB_TABLE_FNAME_LEN];
   int32_t  numOfTags;
   int32_t  numOfColumns;
@@ -863,18 +863,12 @@ typedef struct {
 } STagData;
 
 typedef struct {
-  int32_t     vgroupNum;
-  int32_t     vgroupVersion;
-  char        db[TSDB_TABLE_FNAME_LEN];
-  int32_t     dbVgroupVersion;
-  int32_t     dbVgroupNum;
-  int32_t     dbHashRange;
-  int32_t     dbHashType;
+  char        db[TSDB_FULL_DB_NAME_LEN];
+  int32_t     vgVersion;
+  int32_t     vgNum;
+  int8_t      hashMethod;
   SVgroupInfo vgroupInfo[];
-//int32_t     vgIdList[];
-} SUseDbRspMsg;
-
-
+} SUseDbRsp;
 
 /*
  * sql: show tables like '%a_%'
@@ -1018,37 +1012,29 @@ typedef struct {
 
 // mq related
 typedef struct {
-
 } SMqConnectReq;
 
 typedef struct {
-
 } SMqConnectRsp;
 
 typedef struct {
-
 } SMqDisconnectReq;
 
 typedef struct {
-
 } SMqDisconnectRsp;
 
 typedef struct {
-
 } SMqAckReq;
 
 typedef struct {
-
 } SMqAckRsp;
 
 typedef struct {
-
 } SMqResetReq;
 
 typedef struct {
-
 } SMqResetRsp;
-//mq related end
+// mq related end
 
 typedef struct {
   /* data */
@@ -1102,7 +1088,6 @@ typedef struct {
   /* data */
 } SUpdateTagValRsp;
 
-
 #pragma pack(pop)
 
 #ifdef __cplusplus

include/common/tmsgtype.h

@@ -62,7 +62,7 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CFG_DNODE, "cfg-dnode" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CFG_MNODE, "cfg-mnode" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW, "show" )
-  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RETRIEVE, "retrieve" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RETRIEVE_MNODE, "retrieve" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_KILL_QUERY, "kill-query" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_KILL_STREAM, "kill-stream" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_KILL_CONNECTION, "kill-connection" )

include/dnode/vnode/tq/tq.h

@@ -16,9 +16,9 @@
 #ifndef _TD_TQ_H_
 #define _TD_TQ_H_
 
+#include "mallocator.h"
 #include "os.h"
 #include "tutil.h"
-#include "mallocator.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -62,10 +62,10 @@ typedef struct TmqDisconnectRsp {
   int8_t     status;
 } TmqDisconnectRsp;
 
-typedef struct TmqConsumeReq {
+typedef struct STqConsumeReq {
   TmqMsgHead head;
   TmqAcks    acks;
-} TmqConsumeReq;
+} STqConsumeReq;
 
 typedef struct TmqMsgContent {
   int64_t topicId;
@@ -73,11 +73,11 @@ typedef struct TmqMsgContent {
   char    msg[];
 } TmqMsgContent;
 
-typedef struct TmqConsumeRsp {
+typedef struct STqConsumeRsp {
   TmqMsgHead    head;
   int64_t       bodySize;
   TmqMsgContent msgs[];
-} TmqConsumeRsp;
+} STqConsumeRsp;
 
 typedef struct TmqSubscribeReq {
   TmqMsgHead head;
@@ -97,102 +97,102 @@ typedef struct TmqHeartbeatReq {
 typedef struct TmqHeartbeatRsp {
 } TmqHeartbeatRsp;
 
-typedef struct TqTopicVhandle {
+typedef struct STqTopicVhandle {
   int64_t topicId;
   // executor for filter
   void* filterExec;
   // callback for mnode
   // trigger when vnode list associated topic change
   void* (*mCallback)(void*, void*);
-} TqTopicVhandle;
-
+} STqTopicVhandle;
 
 #define TQ_BUFFER_SIZE 8
 
-typedef struct TqBufferItem {
+typedef struct STqBufferItem {
   int64_t offset;
   // executors are identical but not concurrent
   // so there must be a copy in each item
   void*   executor;
   int64_t size;
   void*   content;
-} TqBufferItem;
+} STqBufferItem;
 
-typedef struct TqBufferHandle {
+typedef struct STqBufferHandle {
   // char* topic; //c style, end with '\0'
   // int64_t cgId;
   // void* ahandle;
   int64_t       nextConsumeOffset;
+  int64_t       floatingCursor;
   int64_t       topicId;
   int32_t       head;
   int32_t       tail;
-  TqBufferItem buffer[TQ_BUFFER_SIZE];
-} TqBufferHandle;
+  STqBufferItem buffer[TQ_BUFFER_SIZE];
+} STqBufferHandle;
 
-typedef struct TqListHandle {
-  TqBufferHandle       bufHandle;
-  struct TqListHandle* next;
-} TqListHandle;
+typedef struct STqListHandle {
+  STqBufferHandle       bufHandle;
+  struct STqListHandle* next;
+} STqListHandle;
 
-typedef struct TqGroupHandle {
+typedef struct STqGroupHandle {
   int64_t        cId;
   int64_t        cgId;
   void*          ahandle;
   int32_t        topicNum;
-  TqListHandle* head;
-} TqGroupHandle;
+  STqListHandle* head;
+} STqGroupHandle;
 
-typedef struct TqQueryExec {
+typedef struct STqQueryExec {
   void*          src;
-  TqBufferItem* dest;
+  STqBufferItem* dest;
   void*          executor;
-} TqQueryExec;
+} STqQueryExec;
 
-typedef struct TqQueryMsg {
-  TqQueryExec*       exec;
-  struct TqQueryMsg* next;
-} TqQueryMsg;
+typedef struct STqQueryMsg {
+  STqQueryExec*       exec;
+  struct STqQueryMsg* next;
+} STqQueryMsg;
 
-typedef struct TqLogReader {
+typedef struct STqLogReader {
   void* logHandle;
   int32_t (*logRead)(void* logHandle, void** data, int64_t ver);
   int64_t (*logGetFirstVer)(void* logHandle);
   int64_t (*logGetSnapshotVer)(void* logHandle);
   int64_t (*logGetLastVer)(void* logHandle);
-} TqLogReader;
+} STqLogReader;
 
 typedef struct STqCfg {
   // TODO
 } STqCfg;
 
-typedef struct TqMemRef {
-  SMemAllocatorFactory *pAlloctorFactory;
-  SMemAllocator *pAllocator;
-} TqMemRef;
+typedef struct STqMemRef {
+  SMemAllocatorFactory* pAlloctorFactory;
+  SMemAllocator*        pAllocator;
+} STqMemRef;
 
-typedef struct TqSerializedHead {
+typedef struct STqSerializedHead {
   int16_t ver;
   int16_t action;
   int32_t checksum;
   int64_t ssize;
   char    content[];
-} TqSerializedHead;
+} STqSerializedHead;
 
-typedef int (*TqSerializeFun)(const void* pObj, TqSerializedHead** ppHead);
-typedef const void* (*TqDeserializeFun)(const TqSerializedHead* pHead, void** ppObj);
-typedef void (*TqDeleteFun)(void*);
+typedef int (*FTqSerialize)(const void* pObj, STqSerializedHead** ppHead);
+typedef const void* (*FTqDeserialize)(const STqSerializedHead* pHead, void** ppObj);
+typedef void (*FTqDelete)(void*);
 
 #define TQ_BUCKET_MASK 0xFF
 #define TQ_BUCKET_SIZE 256
 
 #define TQ_PAGE_SIZE 4096
-//key + offset + size
+// key + offset + size
 #define TQ_IDX_SIZE 24
-//4096 / 24
+// 4096 / 24
 #define TQ_MAX_IDX_ONE_PAGE 170
-//24 * 170
+// 24 * 170
 #define TQ_IDX_PAGE_BODY_SIZE 4080
-//4096 - 4080
+// 4096 - 4080
 #define TQ_IDX_PAGE_HEAD_SIZE 16
 
 #define TQ_ACTION_CONST 0
@@ -202,22 +202,19 @@ typedef void (*TqDeleteFun)(void*);
 
 #define TQ_SVER 0
 
-//TODO: inplace mode is not implemented
+// TODO: inplace mode is not implemented
 #define TQ_UPDATE_INPLACE 0
 #define TQ_UPDATE_APPEND 1
 
 #define TQ_DUP_INTXN_REWRITE 0
 #define TQ_DUP_INTXN_REJECT 2
 
-static inline bool TqUpdateAppend(int32_t tqConfigFlag) {
-  return tqConfigFlag & TQ_UPDATE_APPEND;
-}
+static inline bool TqUpdateAppend(int32_t tqConfigFlag) { return tqConfigFlag & TQ_UPDATE_APPEND; }
 
-static inline bool TqDupIntxnReject(int32_t tqConfigFlag) {
-  return tqConfigFlag & TQ_DUP_INTXN_REJECT;
-}
+static inline bool TqDupIntxnReject(int32_t tqConfigFlag) { return tqConfigFlag & TQ_DUP_INTXN_REJECT; }
 
 static const int8_t TQ_CONST_DELETE = TQ_ACTION_CONST;
+
 #define TQ_DELETE_TOKEN (void*)&TQ_CONST_DELETE
 
 typedef struct TqMetaHandle {
@@ -231,25 +228,25 @@ typedef struct TqMetaHandle {
 typedef struct TqMetaList {
   STqMetaHandle      handle;
   struct TqMetaList* next;
-  //struct TqMetaList* inTxnPrev;
-  //struct TqMetaList* inTxnNext;
+  // struct TqMetaList* inTxnPrev;
+  // struct TqMetaList* inTxnNext;
   struct TqMetaList* unpersistPrev;
   struct TqMetaList* unpersistNext;
 } STqMetaList;
 
 typedef struct TqMetaStore {
   STqMetaList* bucket[TQ_BUCKET_SIZE];
-  //a table head
+  // a table head
   STqMetaList* unpersistHead;
- //TODO:temporaral use, to be replaced by unified tfile
+  // TODO:temporaral use, to be replaced by unified tfile
   int fileFd;
-  //TODO:temporaral use, to be replaced by unified tfile
+  // TODO:temporaral use, to be replaced by unified tfile
   int            idxFd;
   char*          dirPath;
   int32_t        tqConfigFlag;
-  TqSerializeFun   pSerializer;
-  TqDeserializeFun pDeserializer;
-  TqDeleteFun      pDeleter;
+  FTqSerialize   pSerializer;
+  FTqDeserialize pDeserializer;
+  FTqDelete      pDeleter;
 } STqMetaStore;
 
 typedef struct STQ {
@@ -257,34 +254,35 @@ typedef struct STQ {
   // the handle of kvstore
   char*         path;
   STqCfg*       tqConfig;
-  TqLogReader* tqLogReader; 
-  TqMemRef     tqMemRef;
+  STqLogReader* tqLogReader;
+  STqMemRef     tqMemRef;
   STqMetaStore* tqMeta;
 } STQ;
 
 // open in each vnode
-STQ* tqOpen(const char* path, STqCfg* tqConfig, TqLogReader* tqLogReader, SMemAllocatorFactory *allocFac);
+STQ* tqOpen(const char* path, STqCfg* tqConfig, STqLogReader* tqLogReader, SMemAllocatorFactory* allocFac);
 void tqClose(STQ*);
 
 // void* will be replace by a msg type
 int tqPushMsg(STQ*, void* msg, int64_t version);
 int tqCommit(STQ*);
+int tqSetCursor(STQ*, void* msg);
 
-int tqConsume(STQ*, TmqConsumeReq*);
+int tqConsume(STQ*, STqConsumeReq*);
 
-TqGroupHandle* tqGetGroupHandle(STQ*, int64_t cId);
+STqGroupHandle* tqGetGroupHandle(STQ*, int64_t cId);
 
-TqGroupHandle* tqOpenTCGroup(STQ*, int64_t topicId, int64_t cgId, int64_t cId);
+STqGroupHandle* tqOpenTCGroup(STQ*, int64_t topicId, int64_t cgId, int64_t cId);
 int             tqCloseTCGroup(STQ*, int64_t topicId, int64_t cgId, int64_t cId);
-int tqMoveOffsetToNext(TqGroupHandle*);
+int             tqMoveOffsetToNext(STqGroupHandle*);
 int             tqResetOffset(STQ*, int64_t topicId, int64_t cgId, int64_t offset);
-int tqRegisterContext(TqGroupHandle*, void* ahandle);
-int tqLaunchQuery(TqGroupHandle*);
-int tqSendLaunchQuery(TqGroupHandle*);
+int             tqRegisterContext(STqGroupHandle*, void* ahandle);
+int             tqLaunchQuery(STqGroupHandle*);
+int             tqSendLaunchQuery(STqGroupHandle*);
 
-int   tqSerializeGroupHandle(const TqGroupHandle* gHandle, TqSerializedHead** ppHead);
+int tqSerializeGroupHandle(const STqGroupHandle* gHandle, STqSerializedHead** ppHead);
 
-const void* tqDeserializeGroupHandle(const TqSerializedHead* pHead, TqGroupHandle** gHandle);
+const void* tqDeserializeGroupHandle(const STqSerializedHead* pHead, STqGroupHandle** gHandle);
 
 #ifdef __cplusplus
 }

include/libs/catalog/catalog.h

@@ -32,8 +32,7 @@ extern "C" {
 struct SCatalog;
 
 typedef struct SCatalogReq {
-  char    dbName[TSDB_DB_NAME_LEN];
-  SArray *pTableName;     // table full name
+  SArray *pTableName;     // element is SNAME
   SArray *pUdf;           // udf name
   bool    qNodeRequired;  // valid qnode
 } SCatalogReq;
@@ -54,54 +53,86 @@ typedef struct SCatalogCfg {
 int32_t catalogInit(SCatalogCfg *cfg);
 
 /**
- * Catalog service object, which is utilized to hold tableMeta (meta/vgroupInfo/udfInfo) at the client-side.
- * There is ONLY one SCatalog object for one process space, and this function returns a singleton.
- * @param clusterId
- * @return
+ * Get a cluster's catalog handle for all later operations. 
+ * @param clusterId (input, end with \0)
+ * @param catalogHandle (output, NO need to free it)
+ * @return error code
  */
 int32_t catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandle);
 
-
-
-int32_t catalogGetVgroupVersion(struct SCatalog* pCatalog, int32_t* version);
-
-/**
- * get cluster vgroup list.
- * @pVgroupList  - hash of vgroup list, key:vgId, value:SVgroupInfo
- * @return
- */
-int32_t catalogGetVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, SHashObj** pVgroupHash);
-int32_t catalogUpdateVgroupCache(struct SCatalog* pCatalog, SVgroupListInfo* pVgroup);
-
-
-
 int32_t catalogGetDBVgroupVersion(struct SCatalog* pCatalog, const char* dbName, int32_t* version);
-int32_t catalogGetDBVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* dbName, int32_t forceUpdate, SDBVgroupInfo** dbInfo);
+int32_t catalogGetDBVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* dbName, int32_t forceUpdate, SDBVgroupInfo* dbInfo);
 int32_t catalogUpdateDBVgroupCache(struct SCatalog* pCatalog, const char* dbName, SDBVgroupInfo* dbInfo);
 
-
+/**
+ * Get a table's meta data. 
+ * @param pCatalog (input, got with catalogGetHandle)
+ * @param pRpc (input, rpc object)
+ * @param pMgmtEps (input, mnode EPs)
+ * @param pDBName (input, full db name)
+ * @param pTableName (input, table name, NOT including db name)
+ * @param pTableMeta(output, table meta data, NEED to free it by calller)
+ * @return error code
+ */
 int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta);
+
+/**
+ * Force renew a table's local cached meta data. 
+ * @param pCatalog (input, got with catalogGetHandle)
+ * @param pRpc (input, rpc object)
+ * @param pMgmtEps (input, mnode EPs)
+ * @param pDBName (input, full db name)
+ * @param pTableName (input, table name, NOT including db name)
+ * @return error code
+ */
 int32_t catalogRenewTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName);
+
+/**
+ * Force renew a table's local cached meta data and get the new one. 
+ * @param pCatalog (input, got with catalogGetHandle)
+ * @param pRpc (input, rpc object)
+ * @param pMgmtEps (input, mnode EPs)
+ * @param pDBName (input, full db name)
+ * @param pTableName (input, table name, NOT including db name)
+ * @param pTableMeta(output, table meta data, NEED to free it by calller) 
+ * @return error code
+ */
 int32_t catalogRenewAndGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta);
 
 
 /**
- * get table's vgroup list.
- * @param clusterId
- * @pVgroupList  - array of SVgroupInfo
- * @return
+ * Get a table's actual vgroup, for stable it's all possible vgroup list.
+ * @param pCatalog (input, got with catalogGetHandle)
+ * @param pRpc (input, rpc object)
+ * @param pMgmtEps (input, mnode EPs)
+ * @param pDBName (input, full db name)
+ * @param pTableName (input, table name, NOT including db name)
+ * @param pVgroupList (output, vgroup info list, element is SVgroupInfo, NEED to simply free the array by caller)
+ * @return error code
+ */
+int32_t catalogGetTableDistVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SArray* pVgroupList);
+
+/**
+ * Get a table's vgroup from its name's hash value.
+ * @param pCatalog (input, got with catalogGetHandle)
+ * @param pRpc (input, rpc object)
+ * @param pMgmtEps (input, mnode EPs)
+ * @param pDBName (input, full db name)
+ * @param pTableName (input, table name, NOT including db name)
+ * @param vgInfo (output, vgroup info)
+ * @return error code
  */
-int32_t catalogGetTableVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SArray* pVgroupList);
+int32_t catalogGetTableHashVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo);
 
 
 /**
- * Get the required meta data from mnode.
- * Note that this is a synchronized API and is also thread-safety.
- * @param pCatalog
- * @param pMgmtEps
- * @param pMetaReq
- * @param pMetaData
- * @return
+ * Get all meta data required in pReq.
+ * @param pCatalog (input, got with catalogGetHandle)
+ * @param pRpc (input, rpc object)
+ * @param pMgmtEps (input, mnode EPs)
+ * @param pReq (input, reqest info)
+ * @param pRsp (output, response data)
+ * @return error code 
  */
 int32_t catalogGetAllMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SCatalogReq* pReq, SMetaData* pRsp);
 
@@ -112,7 +143,6 @@ int32_t catalogGetQnodeList(struct SCatalog* pCatalog, const SEpSet* pMgmtEps, S
 
 /**
  * Destroy catalog and relase all resources
- * @param pCatalog
  */
 void catalogDestroy(void);
 

include/libs/index/index.h

@@ -28,6 +28,15 @@ typedef struct SIndexOpts SIndexOpts;
 typedef struct SIndexMultiTermQuery SIndexMultiTermQuery;
 typedef struct SArray               SIndexMultiTerm;
 
+typedef enum  {
+   ADD_VALUE,    // add index colume value   
+   DEL_VALUE,    // delete index column value  
+   UPDATE_VALUE, // update index column value 
+   ADD_INDEX,    // add index on specify column
+   DROP_INDEX,   // drop existed index 
+   DROP_SATBLE   // drop stable 
+} SIndexColumnType;
+
 typedef enum  { MUST = 0, SHOULD = 1, NOT = 2 } EIndexOperatorType;
 typedef enum  { QUERY_TERM = 0, QUERY_PREFIX = 1, QUERY_SUFFIX = 2,QUERY_REGEX = 3} EIndexQueryType;
 /*

include/libs/parser/parser.h

@@ -132,13 +132,15 @@ struct SInsertStmtInfo;
 bool qIsInsertSql(const char* pStr, size_t length);
 
 typedef struct SParseContext {
-  const char* pSql;    // sql string
-  size_t sqlLen;       // length of the sql string
-  int64_t id;          // operator id, generated by uuid generator
+  const char* pAcctId;
   const char* pDbname;
+  void *pRpc;
+  const char* pClusterId;
   const SEpSet* pEpSet;
+  int64_t id;          // query id, generated by uuid generator
   int8_t schemaAttached; // denote if submit block is built with table schema or not
-
+  const char* pSql;    // sql string
+  size_t sqlLen;       // length of the sql string
   char* pMsg;           // extended error message if exists to help avoid the problem in sql statement.
   int32_t msgLen;      // max length of the msg
 } SParseContext;
@@ -151,7 +153,7 @@ typedef struct SParseContext {
  * @param msg      extended error message if exists.
  * @return         error code
  */
-int32_t qParseQuerySql(const char* pStr, size_t length, struct SQueryStmtInfo** pQueryInfo, int64_t id, char* msg, int32_t msgLen);
+int32_t qParseQuerySql(const char* pStr, size_t length, int64_t id, int32_t* type, void** pOutput, int32_t* outputLen, char* msg, int32_t msgLen);
 
 typedef enum {
   PAYLOAD_TYPE_KV = 0,

include/libs/planner/planner.h

@@ -20,52 +20,92 @@
 extern "C" {
 #endif
 
+#include "taosmsg.h"
+
 #define QUERY_TYPE_MERGE       1
 #define QUERY_TYPE_PARTIAL     2
 #define QUERY_TYPE_SCAN        3
 
 enum OPERATOR_TYPE_E {
-  OP_TableScan         = 1,
-  OP_DataBlocksOptScan = 2,
-  OP_TableSeqScan      = 3,
-  OP_TagScan           = 4,
-  OP_TableBlockInfoScan= 5,
-  OP_Aggregate         = 6,
-  OP_Project           = 7,
-  OP_Groupby           = 8,
-  OP_Limit             = 9,
-  OP_SLimit            = 10,
-  OP_TimeWindow        = 11,
-  OP_SessionWindow     = 12,
-  OP_StateWindow       = 22,
-  OP_Fill              = 13,
-  OP_MultiTableAggregate     = 14,
-  OP_MultiTableTimeInterval  = 15,
-//  OP_DummyInput        = 16,   //TODO remove it after fully refactor.
-//  OP_MultiwayMergeSort = 17,   // multi-way data merge into one input stream.
-//  OP_GlobalAggregate   = 18,   // global merge for the multi-way data sources.
-  OP_Filter            = 19,
-  OP_Distinct          = 20,
-  OP_Join              = 21,
-  OP_AllTimeWindow     = 23,
-  OP_AllMultiTableTimeInterval = 24,
-  OP_Order             = 25,
-  OP_Exchange          = 26,
+  OP_Unknown,
+#define INCLUDE_AS_ENUM
+#include "plannerOp.h"
+#undef INCLUDE_AS_ENUM
+  OP_TotalNum
 };
 
 struct SEpSet;
-struct SQueryPlanNode;
-struct SPhyNode;
 struct SQueryStmtInfo;
 
+typedef SSchema SSlotSchema;
+
+typedef struct SDataBlockSchema {
+  SSlotSchema        *pSchema;
+  int32_t             numOfCols;    // number of columns
+} SDataBlockSchema;
+
+typedef struct SQueryNodeBasicInfo {
+  int32_t     type;          // operator type
+  const char *name;          // operator name
+} SQueryNodeBasicInfo;
+
+typedef struct SPhyNode {
+  SQueryNodeBasicInfo info;
+  SArray             *pTargets;      // target list to be computed or scanned at this node
+  SArray             *pConditions;   // implicitly-ANDed qual conditions
+  SDataBlockSchema    targetSchema;
+  // children plan to generated result for current node to process
+  // in case of join, multiple plan nodes exist.
+  SArray             *pChildren;
+  struct SPhyNode    *pParent;
+} SPhyNode;
+
+typedef struct SScanPhyNode {
+  SPhyNode    node;
+  uint64_t    uid;  // unique id of the table
+  int8_t      tableType;
+} SScanPhyNode;
+
+typedef SScanPhyNode SSystemTableScanPhyNode;
+typedef SScanPhyNode STagScanPhyNode;
+
+typedef struct STableScanPhyNode {
+  SScanPhyNode scan;
+  uint8_t      scanFlag;         // denotes reversed scan of data or not
+  STimeWindow  window;
+  SArray      *pTagsConditions; // implicitly-ANDed tag qual conditions
+} STableScanPhyNode;
+
+typedef STableScanPhyNode STableSeqScanPhyNode;
+
+typedef struct SProjectPhyNode {
+  SPhyNode node;
+} SProjectPhyNode;
+
+typedef struct SExchangePhyNode {
+  SPhyNode    node;
+  uint64_t    srcTemplateId; // template id of datasource suplans
+  SArray     *pSourceEpSet;  // SEpSet, scheduler fill by calling qSetSuplanExecutionNode
+} SExchangePhyNode;
+
+typedef struct SSubplanId {
+  uint64_t queryId;
+  uint64_t templateId;
+  uint64_t subplanId;
+} SSubplanId;
+
 typedef struct SSubplan {
+  SSubplanId id;          // unique id of the subplan
   int32_t   type;         // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL|QUERY_TYPE_SCAN
-  SArray   *pDatasource;          // the datasource subplan,from which to fetch the result
-  struct SPhyNode *pNode;  // physical plan of current subplan
+  int32_t   level;        // the execution level of current subplan, starting from 0.
+  SEpSet    execEpSet;    // for the scan sub plan, the optional execution node
+  SArray   *pChildern;    // the datasource subplan,from which to fetch the result
+  SArray   *pParents;     // the data destination subplan, get data from current subplan
+  SPhyNode *pNode;        // physical plan of current subplan
 } SSubplan;
 
 typedef struct SQueryDag {
-  SArray  **pSubplans;
+  SArray  *pSubplans; // Element is SArray*, and nested element is SSubplan. The execution level of subplan, starting from 0.
 } SQueryDag;
 
 /**
@@ -73,8 +113,11 @@ typedef struct SQueryDag {
  */
 int32_t qCreateQueryDag(const struct SQueryStmtInfo* pQueryInfo, struct SEpSet* pQnode, struct SQueryDag** pDag);
 
+int32_t qSetSuplanExecutionNode(SArray* subplans, SArray* nodes);
+
 int32_t qExplainQuery(const struct SQueryStmtInfo* pQueryInfo, struct SEpSet* pQnode, char** str);
 
+
 /**
  * Convert to subplan to string for the scheduler to send to the executor
  */
@@ -85,7 +128,7 @@ int32_t qSubPlanToString(struct SSubplan *pPhyNode, char** str);
  * @param pQueryPhyNode
  * @return
  */
-void* qDestroyQueryDag(struct SQueryDag* pDag);
+void qDestroyQueryDag(struct SQueryDag* pDag);
 
 #ifdef __cplusplus
 }

source/dnode/mnode/impl/src/mndSync.c → include/libs/planner/plannerOp.h

@@ -13,24 +13,36 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "mndInt.h"
-#include "mndTrans.h"
+#if defined(INCLUDE_AS_ENUM)  // enum define mode
+    #undef OP_ENUM_MACRO
+    #define OP_ENUM_MACRO(op)    OP_##op,
+#elif defined(INCLUDE_AS_NAME)  // comment define mode
+    #undef OP_ENUM_MACRO
+    #define OP_ENUM_MACRO(op)    #op,
+#else
+    #error To use this include file, first define either INCLUDE_AS_ENUM or INCLUDE_AS_NAME
+#endif
 
-int32_t mndInitSync(SMnode *pMnode) { return 0; }
-void    mndCleanupSync(SMnode *pMnode) {}
-
-int32_t mndSyncPropose(SMnode *pMnode, SSdbRaw *pRaw) {
-  int32_t code = 0;
-
-  // int32_t  len = sdbGetRawTotalSize(pRaw);
-  // SSdbRaw *pReceived = calloc(1, len);
-  // memcpy(pReceived, pRaw, len);
-  // mDebug("trans:%d, data:%p recv from sync, code:0x%x pMsg:%p", pMsg->id, pReceived, code & 0xFFFF, pMsg);
-
-  // mndTransApply(pMnode, pReceived, code);
-  return code;
-}
-
-bool mndIsMaster(SMnode *pMnode) { return true; }
+OP_ENUM_MACRO(TableScan)
+OP_ENUM_MACRO(DataBlocksOptScan)
+OP_ENUM_MACRO(TableSeqScan)
+OP_ENUM_MACRO(TagScan)
+OP_ENUM_MACRO(SystemTableScan)
+OP_ENUM_MACRO(Aggregate)
+OP_ENUM_MACRO(Project)
+OP_ENUM_MACRO(Groupby)
+OP_ENUM_MACRO(Limit)
+OP_ENUM_MACRO(SLimit)
+OP_ENUM_MACRO(TimeWindow)
+OP_ENUM_MACRO(SessionWindow)
+OP_ENUM_MACRO(StateWindow)
+OP_ENUM_MACRO(Fill)
+OP_ENUM_MACRO(MultiTableAggregate)
+OP_ENUM_MACRO(MultiTableTimeInterval)
\ No newline at end of file
+OP_ENUM_MACRO(Filter)
+OP_ENUM_MACRO(Distinct)
+OP_ENUM_MACRO(Join)
+OP_ENUM_MACRO(AllTimeWindow)
+OP_ENUM_MACRO(AllMultiTableTimeInterval)
+OP_ENUM_MACRO(Order)
+OP_ENUM_MACRO(Exchange)

include/libs/query/query.h

@@ -21,6 +21,8 @@ extern "C" {
 #endif
 
 #include "tarray.h"
+#include "thash.h"
+#include "tlog.h"
 
 typedef SVgroupListRspMsg SVgroupListInfo;
 
@@ -63,16 +65,14 @@ typedef struct STableMeta {
 
 
 typedef struct SDBVgroupInfo {
-  int32_t vgroupVersion;
-  SArray *vgId;
-  int32_t hashRange;
-  int32_t hashType;
+  int32_t   vgVersion;  
+  int8_t    hashMethod;
+  SHashObj *vgInfo;  //key:vgId, value:SVgroupInfo
 } SDBVgroupInfo;
 
 typedef struct SUseDbOutput {
-  SVgroupListInfo *vgroupList;
-  char db[TSDB_TABLE_FNAME_LEN];
-  SDBVgroupInfo *dbVgroup;
+  char db[TSDB_FULL_DB_NAME_LEN];
+  SDBVgroupInfo dbVgroup;
 } SUseDbOutput;
 
 typedef struct STableMetaOutput {
@@ -86,6 +86,19 @@ typedef struct STableMetaOutput {
 extern int32_t (*queryBuildMsg[TSDB_MSG_TYPE_MAX])(void* input, char **msg, int32_t msgSize, int32_t *msgLen);
 extern int32_t (*queryProcessMsgRsp[TSDB_MSG_TYPE_MAX])(void* output, char *msg, int32_t msgSize);
 
+extern void msgInit();
+
+
+extern int32_t qDebugFlag;
+
+#define qFatal(...)  do { if (qDebugFlag & DEBUG_FATAL) { taosPrintLog("QRY FATAL ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qError(...)  do { if (qDebugFlag & DEBUG_ERROR) { taosPrintLog("QRY ERROR ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qWarn(...)   do { if (qDebugFlag & DEBUG_WARN)  { taosPrintLog("QRY WARN ", qDebugFlag, __VA_ARGS__); }}  while(0)
+#define qInfo(...)   do { if (qDebugFlag & DEBUG_INFO)  { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qDebug(...)  do { if (qDebugFlag & DEBUG_DEBUG) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qTrace(...)  do { if (qDebugFlag & DEBUG_TRACE) { taosPrintLog("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
+#define qDebugL(...) do { if (qDebugFlag & DEBUG_DEBUG) { taosPrintLongString("QRY ", qDebugFlag, __VA_ARGS__); }} while(0)
+
 
 #ifdef __cplusplus
 }

include/libs/scheduler/scheduler.h

@@ -20,6 +20,12 @@
 extern "C" {
 #endif
 
+#include "planner.h"
+
+typedef struct SSchedulerCfg {
+
+} SSchedulerCfg;
+
 typedef struct SQueryProfileSummary {
   int64_t startTs;      // Object created and added into the message queue
   int64_t endTs;        // the timestamp when the task is completed
@@ -43,43 +49,23 @@ typedef struct SQueryProfileSummary {
   uint64_t resultSize;   // generated result size in Kb.
 } SQueryProfileSummary;
 
-typedef struct SQueryTask {
-  uint64_t            queryId; // query id
-  uint64_t            taskId;  // task id
-  char     *pSubplan;   // operator tree
-  uint64_t            status;  // task status
-  SQueryProfileSummary summary; // task execution summary
-  void               *pOutputHandle; // result buffer handle, to temporarily keep the output result for next stage
-} SQueryTask;
-
-typedef struct SQueryJob {
-  SArray  **pSubtasks;
-  // todo
-} SQueryJob;
-
 /**
  * Process the query job, generated according to the query physical plan.
  * This is a synchronized API, and is also thread-safety.
  * @param pJob
  * @return
  */
-int32_t qProcessQueryJob(struct SQueryJob* pJob);
+int32_t scheduleQueryJob(SQueryDag* pDag, void** pJob);
+
+int32_t scheduleFetchRows(void *pJob, void *data);
 
-/**
- * The SSqlObj should not be here????
- * @param pSql
- * @param pVgroupId
- * @param pRetVgroupId
- * @return
- */
-//SArray* qGetInvolvedVgroupIdList(struct SSqlObj* pSql, SArray* pVgroupId, SArray* pRetVgroupId);
 
 /**
  * Cancel query job
  * @param pJob
  * @return
  */
-int32_t qKillQueryJob(struct SQueryJob* pJob);
+int32_t scheduleCancelJob(void *pJob);
 
 #ifdef __cplusplus
 }

include/libs/wal/wal.h

@@ -16,25 +16,55 @@
 #define _TD_WAL_H_
 
 #include "os.h"
+#include "tarray.h"
 #include "tdef.h"
 #include "tlog.h"
-#include "tarray.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 extern int32_t wDebugFlag;
 
-#define wFatal(...) { if (wDebugFlag & DEBUG_FATAL) { taosPrintLog("WAL FATAL ", 255, __VA_ARGS__); }}
-#define wError(...) { if (wDebugFlag & DEBUG_ERROR) { taosPrintLog("WAL ERROR ", 255, __VA_ARGS__); }}
-#define wWarn(...)  { if (wDebugFlag & DEBUG_WARN)  { taosPrintLog("WAL WARN ", 255, __VA_ARGS__); }}
-#define wInfo(...)  { if (wDebugFlag & DEBUG_INFO)  { taosPrintLog("WAL ", 255, __VA_ARGS__); }}
-#define wDebug(...) { if (wDebugFlag & DEBUG_DEBUG) { taosPrintLog("WAL ", wDebugFlag, __VA_ARGS__); }}
-#define wTrace(...) { if (wDebugFlag & DEBUG_TRACE) { taosPrintLog("WAL ", wDebugFlag, __VA_ARGS__); }}
+#define wFatal(...)                                 \
+  {                                                 \
+    if (wDebugFlag & DEBUG_FATAL) {                 \
+      taosPrintLog("WAL FATAL ", 255, __VA_ARGS__); \
+    }                                               \
+  }
+#define wError(...)                                 \
+  {                                                 \
+    if (wDebugFlag & DEBUG_ERROR) {                 \
+      taosPrintLog("WAL ERROR ", 255, __VA_ARGS__); \
+    }                                               \
+  }
+#define wWarn(...)                                 \
+  {                                                \
+    if (wDebugFlag & DEBUG_WARN) {                 \
+      taosPrintLog("WAL WARN ", 255, __VA_ARGS__); \
+    }                                              \
+  }
+#define wInfo(...)                            \
+  {                                           \
+    if (wDebugFlag & DEBUG_INFO) {            \
+      taosPrintLog("WAL ", 255, __VA_ARGS__); \
+    }                                         \
+  }
+#define wDebug(...)                                  \
+  {                                                  \
+    if (wDebugFlag & DEBUG_DEBUG) {                  \
+      taosPrintLog("WAL ", wDebugFlag, __VA_ARGS__); \
+    }                                                \
+  }
+#define wTrace(...)                                  \
+  {                                                  \
+    if (wDebugFlag & DEBUG_TRACE) {                  \
+      taosPrintLog("WAL ", wDebugFlag, __VA_ARGS__); \
+    }                                                \
+  }
 
 #define WAL_HEAD_VER 0
 #define WAL_NOSUFFIX_LEN 20
-#define WAL_SUFFIX_AT    (WAL_NOSUFFIX_LEN+1)
+#define WAL_SUFFIX_AT (WAL_NOSUFFIX_LEN + 1)
 #define WAL_LOG_SUFFIX "log"
 #define WAL_INDEX_SUFFIX "idx"
 #define WAL_REFRESH_MS 1000
@@ -45,18 +75,14 @@ extern int32_t wDebugFlag;
 #define WAL_CUR_FAILED 1
 
 #pragma pack(push, 1)
-typedef enum {
-  TAOS_WAL_NOLOG = 0,
-  TAOS_WAL_WRITE = 1,
-  TAOS_WAL_FSYNC = 2
-} EWalType;
+typedef enum { TAOS_WAL_NOLOG = 0, TAOS_WAL_WRITE = 1, TAOS_WAL_FSYNC = 2 } EWalType;
 
 typedef struct SWalReadHead {
   int8_t  headVer;
   uint8_t msgType;
   int8_t  reserved[2];
   int32_t len;
-  int64_t  ingestTs;  //not implemented
+  int64_t ingestTs;  // not implemented
   int64_t version;
   char    body[];
 } SWalReadHead;
@@ -89,37 +115,37 @@ typedef struct SWal {
   // cfg
   SWalCfg cfg;
   int32_t fsyncSeq;
-  //meta
+  // meta
   SWalVer vers;
   int64_t writeLogTfd;
   int64_t writeIdxTfd;
   int32_t writeCur;
-  SArray* fileInfoSet;
-  //status
+  SArray *fileInfoSet;
+  // status
   int64_t totSize;
   int64_t lastRollSeq;
-  //ctl
+  // ctl
   int64_t         refId;
   pthread_mutex_t mutex;
-  //path
+  // path
   char path[WAL_PATH_LEN];
-  //reusable write head
+  // reusable write head
   SWalHead writeHead;
 } SWal;  // WAL HANDLE
 
 typedef struct SWalReadHandle {
-  SWal*        pWal;
+  SWal     *pWal;
   int64_t   readLogTfd;
   int64_t   readIdxTfd;
   int64_t   curFileFirstVer;
   int64_t   curVersion;
   int64_t   capacity;
-  int64_t      status;  //if cursor valid
-  SWalHead*    pHead;
+  int64_t   status;  // if cursor valid
+  SWalHead *pHead;
 } SWalReadHandle;
 #pragma pack(pop)
 
-//typedef int32_t (*FWalWrite)(void *ahandle, void *pHead);
+// typedef int32_t (*FWalWrite)(void *ahandle, void *pHead);
 
 // module initialization
 int32_t walInit();
@@ -141,15 +167,15 @@ int32_t walRollback(SWal *, int64_t ver);
 // notify that previous logs can be pruned safely
 int32_t walBeginSnapshot(SWal *, int64_t ver);
 int32_t walEndSnapshot(SWal *);
-//int32_t  walDataCorrupted(SWal*);
+// int32_t  walDataCorrupted(SWal*);
 
 // read
-SWalReadHandle* walOpenReadHandle(SWal *);
+SWalReadHandle *walOpenReadHandle(SWal *);
 void            walCloseReadHandle(SWalReadHandle *);
 int32_t         walReadWithHandle(SWalReadHandle *pRead, int64_t ver);
 
 int32_t walRead(SWal *, SWalHead **, int64_t ver);
-//int32_t walReadWithFp(SWal *, FWalWrite writeFp, int64_t verStart, int32_t readNum);
+// int32_t walReadWithFp(SWal *, FWalWrite writeFp, int64_t verStart, int32_t readNum);
 
 // lifecycle check
 int64_t walGetFirstVer(SWal *);

include/os/os.h

@@ -46,6 +46,7 @@ extern "C" {
 #include <math.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <sys/utsname.h>
 #include <dirent.h>
 #include <unistd.h>
 

include/os/osSysinfo.h

@@ -20,6 +20,8 @@
 extern "C" {
 #endif
 
+#include "os.h"
+  
 #define TSDB_LOCALE_LEN   64
 #define TSDB_TIMEZONE_LEN 96
 
@@ -57,11 +59,11 @@ char *  taosGetCmdlineByPID(int pid);
 void    taosSetCoreDump(bool enable);
 
 typedef struct {
-  const char *sysname;
-  const char *nodename;
-  const char *release;
-  const char *version;
-  const char *machine;
+  char sysname[_UTSNAME_MACHINE_LENGTH];
+  char nodename[_UTSNAME_MACHINE_LENGTH];
+  char release[_UTSNAME_MACHINE_LENGTH];
+  char version[_UTSNAME_MACHINE_LENGTH];
+  char machine[_UTSNAME_MACHINE_LENGTH];
 } SysNameInfo;
 
 SysNameInfo taosGetSysNameInfo();

include/util/taoserror.h

@@ -324,6 +324,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_QRY_INCONSISTAN               TAOS_DEF_ERROR_CODE(0, 0x070C)  //"File inconsistency in replica")
 #define TSDB_CODE_QRY_INVALID_TIME_CONDITION    TAOS_DEF_ERROR_CODE(0, 0x070D)  //"invalid time condition")
 #define TSDB_CODE_QRY_SYS_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x070E)  //"System error")
+#define TSDB_CODE_QRY_INVALID_INPUT             TAOS_DEF_ERROR_CODE(0, 0x070F)  //"invalid input")
 
 
 // grant

include/util/tarray.h

@@ -41,7 +41,7 @@ typedef struct SArray {
  * @param elemSize
  * @return
  */
-void* taosArrayInit(size_t size, size_t elemSize);
+SArray* taosArrayInit(size_t size, size_t elemSize);
 
 /**
  *

include/util/tdef.h

@@ -196,6 +196,7 @@ do { \
 
 #define TSDB_AUTH_LEN             16
 #define TSDB_PASSWORD_LEN         32
+#define TSDB_USET_PASSWORD_LEN    129
 #define TSDB_VERSION_LEN          12
 #define TSDB_LABEL_LEN            8 
 
@@ -232,8 +233,8 @@ do { \
 #define TSDB_CQ_SQL_SIZE          1024
 #define TSDB_MIN_VNODES           64
 #define TSDB_MAX_VNODES           512
-#define TSDB_MIN_VNODES_PER_DB    2
-#define TSDB_MAX_VNODES_PER_DB    64
+#define TSDB_MIN_VNODES_PER_DB    1
+#define TSDB_MAX_VNODES_PER_DB    4096
 
 #define TSDB_DNODE_ROLE_ANY       0
 #define TSDB_DNODE_ROLE_MGMT      1

source/client/CMakeLists.txt

@@ -9,7 +9,7 @@ target_link_libraries(
     taos
     PRIVATE common
     INTERFACE api
-    PRIVATE os util common transport parser
+    PRIVATE os util common transport parser catalog function query
 )
 
 ADD_SUBDIRECTORY(test)
\ No newline at end of file

source/client/inc/clientInt.h

@@ -21,13 +21,14 @@ extern "C" {
 #endif
 
 #include "taos.h"
+#include "common.h"
 #include "taosmsg.h"
+#include "tdef.h"
+#include "tep.h"
 #include "thash.h"
 #include "tlist.h"
-#include "trpc.h"
-#include "tdef.h"
 #include "tmsgtype.h"
-#include "tep.h"
+#include "trpc.h"
 
 typedef struct SQueryExecMetric {
   int64_t      start;    // start timestamp
@@ -86,12 +87,29 @@ typedef struct STscObj {
   SAppInstInfo      *pAppInfo;
 } STscObj;
 
+typedef struct SClientResultInfo {
+  const char  *pMsg;
+  const char  *pData;
+  TAOS_FIELD  *fields;
+  int32_t      numOfCols;
+  int32_t      numOfRows;
+  int32_t      current;
+  int32_t     *length;
+  TAOS_ROW     row;
+  char       **pCol;
+} SClientResultInfo;
+
 typedef struct SReqBody {
   tsem_t    rspSem;        // not used now
   void*     fp;
   void*     param;
+  int32_t   paramLen;
+  int64_t   execId;    // showId/queryId
+  SClientResultInfo* pResInfo;
 } SRequestBody;
 
+#define ERROR_MSG_BUF_DEFAULT_SIZE  512
+
 typedef struct SRequestObj {
   uint64_t         requestId;
   int32_t          type;   // request type
@@ -118,7 +136,7 @@ extern int32_t    tscReqRef;
 extern void      *tscQhandle;
 extern int32_t    tscConnRef;
 
-extern int (*tscBuildMsg[TSDB_SQL_MAX])(SRequestObj *pRequest, SRequestMsgBody *pMsg);
+extern int (*buildRequestMsgFp[TSDB_SQL_MAX])(SRequestObj *pRequest, SRequestMsgBody *pMsgBody);
 extern int (*handleRequestRspFp[TSDB_SQL_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
 
 int   taos_init();
@@ -129,8 +147,6 @@ void  destroyTscObj(void*pObj);
 void* createRequest(STscObj* pObj, __taos_async_fn_t fp, void* param, int32_t type);
 void destroyRequest(SRequestObj* pRequest);
 
-TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass, const char *auth, const char *db, uint16_t port);
-
 void taos_init_imp(void);
 int taos_options_imp(TSDB_OPTION option, const char *str);
 
@@ -139,6 +155,12 @@ void* openTransporter(const char *user, const char *auth);
 void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet);
 void initMsgHandleFp();
 
+TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass, const char *auth, const char *db, uint16_t port);
+TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen);
+
+void* doFetchRow(SRequestObj* pRequest);
+void setResultDataPtr(SClientResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows);
+
 #ifdef __cplusplus
 }
 #endif

source/client/inc/tscLog.h → source/client/inc/clientLog.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_TSCLOG_H
-#define TDENGINE_TSCLOG_H
+#ifndef TDENGINE_CLIENTLOG_H
+#define TDENGINE_CLIENTLOG_H
 
 #ifdef __cplusplus
 extern "C" {

source/client/src/client.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 "os.h"
-#include "tdef.h"
-#include "tglobal.h"
-#include "clientInt.h"
-#include "tscLog.h"
-
-TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
-  int32_t p = (port != 0)? port:tsServerPort;
-
-  tscDebug("try to connect to %s:%u, user:%s db:%s", ip, p, user, db);
-  if (user == NULL) {
-    user = TSDB_DEFAULT_USER;
-  }
-
-  if (pass == NULL) {
-    pass = TSDB_DEFAULT_PASS;
-  }
-
-  return taos_connect_internal(ip, user, pass, NULL, db, p);
-}
-
-TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port) {
-  tscDebug("try to connect to %s:%u by auth, user:%s db:%s", ip, port, user, db);
-  if (user == NULL) {
-    user = TSDB_DEFAULT_USER;
-  }
-
-  if (auth == NULL) {
-    tscError("No auth info is given, failed to connect to server");
-    return NULL;
-  }
-
-  return taos_connect_internal(ip, user, NULL, auth, db, port);
-}
-
-TAOS *taos_connect_l(const char *ip, int ipLen, const char *user, int userLen, const char *pass, int passLen, const char *db, int dbLen, uint16_t port) {
-  char ipStr[TSDB_EP_LEN]      = {0};
-  char dbStr[TSDB_DB_NAME_LEN] = {0};
-  char userStr[TSDB_USER_LEN]  = {0};
-  char passStr[TSDB_PASSWORD_LEN]   = {0};
-
-  strncpy(ipStr,   ip,   MIN(TSDB_EP_LEN - 1, ipLen));
-  strncpy(userStr, user, MIN(TSDB_USER_LEN - 1, userLen));
-  strncpy(passStr, pass, MIN(TSDB_PASSWORD_LEN - 1, passLen));
-  strncpy(dbStr,   db,   MIN(TSDB_DB_NAME_LEN - 1, dbLen));
-  return taos_connect(ipStr, userStr, passStr, dbStr, port);
-}
-

source/client/src/clientImpl.c

-#include <tpagedfile.h>
+
 #include "clientInt.h"
+#include "clientLog.h"
 #include "tdef.h"
 #include "tep.h"
 #include "tglobal.h"
 #include "tmsgtype.h"
+#include "tnote.h"
+#include "tpagedfile.h"
 #include "tref.h"
-#include "tscLog.h"
+#include "parser.h"
 
 static int32_t initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet);
 static int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody);
-static void destroyConnectMsg(SRequestMsgBody* pMsgBody);
+static void destroyRequestMsgBody(SRequestMsgBody* pMsgBody);
 
 static int32_t sendMsgToServer(void *pTransporter, SEpSet* epSet, const SRequestMsgBody *pBody, int64_t* pTransporterId);
 
@@ -96,17 +99,84 @@ TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass,
 
   char* key = getClusterKey(user, secretEncrypt, ip, port);
 
-  SAppInstInfo* pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
+  SAppInstInfo** pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
   if (pInst == NULL) {
-    pInst = calloc(1, sizeof(struct SAppInstInfo));
+    SAppInstInfo* p = calloc(1, sizeof(struct SAppInstInfo));
+
+    p->mgmtEp       = epSet;
+    p->pTransporter = openTransporter(user, secretEncrypt);
+    taosHashPut(appInfo.pInstMap, key, strlen(key), &p, POINTER_BYTES);
+
+    pInst = &p;
+  }
+
+  tfree(key);
+  return taosConnectImpl(ip, user, &secretEncrypt[0], db, port, NULL, NULL, *pInst);
+}
+
+TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
+  STscObj *pTscObj = (STscObj *)taos;
+  if (sqlLen > (size_t) tsMaxSQLStringLen) {
+    tscError("sql string exceeds max length:%d", tsMaxSQLStringLen);
+    terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
+    return NULL;
+  }
+
+  nPrintTsc("%s", sql)
+
+  SRequestObj* pRequest = createRequest(pTscObj, NULL, NULL, TSDB_SQL_SELECT);
+  if (pRequest == NULL) {
+    tscError("failed to malloc sqlObj");
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  pRequest->sqlstr = malloc(sqlLen + 1);
+  if (pRequest->sqlstr == NULL) {
+    tscError("0x%"PRIx64" failed to prepare sql string buffer", pRequest->self);
+
+    pRequest->msgBuf = strdup("failed to prepare sql string buffer");
+    terrno = pRequest->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return pRequest;
+  }
+
+  strntolower(pRequest->sqlstr, sql, (int32_t)sqlLen);
+  pRequest->sqlstr[sqlLen] = 0;
+
+  tscDebugL("0x%"PRIx64" SQL: %s", pRequest->requestId, pRequest->sqlstr);
+
+  int32_t code = 0;
+  if (qIsInsertSql(pRequest->sqlstr, sqlLen)) {
+    // todo add
+  } else {
+    int32_t type = 0;
+    void*   output = NULL;
+    int32_t outputLen = 0;
+    code = qParseQuerySql(pRequest->sqlstr, sqlLen, pRequest->requestId, &type, &output, &outputLen, pRequest->msgBuf, ERROR_MSG_BUF_DEFAULT_SIZE);
+    if (type == TSDB_SQL_CREATE_USER || type == TSDB_SQL_SHOW) {
+      pRequest->type = type;
+      pRequest->body.param = output;
+      pRequest->body.paramLen = outputLen;
 
-    pInst->mgmtEp       = epSet;
-    pInst->pTransporter = openTransporter(user, secretEncrypt);
+      SRequestMsgBody body = {0};
+      buildRequestMsgFp[type](pRequest, &body);
+
+      int64_t transporterId = 0;
+      sendMsgToServer(pTscObj->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &body, &transporterId);
 
-    taosHashPut(appInfo.pInstMap, key, strlen(key), &pInst, POINTER_BYTES);
+      tsem_wait(&pRequest->body.rspSem);
+      destroyRequestMsgBody(&body);
+    } else {
+      assert(0);
+    }
+  }
+
+  if (code != TSDB_CODE_SUCCESS) {
+    pRequest->code = code;
+    return pRequest;
   }
 
-  return taosConnectImpl(ip, user, &secretEncrypt[0], db, port, NULL, NULL, pInst);
+  return pRequest;
 }
 
 int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSet) {
@@ -166,7 +236,7 @@ STscObj* taosConnectImpl(const char *ip, const char *user, const char *auth, con
   sendMsgToServer(pTscObj->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &body, &transporterId);
 
   tsem_wait(&pRequest->body.rspSem);
-  destroyConnectMsg(&body);
+  destroyRequestMsgBody(&body);
 
   if (pRequest->code != TSDB_CODE_SUCCESS) {
     const char *errorMsg = (pRequest->code == TSDB_CODE_RPC_FQDN_ERROR) ? taos_errstr(pRequest) : tstrerror(terrno);
@@ -213,7 +283,7 @@ static int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody)
   return 0;
 }
 
-static void destroyConnectMsg(SRequestMsgBody* pMsgBody) {
+static void destroyRequestMsgBody(SRequestMsgBody* pMsgBody) {
   assert(pMsgBody != NULL);
   tfree(pMsgBody->pData);
 }
@@ -269,11 +339,18 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
     tscDebug("0x%" PRIx64 " message:%s, code:%s rspLen:%d, elapsed:%"PRId64 " ms", pRequest->requestId, taosMsg[pMsg->msgType],
              tstrerror(pMsg->code), pMsg->contLen, pRequest->metric.rsp - pRequest->metric.start);
     if (handleRequestRspFp[pRequest->type]) {
-      pMsg->code = (*handleRequestRspFp[pRequest->type])(pRequest, pMsg->pCont, pMsg->contLen);
+      char *p = malloc(pMsg->contLen);
+      if (p == NULL) {
+        pRequest->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        terrno = pRequest->code;
+      } else {
+        memcpy(p, pMsg->pCont, pMsg->contLen);
+        pMsg->code = (*handleRequestRspFp[pRequest->type])(pRequest, p, pMsg->contLen);
+      }
     }
   } else {
-    tscError("0x%" PRIx64 " SQL cmd:%s, code:%s rspLen:%d", pRequest->requestId, taosMsg[pMsg->msgType],
-             tstrerror(pMsg->code), pMsg->contLen);
+    tscError("0x%" PRIx64 " SQL cmd:%s, code:%s rspLen:%d, elapsed time:%"PRId64" ms", pRequest->requestId, taosMsg[pMsg->msgType],
+             tstrerror(pMsg->code), pMsg->contLen, pRequest->metric.rsp - pRequest->metric.start);
   }
 
   taosReleaseRef(tscReqRef, requestRefId);
@@ -281,3 +358,80 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) {
 
   sem_post(&pRequest->body.rspSem);
 }
+
+TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port) {
+  tscDebug("try to connect to %s:%u by auth, user:%s db:%s", ip, port, user, db);
+  if (user == NULL) {
+    user = TSDB_DEFAULT_USER;
+  }
+
+  if (auth == NULL) {
+    tscError("No auth info is given, failed to connect to server");
+    return NULL;
+  }
+
+  return taos_connect_internal(ip, user, NULL, auth, db, port);
+}
+
+TAOS *taos_connect_l(const char *ip, int ipLen, const char *user, int userLen, const char *pass, int passLen, const char *db, int dbLen, uint16_t port) {
+  char ipStr[TSDB_EP_LEN]      = {0};
+  char dbStr[TSDB_DB_NAME_LEN] = {0};
+  char userStr[TSDB_USER_LEN]  = {0};
+  char passStr[TSDB_PASSWORD_LEN]   = {0};
+
+  strncpy(ipStr,   ip,   MIN(TSDB_EP_LEN - 1, ipLen));
+  strncpy(userStr, user, MIN(TSDB_USER_LEN - 1, userLen));
+  strncpy(passStr, pass, MIN(TSDB_PASSWORD_LEN - 1, passLen));
+  strncpy(dbStr,   db,   MIN(TSDB_DB_NAME_LEN - 1, dbLen));
+  return taos_connect(ipStr, userStr, passStr, dbStr, port);
+}
+
+void* doFetchRow(SRequestObj* pRequest) {
+  assert(pRequest != NULL);
+  SClientResultInfo* pResultInfo = pRequest->body.pResInfo;
+
+  if (pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) {
+    pRequest->type = TSDB_SQL_RETRIEVE_MNODE;
+
+    SRequestMsgBody body = {0};
+    buildRequestMsgFp[pRequest->type](pRequest, &body);
+
+    int64_t transporterId = 0;
+    STscObj* pTscObj = pRequest->pTscObj;
+    sendMsgToServer(pTscObj->pTransporter, &pTscObj->pAppInfo->mgmtEp.epSet, &body, &transporterId);
+
+    tsem_wait(&pRequest->body.rspSem);
+    destroyRequestMsgBody(&body);
+
+    pResultInfo->current = 0;
+    if (pResultInfo->numOfRows <= pResultInfo->current) {
+      return NULL;
+    }
+  }
+
+  for(int32_t i = 0; i < pResultInfo->numOfCols; ++i) {
+    pResultInfo->row[i] = pResultInfo->pCol[i] + pResultInfo->fields[i].bytes * pResultInfo->current;
+    if (IS_VAR_DATA_TYPE(pResultInfo->fields[i].type)) {
+      pResultInfo->length[i] = varDataLen(pResultInfo->row[i]);
+      pResultInfo->row[i] = varDataVal(pResultInfo->row[i]);
+    }
+  }
+
+  pResultInfo->current += 1;
+  return pResultInfo->row;
+}
+
+void setResultDataPtr(SClientResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows) {
+  assert(numOfCols > 0 && pFields != NULL && pResultInfo != NULL);
+  if (numOfRows == 0) {
+    return;
+  }
+
+  int32_t offset = 0;
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    pResultInfo->length[i] = pResultInfo->fields[i].bytes;
+    pResultInfo->row[i]    = pResultInfo->pData + offset * pResultInfo->numOfRows;
+    pResultInfo->pCol[i]   = pResultInfo->row[i];
+    offset += pResultInfo->fields[i].bytes;
+  }
+}
\ No newline at end of file

source/client/src/clientMain.c

+#include "clientInt.h"
+#include "clientLog.h"
+#include "os.h"
+#include "taosmsg.h"
+#include "tcache.h"
+#include "tconfig.h"
+#include "tglobal.h"
+#include "tnote.h"
+#include "tref.h"
+#include "trpc.h"
+#include "tsched.h"
+#include "ttime.h"
+#include "ttimezone.h"
+
+#define TSC_VAR_NOT_RELEASE 1
+#define TSC_VAR_RELEASED    0
+
+static int32_t sentinel = TSC_VAR_NOT_RELEASE;
+
+int taos_options(TSDB_OPTION option, const void *arg, ...) {
+  static int32_t lock = 0;
+
+  for (int i = 1; atomic_val_compare_exchange_32(&lock, 0, 1) != 0; ++i) {
+    if (i % 1000 == 0) {
+      tscInfo("haven't acquire lock after spin %d times.", i);
+      sched_yield();
+    }
+  }
+
+  int ret = taos_options_imp(option, (const char*)arg);
+  atomic_store_32(&lock, 0);
+  return ret;
+}
+
+// this function may be called by user or system, or by both simultaneously.
+void taos_cleanup(void) {
+  tscDebug("start to cleanup client environment");
+
+  if (atomic_val_compare_exchange_32(&sentinel, TSC_VAR_NOT_RELEASE, TSC_VAR_RELEASED) != TSC_VAR_NOT_RELEASE) {
+    return;
+  }
+
+  int32_t id = tscReqRef;
+  tscReqRef = -1;
+  taosCloseRef(id);
+
+  void* p = tscQhandle;
+  tscQhandle = NULL;
+  taosCleanUpScheduler(p);
+
+  id = tscConnRef;
+  tscConnRef = -1;
+  taosCloseRef(id);
+
+  rpcCleanup();
+  taosCloseLog();
+}
+
+TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
+  int32_t p = (port != 0) ? port : tsServerPort;
+
+  tscDebug("try to connect to %s:%u, user:%s db:%s", ip, p, user, db);
+  if (user == NULL) {
+    user = TSDB_DEFAULT_USER;
+  }
+
+  if (pass == NULL) {
+    pass = TSDB_DEFAULT_PASS;
+  }
+
+  return taos_connect_internal(ip, user, pass, NULL, db, p);
+}
+
+void taos_close(TAOS* taos) {
+  if (taos == NULL) {
+    return;
+  }
+
+  STscObj *pTscObj = (STscObj *)taos;
+  tscDebug("0x%"PRIx64" try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs);
+
+  taosRemoveRef(tscConnRef, pTscObj->id);
+}
+
+int taos_errno(TAOS_RES *tres) {
+  if (tres == NULL) {
+    return terrno;
+  }
+
+  return ((SRequestObj*) tres)->code;
+}
+
+const char *taos_errstr(TAOS_RES *res) {
+  SRequestObj *pRequest = (SRequestObj *) res;
+
+  if (pRequest == NULL) {
+    return (const char*) tstrerror(terrno);
+  }
+
+  if (strlen(pRequest->msgBuf) > 0 || pRequest->code == TSDB_CODE_RPC_FQDN_ERROR) {
+    return pRequest->msgBuf;
+  } else {
+    return (const char*)tstrerror(pRequest->code);
+  }
+}
+
+void taos_free_result(TAOS_RES *res) {
+  SRequestObj* pRequest = (SRequestObj*) res;
+  destroyRequest(pRequest);
+}
+
+int  taos_field_count(TAOS_RES *res) {
+  if (res == NULL) {
+    return 0;
+  }
+
+  SRequestObj* pRequest = (SRequestObj*) res;
+
+  SClientResultInfo* pResInfo = pRequest->body.pResInfo;
+  if (pResInfo == NULL) {
+    return 0;
+  }
+
+  return pResInfo->numOfCols;
+}
+
+int  taos_num_fields(TAOS_RES *res) {
+  return taos_field_count(res);
+}
+
+TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
+  if (taos_num_fields(res) == 0) {
+    return NULL;
+  }
+
+  SClientResultInfo* pResInfo = ((SRequestObj*) res)->body.pResInfo;
+  return pResInfo->fields;
+}
+
+TAOS_RES *taos_query(TAOS *taos, const char *sql) {
+  if (taos == NULL || sql == NULL) {
+    return NULL;
+  }
+
+  return taos_query_l(taos, sql, strlen(sql));
+}
+
+TAOS_ROW taos_fetch_row(TAOS_RES *pRes) {
+  if (pRes == NULL) {
+    return NULL;
+  }
+
+  SRequestObj *pRequest = (SRequestObj *) pRes;
+  if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
+      pRequest->type == TSDB_SQL_INSERT) {
+    return NULL;
+  }
+
+  return doFetchRow(pRequest);
+}
+
+int  taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
+  int32_t len = 0;
+  for (int i = 0; i < num_fields; ++i) {
+    if (i > 0) {
+      str[len++] = ' ';
+    }
+
+    if (row[i] == NULL) {
+      len += sprintf(str + len, "%s", TSDB_DATA_NULL_STR);
+      continue;
+    }
+
+    switch (fields[i].type) {
+      case TSDB_DATA_TYPE_TINYINT:
+        len += sprintf(str + len, "%d", *((int8_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UTINYINT:
+        len += sprintf(str + len, "%u", *((uint8_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_SMALLINT:
+        len += sprintf(str + len, "%d", *((int16_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_USMALLINT:
+        len += sprintf(str + len, "%u", *((uint16_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_INT:
+        len += sprintf(str + len, "%d", *((int32_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UINT:
+        len += sprintf(str + len, "%u", *((uint32_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_BIGINT:
+        len += sprintf(str + len, "%" PRId64, *((int64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_UBIGINT:
+        len += sprintf(str + len, "%" PRIu64, *((uint64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_FLOAT: {
+        float fv = 0;
+        fv = GET_FLOAT_VAL(row[i]);
+        len += sprintf(str + len, "%f", fv);
+      } break;
+
+      case TSDB_DATA_TYPE_DOUBLE: {
+        double dv = 0;
+        dv = GET_DOUBLE_VAL(row[i]);
+        len += sprintf(str + len, "%lf", dv);
+      } break;
+
+      case TSDB_DATA_TYPE_BINARY:
+      case TSDB_DATA_TYPE_NCHAR: {
+        int32_t charLen = varDataLen((char*)row[i] - VARSTR_HEADER_SIZE);
+        if (fields[i].type == TSDB_DATA_TYPE_BINARY) {
+          assert(charLen <= fields[i].bytes && charLen >= 0);
+        } else {
+          assert(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE && charLen >= 0);
+        }
+
+        memcpy(str + len, row[i], charLen);
+        len += charLen;
+      } break;
+
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        len += sprintf(str + len, "%" PRId64, *((int64_t *)row[i]));
+        break;
+
+      case TSDB_DATA_TYPE_BOOL:
+        len += sprintf(str + len, "%d", *((int8_t *)row[i]));
+      default:
+        break;
+    }
+  }
+
+  return len;
+}
+
+int* taos_fetch_lengths(TAOS_RES *res) {
+  if (res == NULL) {
+    return NULL;
+  }
+
+  return ((SRequestObj*) res)->body.pResInfo->length;
+}
+
+const char *taos_data_type(int type) {
+  switch (type) {
+    case TSDB_DATA_TYPE_NULL:            return "TSDB_DATA_TYPE_NULL";
+    case TSDB_DATA_TYPE_BOOL:            return "TSDB_DATA_TYPE_BOOL";
+    case TSDB_DATA_TYPE_TINYINT:         return "TSDB_DATA_TYPE_TINYINT";
+    case TSDB_DATA_TYPE_SMALLINT:        return "TSDB_DATA_TYPE_SMALLINT";
+    case TSDB_DATA_TYPE_INT:             return "TSDB_DATA_TYPE_INT";
+    case TSDB_DATA_TYPE_BIGINT:          return "TSDB_DATA_TYPE_BIGINT";
+    case TSDB_DATA_TYPE_FLOAT:           return "TSDB_DATA_TYPE_FLOAT";
+    case TSDB_DATA_TYPE_DOUBLE:          return "TSDB_DATA_TYPE_DOUBLE";
+    case TSDB_DATA_TYPE_BINARY:          return "TSDB_DATA_TYPE_BINARY";
+    case TSDB_DATA_TYPE_TIMESTAMP:       return "TSDB_DATA_TYPE_TIMESTAMP";
+    case TSDB_DATA_TYPE_NCHAR:           return "TSDB_DATA_TYPE_NCHAR";
+    default: return "UNKNOWN";
+  }
+}

source/client/src/clientMsgHandler.c

@@ -13,11 +13,12 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "os.h"
+#include <catalog.h>
 #include "clientInt.h"
+#include "clientLog.h"
+#include "os.h"
 #include "tmsgtype.h"
 #include "trpc.h"
-#include "tscLog.h"
 
 int (*buildRequestMsgFp[TSDB_SQL_MAX])(SRequestObj *pRequest, SRequestMsgBody *pMsgBody) = {0};
 int (*handleRequestRspFp[TSDB_SQL_MAX])(SRequestObj *pRequest, const char* pMsg, int32_t msgLen);
@@ -528,7 +529,7 @@ int doBuildAndSendMsg(SSqlObj *pSql) {
 
   if (pCmd->command == TSDB_SQL_SELECT ||
       pCmd->command == TSDB_SQL_FETCH ||
-      pCmd->command == TSDB_SQL_RETRIEVE ||
+      pCmd->command == TSDB_SQL_RETRIEVE_MNODE ||
       pCmd->command == TSDB_SQL_INSERT ||
       pCmd->command == TSDB_SQL_CONNECT ||
       pCmd->command == TSDB_SQL_HB ||
@@ -2699,7 +2700,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
   }
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-  if ((pCmd->command == TSDB_SQL_RETRIEVE) ||
+  if ((pCmd->command == TSDB_SQL_RETRIEVE_MNODE) ||
       ((UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo) || UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) &&
        !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_SUBQUERY)) ||
       (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) &&
@@ -3091,6 +3092,36 @@ int tscGetSTableVgroupInfo(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
 
 #endif
 
+int32_t buildConnectMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) {
+  pMsgBody->msgType         = TSDB_MSG_TYPE_CONNECT;
+  pMsgBody->msgLen          = sizeof(SConnectMsg);
+  pMsgBody->requestObjRefId = pRequest->self;
+
+  SConnectMsg *pConnect = calloc(1, sizeof(SConnectMsg));
+  if (pConnect == NULL) {
+    terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  // TODO refactor full_name
+  char *db;  // ugly code to move the space
+
+  STscObj *pObj = pRequest->pTscObj;
+  pthread_mutex_lock(&pObj->mutex);
+  db = strstr(pObj->db, TS_PATH_DELIMITER);
+
+  db = (db == NULL) ? pObj->db : db + 1;
+  tstrncpy(pConnect->db, db, sizeof(pConnect->db));
+  pthread_mutex_unlock(&pObj->mutex);
+
+  pConnect->pid = htonl(appInfo.pid);
+  pConnect->startTime = htobe64(appInfo.startTime);
+  tstrncpy(pConnect->app, appInfo.appName, tListLen(pConnect->app));
+
+  pMsgBody->pData = pConnect;
+  return 0;
+}
+
 int processConnectRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) {
   STscObj *pTscObj = pRequest->pTscObj;
 
@@ -3099,6 +3130,11 @@ int processConnectRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) {
   pConnect->connId    = htonl(pConnect->connId);
   pConnect->clusterId = htonl(pConnect->clusterId);
 
+  assert(pConnect->epSet.numOfEps > 0);
+  for(int32_t i = 0; i < pConnect->epSet.numOfEps; ++i) {
+    pConnect->epSet.port[i] = htons(pConnect->epSet.port[i]);
+  }
+
   // TODO refactor
   pthread_mutex_lock(&pTscObj->mutex);
   char temp[TSDB_TABLE_FNAME_LEN * 2] = {0};
@@ -3108,13 +3144,12 @@ int processConnectRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) {
   tstrncpy(pTscObj->db, temp, sizeof(pTscObj->db));
   pthread_mutex_unlock(&pTscObj->mutex);
 
-  assert(pConnect->epSet.numOfEps > 0);
   if (!isEpsetEqual(&pTscObj->pAppInfo->mgmtEp.epSet, &pConnect->epSet)) {
     updateEpSet_s(&pTscObj->pAppInfo->mgmtEp, &pConnect->epSet);
   }
 
   for (int i = 0; i < pConnect->epSet.numOfEps; ++i) {
-    tscDebug("0x%" PRIx64 " epSet.fqdn[%d]: %s, connObj:0x%"PRIx64, pRequest->requestId, i, pConnect->epSet.fqdn[i], pTscObj->id);
+    tscDebug("0x%" PRIx64 " epSet.fqdn[%d]:%s port:%d, connObj:0x%"PRIx64, pRequest->requestId, i, pConnect->epSet.fqdn[i], pConnect->epSet.port[i], pTscObj->id);
   }
 
   pTscObj->connId = pConnect->connId;
@@ -3123,14 +3158,132 @@ int processConnectRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) {
   pTscObj->pAppInfo->clusterId = pConnect->clusterId;
   atomic_add_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
 
+  pRequest->body.pResInfo = calloc(1, sizeof(SClientResultInfo));
+  pRequest->body.pResInfo->pMsg = pMsg;
+
   tscDebug("0x%" PRIx64 " clusterId:%d, totalConn:%"PRId64, pRequest->requestId, pConnect->clusterId, pTscObj->pAppInfo->numOfConns);
-  //  createHbObj(pTscObj);
+  return 0;
+}
+
+int32_t buildCreateUserMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) {
+  pMsgBody->msgType         = TSDB_MSG_TYPE_CREATE_USER;
+  pMsgBody->msgLen          = sizeof(SCreateUserMsg);
+  pMsgBody->requestObjRefId = pRequest->self;
+  pMsgBody->pData           = pRequest->body.param;
+  return 0;
+}
+
+int32_t buildShowMsg(SRequestObj* pRequest, SRequestMsgBody* pMsgBody) {
+  pMsgBody->msgType         = TSDB_MSG_TYPE_SHOW;
+  pMsgBody->msgLen          = pRequest->body.paramLen;
+  pMsgBody->requestObjRefId = pRequest->self;
+  pMsgBody->pData           = pRequest->body.param;
+}
+
+STableMeta* createTableMetaFromMsg(STableMetaMsg* pTableMetaMsg) {
+  assert(pTableMetaMsg != NULL && pTableMetaMsg->numOfColumns >= 2);
+
+  size_t schemaSize = (pTableMetaMsg->numOfColumns + pTableMetaMsg->numOfTags) * sizeof(SSchema);
+  STableMeta* pTableMeta = calloc(1, sizeof(STableMeta) + schemaSize);
+
+  pTableMeta->tableType = pTableMetaMsg->tableType;
+  pTableMeta->vgId      = pTableMetaMsg->vgId;
+  pTableMeta->suid      = pTableMetaMsg->suid;
+  pTableMeta->uid       = pTableMetaMsg->tuid;
+
+  pTableMeta->tableInfo = (STableComInfo) {
+      .numOfTags    = pTableMetaMsg->numOfTags,
+      .precision    = pTableMetaMsg->precision,
+      .numOfColumns = pTableMetaMsg->numOfColumns,
+  };
+
+  pTableMeta->sversion = pTableMetaMsg->sversion;
+  pTableMeta->tversion = pTableMetaMsg->tversion;
+
+  memcpy(pTableMeta->schema, pTableMetaMsg->pSchema, schemaSize);
+
+  int32_t numOfTotalCols = pTableMeta->tableInfo.numOfColumns;
+  for(int32_t i = 0; i < numOfTotalCols; ++i) {
+    pTableMeta->tableInfo.rowSize += pTableMeta->schema[i].bytes;
+  }
+
+  return pTableMeta;
+}
+
+int32_t processShowRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) {
+  SShowRsp* pShow = (SShowRsp *)pMsg;
+  pShow->showId   = htonl(pShow->showId);
+
+  STableMetaMsg *pMetaMsg = &(pShow->tableMeta);
+  pMetaMsg->numOfColumns = htonl(pMetaMsg->numOfColumns);
+
+  SSchema* pSchema = pMetaMsg->pSchema;
+  pMetaMsg->tuid = htobe64(pMetaMsg->tuid);
+  for (int i = 0; i < pMetaMsg->numOfColumns; ++i) {
+    pSchema->bytes = htonl(pSchema->bytes);
+    pSchema++;
+  }
+
+  pSchema = pMetaMsg->pSchema;
+  TAOS_FIELD* pFields = calloc(pMetaMsg->numOfColumns, sizeof(TAOS_FIELD));
+  for (int32_t i = 0; i < pMetaMsg->numOfColumns; ++i) {
+    tstrncpy(pFields[i].name, pSchema[i].name, tListLen(pFields[i].name));
+    pFields[i].type  = pSchema[i].type;
+    pFields[i].bytes = pSchema[i].bytes;
+  }
+
+  if (pRequest->body.pResInfo == NULL) {
+    pRequest->body.pResInfo = calloc(1, sizeof(SClientResultInfo));
+  }
+
+  pRequest->body.pResInfo->pMsg = pMsg;
+  SClientResultInfo* pResInfo = pRequest->body.pResInfo;
 
-  // launch a timer to send heartbeat to maintain the connection and send status to mnode
-  //  taosTmrReset(tscProcessActivityTimer, tsShellActivityTimer * 500, (void *)pTscObj->rid, tscTmr, &pTscObj->pTimer);
+  pResInfo->fields    = pFields;
+  pResInfo->numOfCols = pMetaMsg->numOfColumns;
+  pResInfo->row       = calloc(pResInfo->numOfCols, POINTER_BYTES);
+  pResInfo->pCol      = calloc(pResInfo->numOfCols, POINTER_BYTES);
+  pResInfo->length    = calloc(pResInfo->numOfCols, sizeof(int32_t));
+
+  pRequest->body.execId = pShow->showId;
+  return 0;
+}
+
+int buildRetrieveMnodeMsg(SRequestObj *pRequest, SRequestMsgBody* pMsgBody) {
+  pMsgBody->msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+  pMsgBody->msgLen = sizeof(SRetrieveTableMsg);
+  pMsgBody->requestObjRefId = pRequest->self;
+
+  SRetrieveTableMsg *pRetrieveMsg = calloc(1, sizeof(SRetrieveTableMsg));
+  pRetrieveMsg->showId  = htonl(pRequest->body.execId);
+
+  pMsgBody->pData = pRetrieveMsg;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t processRetrieveMnodeRsp(SRequestObj *pRequest, const char* pMsg, int32_t msgLen) {
+  assert(msgLen >= sizeof(SRetrieveTableRsp));
+
+  tfree(pRequest->body.pResInfo->pMsg);
+  pRequest->body.pResInfo->pMsg = pMsg;
+
+  SRetrieveTableRsp *pRetrieve = (SRetrieveTableRsp *) pMsg;
+  pRetrieve->numOfRows  = htonl(pRetrieve->numOfRows);
+  pRetrieve->precision  = htons(pRetrieve->precision);
+
+  SClientResultInfo* pResInfo = pRequest->body.pResInfo;
+  pResInfo->numOfRows = pRetrieve->numOfRows;
+  pResInfo->pData = pRetrieve->data;              // todo fix this in async model
+
+  pResInfo->current = 0;
+  setResultDataPtr(pResInfo, pResInfo->fields, pResInfo->numOfCols, pResInfo->numOfRows);
+
+  tscDebug("0x%"PRIx64" numOfRows:%d, complete:%d, qId:0x%"PRIx64, pRequest->self, pRetrieve->numOfRows,
+           pRetrieve->completed, pRequest->body.execId);
   return 0;
 }
 
+
 void initMsgHandleFp() {
 #if 0
   tscBuildMsg[TSDB_SQL_SELECT] = tscBuildQueryMsg;
@@ -3167,7 +3320,7 @@ void initMsgHandleFp() {
 
   tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg;
   tscBuildMsg[TSDB_SQL_SHOW] = tscBuildShowMsg;
-  tscBuildMsg[TSDB_SQL_RETRIEVE] = tscBuildRetrieveFromMgmtMsg;
+  tscBuildMsg[TSDB_SQL_RETRIEVE_MNODE] = tscBuildRetrieveFromMgmtMsg;
   tscBuildMsg[TSDB_SQL_KILL_QUERY] = tscBuildKillMsg;
   tscBuildMsg[TSDB_SQL_KILL_STREAM] = tscBuildKillMsg;
   tscBuildMsg[TSDB_SQL_KILL_CONNECTION] = tscBuildKillMsg;
@@ -3185,7 +3338,7 @@ void initMsgHandleFp() {
   tscProcessMsgRsp[TSDB_SQL_RETRIEVE_FUNC] = tscProcessRetrieveFuncRsp;
 
   tscProcessMsgRsp[TSDB_SQL_SHOW] = tscProcessShowRsp;
-  tscProcessMsgRsp[TSDB_SQL_RETRIEVE] = tscProcessRetrieveRspFromNode;  // rsp handled by same function.
+  tscProcessMsgRsp[TSDB_SQL_RETRIEVE_MNODE] = tscProcessRetrieveRspFromNode;  // rsp handled by same function.
   tscProcessMsgRsp[TSDB_SQL_DESCRIBE_TABLE] = tscProcessDescribeTableRsp;
 
   tscProcessMsgRsp[TSDB_SQL_CURRENT_DB]   = tscProcessLocalRetrieveRsp;
@@ -3207,6 +3360,14 @@ void initMsgHandleFp() {
   tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
 #endif
 
-//  buildRequestMsgFp[TSDB_SQL_CONNECT]  = tscBuildConnectMsg;
+  buildRequestMsgFp[TSDB_SQL_CONNECT]  = buildConnectMsg;
   handleRequestRspFp[TSDB_SQL_CONNECT] = processConnectRsp;
+
+  buildRequestMsgFp[TSDB_SQL_CREATE_USER]  = buildCreateUserMsg;
+
+  buildRequestMsgFp[TSDB_SQL_SHOW]         = buildShowMsg;
+  handleRequestRspFp[TSDB_SQL_SHOW]        = processShowRsp;
+
+  buildRequestMsgFp[TSDB_SQL_RETRIEVE_MNODE] = buildRetrieveMnodeMsg;
+  handleRequestRspFp[TSDB_SQL_RETRIEVE_MNODE]= processRetrieveMnodeRsp;
 }
\ No newline at end of file

source/client/src/clientmain.c

-#include "clientInt.h"
-#include "trpc.h"
-#include "os.h"
-#include "taosmsg.h"
-#include "tcache.h"
-#include "tconfig.h"
-#include "tglobal.h"
-#include "tnote.h"
-#include "tref.h"
-#include "tscLog.h"
-#include "tsched.h"
-#include "ttime.h"
-#include "ttimezone.h"
-
-#define TSC_VAR_NOT_RELEASE 1
-#define TSC_VAR_RELEASED    0
-
-static int32_t sentinel = TSC_VAR_NOT_RELEASE;
-static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
-
-extern int32_t tscInitRes;
-
-int taos_options(TSDB_OPTION option, const void *arg, ...) {
-  static int32_t lock = 0;
-
-  for (int i = 1; atomic_val_compare_exchange_32(&lock, 0, 1) != 0; ++i) {
-    if (i % 1000 == 0) {
-      tscInfo("haven't acquire lock after spin %d times.", i);
-      sched_yield();
-    }
-  }
-
-  int ret = taos_options_imp(option, (const char*)arg);
-
-  atomic_store_32(&lock, 0);
-  return ret;
-}
-
-int taos_init() {
-  pthread_once(&tscinit, taos_init_imp);
-  return tscInitRes;
-}
-
-// this function may be called by user or system, or by both simultaneously.
-void taos_cleanup(void) {
-  tscDebug("start to cleanup client environment");
-
-  if (atomic_val_compare_exchange_32(&sentinel, TSC_VAR_NOT_RELEASE, TSC_VAR_RELEASED) != TSC_VAR_NOT_RELEASE) {
-    return;
-  }
-
-  int32_t id = tscReqRef;
-  tscReqRef = -1;
-  taosCloseRef(id);
-
-  void* p = tscQhandle;
-  tscQhandle = NULL;
-  taosCleanUpScheduler(p);
-
-  id = tscConnRef;
-  tscConnRef = -1;
-  taosCloseRef(id);
-
-  rpcCleanup();
-  taosCloseLog();
-}
-
-void taos_close(TAOS* taos) {
-  if (taos == NULL) {
-    return;
-  }
-
-  STscObj *pTscObj = (STscObj *)taos;
-  tscDebug("0x%"PRIx64" try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs);
-
-  taosRemoveRef(tscConnRef, pTscObj->id);
-}
-
-const char *taos_errstr(TAOS_RES *res) {
-
-}
-
-void taos_free_result(TAOS_RES *res) {
-
-}
\ No newline at end of file

source/client/src/tscEnv.c

@@ -13,6 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "clientInt.h"
+#include "clientLog.h"
 #include "os.h"
 #include "taosmsg.h"
 #include "tcache.h"
@@ -20,12 +22,10 @@
 #include "tglobal.h"
 #include "tnote.h"
 #include "tref.h"
-#include "tscLog.h"
+#include "trpc.h"
 #include "tsched.h"
 #include "ttime.h"
-#include "trpc.h"
 #include "ttimezone.h"
-#include "clientInt.h"
 
 #define TSC_VAR_NOT_RELEASE 1
 #define TSC_VAR_RELEASED    0
@@ -35,6 +35,7 @@ int32_t    tscReqRef  = -1;
 int32_t    tscConnRef = -1;
 void      *tscQhandle = NULL;
 
+static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
 int32_t tsNumOfThreads = 1;
 volatile int32_t tscInitRes = 0;
 
@@ -126,8 +127,6 @@ void destroyTscObj(void *pObj) {
 
   atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
   tscDebug("connObj 0x%"PRIx64" destroyed, totalConn:%"PRId64, pTscObj->id, pTscObj->pAppInfo->numOfConns);
-
-  closeTransporter(pTscObj);
   pthread_mutex_destroy(&pTscObj->mutex);
   tfree(pTscObj);
 }
@@ -172,6 +171,7 @@ void* createRequest(STscObj* pObj, __taos_async_fn_t fp, void* param, int32_t ty
   pRequest->pTscObj    = pObj;
   pRequest->body.fp    = fp;
   pRequest->body.param = param;
+  pRequest->msgBuf     = calloc(1, ERROR_MSG_BUF_DEFAULT_SIZE);
   tsem_init(&pRequest->body.rspSem, 0, 0);
 
   registerRequest(pRequest);
@@ -188,6 +188,12 @@ static void doDestroyRequest(void* p) {
   tfree(pRequest->sqlstr);
   tfree(pRequest->pInfo);
 
+  if (pRequest->body.pResInfo != NULL) {
+    tfree(pRequest->body.pResInfo->pData);
+    tfree(pRequest->body.pResInfo->pMsg);
+    tfree(pRequest->body.pResInfo);
+  }
+
   deregisterRequest(pRequest);
   tfree(pRequest);
 }
@@ -250,6 +256,11 @@ void taos_init_imp(void) {
   tscDebug("client is initialized successfully");
 }
 
+int taos_init() {
+  pthread_once(&tscinit, taos_init_imp);
+  return tscInitRes;
+}
+
 int taos_options_imp(TSDB_OPTION option, const char *str) {
   SGlobalCfg *cfg = NULL;
 

source/client/test/clientTests.cpp

@@ -14,6 +14,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <taoserror.h>
 #include <iostream>
 #include "tglobal.h"
 #pragma GCC diagnostic ignored "-Wwrite-strings"
@@ -22,6 +23,7 @@
 #pragma GCC diagnostic ignored "-Wunused-variable"
 #pragma GCC diagnostic ignored "-Wsign-compare"
 
+#include "../inc/clientInt.h"
 #include "taos.h"
 
 namespace {
@@ -33,8 +35,62 @@ int main(int argc, char** argv) {
 }
 
 TEST(testCase, driverInit_Test) {
+  taos_init();
+}
+
+TEST(testCase, connect_Test) {
+  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+  taos_close(pConn);
+}
+
+TEST(testCase, create_user_Test) {
+  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "create user abc pass 'abc'");
+  if (taos_errno(pRes) != TSDB_CODE_SUCCESS) {
+    printf("failed to create user, reason:%s\n", taos_errstr(pRes));
+  }
+
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
+
+//TEST(testCase, show_user_Test) {
+//  TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
+//  assert(pConn != NULL);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "show users");
+//  TAOS_ROW pRow = NULL;
+//
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  int32_t numOfFields = taos_num_fields(pRes);
+//
+//  char str[512] = {0};
+//  while((pRow = taos_fetch_row(pRes)) != NULL) {
+//    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+//    printf("%s\n", str);
+//  }
+//
+//  taos_close(pConn);
+//}
+
+TEST(testCase, show_db_Test) {
   TAOS* pConn = taos_connect("ubuntu", "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
 
+  TAOS_RES* pRes = taos_query(pConn, "show databases");
+  TAOS_ROW pRow = NULL;
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  int32_t numOfFields = taos_num_fields(pRes);
+
+  char str[512] = {0};
+  while((pRow = taos_fetch_row(pRes)) != NULL) {
+    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+    printf("%s\n", str);
+  }
+
   taos_close(pConn);
 }

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

@@ -44,8 +44,7 @@ static void dndInitMsgFp(STransMgmt *pMgmt) {
   pMgmt->msgFp[TSDB_MSG_TYPE_MQ_CONSUME] = dndProcessVnodeQueryMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_MQ_CONNECT] = dndProcessVnodeWriteMsg;
   pMgmt->msgFp[TSDB_MSG_TYPE_MQ_DISCONNECT] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_MQ_ACK] = dndProcessVnodeWriteMsg;
-  pMgmt->msgFp[TSDB_MSG_TYPE_MQ_RESET] = dndProcessVnodeWriteMsg;
+  pMgmt->msgFp[TSDB_MSG_TYPE_MQ_SET] = dndProcessVnodeWriteMsg;
 
   // msg from client to mnode
   pMgmt->msgFp[TSDB_MSG_TYPE_CONNECT] = dndProcessMnodeReadMsg;

source/dnode/mgmt/impl/test/acct/acct.cpp

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+/**
+ * @file vnodeApiTests.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module acct-msg tests
+ * @version 0.1
+ * @date 2021-12-15
  *
- * 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.
+ * @copyright Copyright (c) 2021
  *
- * 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 "deploy.h"
@@ -49,7 +45,7 @@ SServer* DndTestAcct::pServer;
 SClient* DndTestAcct::pClient;
 int32_t  DndTestAcct::connId;
 
-TEST_F(DndTestAcct, CreateAcct) {
+TEST_F(DndTestAcct, 01_CreateAcct) {
   ASSERT_NE(pClient, nullptr);
 
   SCreateAcctMsg* pReq = (SCreateAcctMsg*)rpcMallocCont(sizeof(SCreateAcctMsg));
@@ -65,7 +61,7 @@ TEST_F(DndTestAcct, CreateAcct) {
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
-TEST_F(DndTestAcct, AlterAcct) {
+TEST_F(DndTestAcct, 02_AlterAcct) {
   ASSERT_NE(pClient, nullptr);
 
   SAlterAcctMsg* pReq = (SAlterAcctMsg*)rpcMallocCont(sizeof(SAlterAcctMsg));
@@ -81,7 +77,7 @@ TEST_F(DndTestAcct, AlterAcct) {
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
-TEST_F(DndTestAcct, DropAcct) {
+TEST_F(DndTestAcct, 03_DropAcct) {
   ASSERT_NE(pClient, nullptr);
 
   SDropAcctMsg* pReq = (SDropAcctMsg*)rpcMallocCont(sizeof(SDropAcctMsg));
@@ -97,7 +93,7 @@ TEST_F(DndTestAcct, DropAcct) {
   ASSERT_EQ(pMsg->code, TSDB_CODE_MND_MSG_NOT_PROCESSED);
 }
 
-TEST_F(DndTestAcct, ShowAcct) {
+TEST_F(DndTestAcct, 04_ShowAcct) {
   ASSERT_NE(pClient, nullptr);
 
   SShowMsg* pReq = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));

source/dnode/mgmt/impl/test/cluster/cluster.cpp

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+/**
+ * @file vnodeApiTests.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module cluster-msg tests
+ * @version 0.1
+ * @date 2021-12-15
  *
- * 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.
+ * @copyright Copyright (c) 2021
  *
- * 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 "deploy.h"

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

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+/**
+ * @file vnodeApiTests.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module db-msg tests
+ * @version 0.1
+ * @date 2021-12-15
  *
- * 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.
+ * @copyright Copyright (c) 2021
  *
- * 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 "deploy.h"
@@ -30,7 +26,7 @@ class DndTestDb : public ::testing::Test {
     const char* firstEp = "localhost:9040";
     pServer = CreateServer("/tmp/dnode_test_db", fqdn, 9040, firstEp);
     pClient = createClient("root", "taosdata", fqdn, 9040);
-    taosMsleep(300);
+    taosMsleep(1100);
   }
 
   static void TearDownTestSuite() {
@@ -48,11 +44,12 @@ class DndTestDb : public ::testing::Test {
   void SetUp() override {}
   void TearDown() override {}
 
-  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns) {
+  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns, const char* db) {
     SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
     pShow->type = showType;
-    strcpy(pShow->db, "");
-
+    if (db != NULL) {
+      strcpy(pShow->db, db);
+    }
     SRpcMsg showRpcMsg = {0};
     showRpcMsg.pCont = pShow;
     showRpcMsg.contLen = sizeof(SShowMsg);
@@ -67,10 +64,10 @@ class DndTestDb : public ::testing::Test {
     ASSERT_NE(pShowRsp, nullptr);
     pShowRsp->showId = htonl(pShowRsp->showId);
     pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htons(pMeta->numOfTags);
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    pMeta->sversion = htons(pMeta->sversion);
-    pMeta->tversion = htons(pMeta->tversion);
+    pMeta->numOfTags = htonl(pMeta->numOfTags);
+    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
+    pMeta->sversion = htonl(pMeta->sversion);
+    pMeta->tversion = htonl(pMeta->tversion);
     pMeta->tuid = htobe64(pMeta->tuid);
     pMeta->suid = htobe64(pMeta->suid);
 
@@ -183,31 +180,33 @@ SClient* DndTestDb::pClient;
 int32_t  DndTestDb::connId;
 
 TEST_F(DndTestDb, 01_ShowDb) {
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
   CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN - 1 + VARSTR_HEADER_SIZE, "name");
   CheckSchema(1, TSDB_DATA_TYPE_TIMESTAMP, 8, "create time");
-  CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "replica");
-  CheckSchema(3, TSDB_DATA_TYPE_SMALLINT, 2, "quorum");
-  CheckSchema(4, TSDB_DATA_TYPE_SMALLINT, 2, "days");
-  CheckSchema(5, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "keep0,keep1,keep2");
-  CheckSchema(6, TSDB_DATA_TYPE_INT, 4, "cache(MB)");
-  CheckSchema(7, TSDB_DATA_TYPE_INT, 4, "blocks");
-  CheckSchema(8, TSDB_DATA_TYPE_INT, 4, "minrows");
-  CheckSchema(9, TSDB_DATA_TYPE_INT, 4, "maxrows");
-  CheckSchema(10, TSDB_DATA_TYPE_TINYINT, 1, "wallevel");
-  CheckSchema(11, TSDB_DATA_TYPE_INT, 4, "fsync");
-  CheckSchema(12, TSDB_DATA_TYPE_TINYINT, 1, "comp");
-  CheckSchema(13, TSDB_DATA_TYPE_TINYINT, 1, "cachelast");
-  CheckSchema(14, TSDB_DATA_TYPE_BINARY, 3 + VARSTR_HEADER_SIZE, "precision");
-  CheckSchema(15, TSDB_DATA_TYPE_TINYINT, 1, "update");
+  CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "vgroups");
+  CheckSchema(3, TSDB_DATA_TYPE_SMALLINT, 2, "replica");
+  CheckSchema(4, TSDB_DATA_TYPE_SMALLINT, 2, "quorum");
+  CheckSchema(5, TSDB_DATA_TYPE_SMALLINT, 2, "days");
+  CheckSchema(6, TSDB_DATA_TYPE_BINARY, 24 + VARSTR_HEADER_SIZE, "keep0,keep1,keep2");
+  CheckSchema(7, TSDB_DATA_TYPE_INT, 4, "cache(MB)");
+  CheckSchema(8, TSDB_DATA_TYPE_INT, 4, "blocks");
+  CheckSchema(9, TSDB_DATA_TYPE_INT, 4, "minrows");
+  CheckSchema(10, TSDB_DATA_TYPE_INT, 4, "maxrows");
+  CheckSchema(11, TSDB_DATA_TYPE_TINYINT, 1, "wallevel");
+  CheckSchema(12, TSDB_DATA_TYPE_INT, 4, "fsync");
+  CheckSchema(13, TSDB_DATA_TYPE_TINYINT, 1, "comp");
+  CheckSchema(14, TSDB_DATA_TYPE_TINYINT, 1, "cachelast");
+  CheckSchema(15, TSDB_DATA_TYPE_BINARY, 3 + VARSTR_HEADER_SIZE, "precision");
+  CheckSchema(16, TSDB_DATA_TYPE_TINYINT, 1, "update");
 
   SendThenCheckShowRetrieveMsg(0);
 }
 
-TEST_F(DndTestDb, 02_CreateDb) {
+TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) {
   {
     SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
     strcpy(pReq->db, "1.d1");
+    pReq->numOfVgroups = htonl(2);
     pReq->cacheBlockSize = htonl(16);
     pReq->totalBlocks = htonl(10);
     pReq->daysPerFile = htonl(10);
@@ -238,10 +237,11 @@ TEST_F(DndTestDb, 02_CreateDb) {
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
   SendThenCheckShowRetrieveMsg(1);
   CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
   CheckTimestamp();
+  CheckInt16(2);                      // vgroups
   CheckInt16(1);                      // replica
   CheckInt16(1);                      // quorum
   CheckInt16(10);                     // days
@@ -256,9 +256,22 @@ TEST_F(DndTestDb, 02_CreateDb) {
   CheckInt8(0);                       // cachelast
   CheckBinary("ms", 3);               // precision
   CheckInt8(0);                       // update
-}
 
-TEST_F(DndTestDb, 03_AlterDb) {
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_VGROUP, "show vgroups", 4, "1.d1");
+  CheckSchema(0, TSDB_DATA_TYPE_INT, 4, "vgId");
+  CheckSchema(1, TSDB_DATA_TYPE_INT, 4, "tables");
+  CheckSchema(2, TSDB_DATA_TYPE_SMALLINT, 2, "v1_dnode");
+  CheckSchema(3, TSDB_DATA_TYPE_BINARY, 9 + VARSTR_HEADER_SIZE, "v1_status");
+  SendThenCheckShowRetrieveMsg(2);
+  CheckInt32(1);
+  CheckInt32(2);
+  CheckInt32(0);
+  CheckInt32(0);
+  CheckInt16(1);
+  CheckInt16(1);
+  CheckBinary("master", 9);
+  CheckBinary("master", 9);
+
   {
     SAlterDbMsg* pReq = (SAlterDbMsg*)rpcMallocCont(sizeof(SAlterDbMsg));
     strcpy(pReq->db, "1.d1");
@@ -282,10 +295,11 @@ TEST_F(DndTestDb, 03_AlterDb) {
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
   SendThenCheckShowRetrieveMsg(1);
   CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
   CheckTimestamp();
+  CheckInt16(2);                   // vgroups
   CheckInt16(1);                   // replica
   CheckInt16(2);                   // quorum
   CheckInt16(10);                  // days
@@ -300,9 +314,8 @@ TEST_F(DndTestDb, 03_AlterDb) {
   CheckInt8(1);                    // cachelast
   CheckBinary("ms", 3);            // precision
   CheckInt8(0);                    // update
-}
 
-TEST_F(DndTestDb, 04_RestartDnode) {
+  // restart
   stopServer(pServer);
   pServer = NULL;
 
@@ -314,10 +327,11 @@ TEST_F(DndTestDb, 04_RestartDnode) {
 
   uInfo("all server is running");
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
   SendThenCheckShowRetrieveMsg(1);
   CheckBinary("d1", TSDB_DB_NAME_LEN - 1);
   CheckTimestamp();
+  CheckInt16(2);                   // vgroups
   CheckInt16(1);                   // replica
   CheckInt16(2);                   // quorum
   CheckInt16(10);                  // days
@@ -332,11 +346,9 @@ TEST_F(DndTestDb, 04_RestartDnode) {
   CheckInt8(1);                    // cachelast
   CheckBinary("ms", 3);            // precision
   CheckInt8(0);                    // update
-}
 
-TEST_F(DndTestDb, 05_DropDb) {
   {
-    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(sizeof(SAlterDbMsg));
+    SDropDbMsg* pReq = (SDropDbMsg*)rpcMallocCont(sizeof(SDropDbMsg));
     strcpy(pReq->db, "1.d1");
 
     SRpcMsg rpcMsg = {0};
@@ -350,6 +362,103 @@ TEST_F(DndTestDb, 05_DropDb) {
     ASSERT_EQ(pMsg->code, 0);
   }
 
-  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 16);
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
   SendThenCheckShowRetrieveMsg(0);
 }
+
+TEST_F(DndTestDb, 03_Create_Use_Restart_Use_Db) {
+  {
+    SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+    strcpy(pReq->db, "1.d2");
+    pReq->numOfVgroups = htonl(2);
+    pReq->cacheBlockSize = htonl(16);
+    pReq->totalBlocks = htonl(10);
+    pReq->daysPerFile = htonl(10);
+    pReq->daysToKeep0 = htonl(3650);
+    pReq->daysToKeep1 = htonl(3650);
+    pReq->daysToKeep2 = htonl(3650);
+    pReq->minRowsPerFileBlock = htonl(100);
+    pReq->maxRowsPerFileBlock = htonl(4096);
+    pReq->commitTime = htonl(3600);
+    pReq->fsyncPeriod = htonl(3000);
+    pReq->walLevel = 1;
+    pReq->precision = 0;
+    pReq->compression = 2;
+    pReq->replications = 1;
+    pReq->quorum = 1;
+    pReq->update = 0;
+    pReq->cacheLastRow = 0;
+    pReq->ignoreExist = 1;
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SCreateDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+  }
+
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DB, "show databases", 17, NULL);
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("d2", TSDB_DB_NAME_LEN - 1);
+
+  {
+    SUseDbMsg* pReq = (SUseDbMsg*)rpcMallocCont(sizeof(SUseDbMsg));
+    strcpy(pReq->db, "1.d2");
+    pReq->vgVersion = htonl(-1);
+
+    SRpcMsg rpcMsg = {0};
+    rpcMsg.pCont = pReq;
+    rpcMsg.contLen = sizeof(SUseDbMsg);
+    rpcMsg.msgType = TSDB_MSG_TYPE_USE_DB;
+
+    sendMsg(pClient, &rpcMsg);
+    SRpcMsg* pMsg = pClient->pRsp;
+    ASSERT_NE(pMsg, nullptr);
+    ASSERT_EQ(pMsg->code, 0);
+
+    SUseDbRsp* pRsp = (SUseDbRsp*)pMsg->pCont;
+    EXPECT_STREQ(pRsp->db, "1.d2");
+    pRsp->vgVersion = htonl(pRsp->vgVersion);
+    pRsp->vgNum = htonl(pRsp->vgNum);
+    pRsp->hashMethod = pRsp->hashMethod;
+    EXPECT_EQ(pRsp->vgVersion, 1);
+    EXPECT_EQ(pRsp->vgNum, 2);
+    EXPECT_EQ(pRsp->hashMethod, 1);
+
+    {
+      SVgroupInfo* pInfo = &pRsp->vgroupInfo[0];
+      pInfo->vgId = htonl(pInfo->vgId);
+      pInfo->hashBegin = htonl(pInfo->hashBegin);
+      pInfo->hashEnd = htonl(pInfo->hashEnd);
+      EXPECT_GT(pInfo->vgId, 0);
+      EXPECT_EQ(pInfo->hashBegin, 0);
+      EXPECT_EQ(pInfo->hashEnd, UINT32_MAX / 2 - 1);
+      EXPECT_EQ(pInfo->inUse, 0);
+      EXPECT_EQ(pInfo->numOfEps, 1);
+      SEpAddrMsg* pAddr = &pInfo->epAddr[0];
+      pAddr->port = htons(pAddr->port);
+      EXPECT_EQ(pAddr->port, 9040);
+      EXPECT_STREQ(pAddr->fqdn, "localhost");
+    }
+
+    {
+      SVgroupInfo* pInfo = &pRsp->vgroupInfo[1];
+      pInfo->vgId = htonl(pInfo->vgId);
+      pInfo->hashBegin = htonl(pInfo->hashBegin);
+      pInfo->hashEnd = htonl(pInfo->hashEnd);
+      EXPECT_GT(pInfo->vgId, 0);
+      EXPECT_EQ(pInfo->hashBegin, UINT32_MAX / 2);
+      EXPECT_EQ(pInfo->hashEnd, UINT32_MAX);
+      EXPECT_EQ(pInfo->inUse, 0);
+      EXPECT_EQ(pInfo->numOfEps, 1);
+      SEpAddrMsg* pAddr = &pInfo->epAddr[0];
+      pAddr->port = htons(pAddr->port);
+      EXPECT_EQ(pAddr->port, 9040);
+      EXPECT_STREQ(pAddr->fqdn, "localhost");
+    }
+  }
+}

source/dnode/mgmt/impl/test/dnode/dnode.cpp

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+/**
+ * @file vnodeApiTests.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module dnode-msg tests
+ * @version 0.1
+ * @date 2021-12-15
  *
- * 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.
+ * @copyright Copyright (c) 2021
  *
- * 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 "deploy.h"
@@ -82,11 +78,11 @@ class DndTestDnode : public ::testing::Test {
     ASSERT_NE(pShowRsp, nullptr);
     pShowRsp->showId = htonl(pShowRsp->showId);
     pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htons(pMeta->numOfTags);
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    pMeta->sversion = htons(pMeta->sversion);
+    pMeta->numOfTags = htonl(pMeta->numOfTags);
+    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
+    pMeta->sversion = htonl(pMeta->sversion);
     pMeta->tversion = htons(pMeta->tversion);
-    pMeta->tuid = htobe64(pMeta->tuid);
+    pMeta->tuid = htonl(pMeta->tuid);
     pMeta->suid = htobe64(pMeta->suid);
 
     showId = pShowRsp->showId;
@@ -224,7 +220,8 @@ TEST_F(DndTestDnode, 02_ConfigDnode) {
   ASSERT_EQ(pMsg->code, 0);
 }
 
-TEST_F(DndTestDnode, 03_CreateDnode) {
+TEST_F(DndTestDnode, 03_Create_Drop_Restart_Dnode) {
+  {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
     strcpy(pReq->ep, "localhost:9042");
 
@@ -237,6 +234,7 @@ TEST_F(DndTestDnode, 03_CreateDnode) {
     SRpcMsg* pMsg = pClient->pRsp;
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
+  }
 
   taosMsleep(1300);
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
@@ -255,9 +253,8 @@ TEST_F(DndTestDnode, 03_CreateDnode) {
   CheckTimestamp();
   CheckBinary("", 24);
   CheckBinary("", 24);
-}
 
-TEST_F(DndTestDnode, 04_DropDnode) {
+  {
     SDropDnodeMsg* pReq = (SDropDnodeMsg*)rpcMallocCont(sizeof(SDropDnodeMsg));
     pReq->dnodeId = htonl(2);
 
@@ -270,6 +267,7 @@ TEST_F(DndTestDnode, 04_DropDnode) {
     SRpcMsg* pMsg = pClient->pRsp;
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
+  }
 
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
   SendThenCheckShowRetrieveMsg(1);
@@ -280,9 +278,7 @@ TEST_F(DndTestDnode, 04_DropDnode) {
   CheckBinary("ready", 10);
   CheckTimestamp();
   CheckBinary("", 24);
-}
 
-TEST_F(DndTestDnode, 05_CreateDnode) {
   {
     SCreateDnodeMsg* pReq = (SCreateDnodeMsg*)rpcMallocCont(sizeof(SCreateDnodeMsg));
     strcpy(pReq->ep, "localhost:9043");
@@ -359,9 +355,8 @@ TEST_F(DndTestDnode, 05_CreateDnode) {
   CheckBinary("", 24);
   CheckBinary("", 24);
   CheckBinary("", 24);
-}
 
-TEST_F(DndTestDnode, 06_RestartDnode) {
+  // restart
   uInfo("stop all server");
   stopServer(pServer1);
   stopServer(pServer2);

source/dnode/mgmt/impl/test/profile/profile.cpp

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+/**
+ * @file vnodeApiTests.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module profile-msg tests
+ * @version 0.1
+ * @date 2021-12-15
  *
- * 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.
+ * @copyright Copyright (c) 2021
  *
- * 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 "deploy.h"

source/dnode/mgmt/impl/test/show/show.cpp

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+/**
+ * @file vnodeApiTests.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module show-msg tests
+ * @version 0.1
+ * @date 2021-12-15
  *
- * 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.
+ * @copyright Copyright (c) 2021
  *
- * 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 "deploy.h"

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

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+/**
+ * @file vnodeApiTests.cpp
+ * @author slguan (slguan@taosdata.com)
+ * @brief DNODE module user-msg tests
+ * @version 0.1
+ * @date 2021-12-15
  *
- * 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.
+ * @copyright Copyright (c) 2021
  *
- * 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 "deploy.h"
@@ -67,10 +63,10 @@ class DndTestUser : public ::testing::Test {
     ASSERT_NE(pShowRsp, nullptr);
     pShowRsp->showId = htonl(pShowRsp->showId);
     pMeta = &pShowRsp->tableMeta;
-    pMeta->numOfTags = htons(pMeta->numOfTags);
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    pMeta->sversion = htons(pMeta->sversion);
-    pMeta->tversion = htons(pMeta->tversion);
+    pMeta->numOfTags = htonl(pMeta->numOfTags);
+    pMeta->numOfColumns = htonl(pMeta->numOfColumns);
+    pMeta->sversion = htonl(pMeta->sversion);
+    pMeta->tversion = htonl(pMeta->tversion);
     pMeta->tuid = htobe64(pMeta->tuid);
     pMeta->suid = htobe64(pMeta->suid);
 
@@ -184,7 +180,7 @@ TEST_F(DndTestUser, 01_ShowUser) {
   CheckBinary("root", TSDB_USER_LEN);
 }
 
-TEST_F(DndTestUser, 02_CreateUser) {
+TEST_F(DndTestUser, 02_Create_Drop_Alter_User) {
   {
     SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(sizeof(SCreateUserMsg));
     strcpy(pReq->user, "u1");
@@ -231,9 +227,8 @@ TEST_F(DndTestUser, 02_CreateUser) {
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("root", TSDB_USER_LEN);
-}
 
-TEST_F(DndTestUser, 03_AlterUser) {
+  {
     SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(sizeof(SAlterUserMsg));
     strcpy(pReq->user, "u1");
     strcpy(pReq->pass, "p2");
@@ -247,7 +242,7 @@ TEST_F(DndTestUser, 03_AlterUser) {
     SRpcMsg* pMsg = pClient->pRsp;
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
-
+  }
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
   SendThenCheckShowRetrieveMsg(3);
   CheckBinary("u1", TSDB_USER_LEN);
@@ -262,9 +257,8 @@ TEST_F(DndTestUser, 03_AlterUser) {
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("root", TSDB_USER_LEN);
-}
 
-TEST_F(DndTestUser, 04_DropUser) {
+  {
     SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(sizeof(SDropUserMsg));
     strcpy(pReq->user, "u1");
 
@@ -277,7 +271,7 @@ TEST_F(DndTestUser, 04_DropUser) {
     SRpcMsg* pMsg = pClient->pRsp;
     ASSERT_NE(pMsg, nullptr);
     ASSERT_EQ(pMsg->code, 0);
-
+  }
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
   SendThenCheckShowRetrieveMsg(2);
   CheckBinary("root", TSDB_USER_LEN);
@@ -288,9 +282,8 @@ TEST_F(DndTestUser, 04_DropUser) {
   CheckTimestamp();
   CheckBinary("root", TSDB_USER_LEN);
   CheckBinary("root", TSDB_USER_LEN);
-}
 
-TEST_F(DndTestUser, 05_RestartDnode) {
+  // restart
   stopServer(pServer);
   pServer = NULL;
 

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

@@ -42,13 +42,6 @@ extern int32_t mDebugFlag;
 #define mDebug(...) { if (mDebugFlag & DEBUG_DEBUG) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
 #define mTrace(...) { if (mDebugFlag & DEBUG_TRACE) { taosPrintLog("MND ", mDebugFlag, __VA_ARGS__); }}
 
-typedef struct SClusterObj SClusterObj;
-typedef struct SMnodeObj   SMnodeObj;
-typedef struct SAcctObj    SAcctObj;
-typedef struct SVgObj      SVgObj;
-typedef struct SFuncObj    SFuncObj;
-typedef struct SOperObj    SOperObj;
-
 typedef enum {
   MND_AUTH_ACCT_START = 0,
   MND_AUTH_ACCT_USER,
@@ -99,7 +92,7 @@ typedef enum {
   DND_REASON_OTHERS
 } EDndReason;
 
-typedef struct STrans {
+typedef struct {
   int32_t    id;
   ETrnStage  stage;
   ETrnPolicy policy;
@@ -111,7 +104,7 @@ typedef struct STrans {
   SArray    *undoActions;
 } STrans;
 
-typedef struct SClusterObj {
+typedef struct {
   int32_t id;
   char    name[TSDB_CLUSTER_ID_LEN];
   int64_t createdTime;
@@ -139,7 +132,7 @@ typedef struct {
   char       ep[TSDB_EP_LEN];
 } SDnodeObj;
 
-typedef struct SMnodeObj {
+typedef struct {
   int32_t    id;
   int64_t    createdTime;
   int64_t    updateTime;
@@ -167,7 +160,7 @@ typedef struct {
   int64_t compStorage;   // Compressed storage on disk
 } SAcctInfo;
 
-typedef struct SAcctObj {
+typedef struct {
   char      acct[TSDB_USER_LEN];
   int64_t   createdTime;
   int64_t   updateTime;
@@ -195,8 +188,8 @@ typedef struct {
   int32_t daysToKeep0;
   int32_t daysToKeep1;
   int32_t daysToKeep2;
-  int32_t minRowsPerFileBlock;
-  int32_t maxRowsPerFileBlock;
+  int32_t minRows;
+  int32_t maxRows;
   int32_t commitTime;
   int32_t fsyncPeriod;
   int8_t  walLevel;
@@ -214,7 +207,10 @@ typedef struct {
   int64_t createdTime;
   int64_t updateTime;
   int64_t uid;
-  int32_t version;
+  int32_t cfgVersion;
+  int32_t vgVersion;
+  int32_t numOfVgroups;
+  int8_t  hashMethod;  // default is 1
   SDbCfg  cfg;
 } SDbObj;
 
@@ -223,12 +219,15 @@ typedef struct {
   ESyncState role;
 } SVnodeGid;
 
-typedef struct SVgObj {
+typedef struct {
   int32_t   vgId;
   int64_t   createdTime;
   int64_t   updateTime;
   int32_t   version;
+  uint32_t  hashBegin;
+  uint32_t  hashEnd;
   char      dbName[TSDB_FULL_DB_NAME_LEN];
+  int64_t   dbUid;
   int32_t   numOfTables;
   int32_t   numOfTimeSeries;
   int64_t   totalStorage;
@@ -245,6 +244,7 @@ typedef struct {
   int64_t  createdTime;
   int64_t  updateTime;
   uint64_t uid;
+  uint64_t dbUid;
   int32_t  version;
   int32_t  numOfColumns;
   int32_t  numOfTags;
@@ -252,7 +252,7 @@ typedef struct {
   SSchema *pSchema;
 } SStbObj;
 
-typedef struct SFuncObj {
+typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
   int64_t createdTime;
   int8_t  funcType;

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

@@ -28,6 +28,7 @@ SDnodeObj *mndAcquireDnode(SMnode *pMnode, int32_t dnodeId);
 void       mndReleaseDnode(SMnode *pMnode, SDnodeObj *pDnode);
 SEpSet     mndGetDnodeEpset(SDnodeObj *pDnode);
 int32_t    mndGetDnodeSize(SMnode *pMnode);
+bool       mndIsDnodeInReadyStatus(SMnode *pMnode, SDnodeObj *pDnode);
 
 #ifdef __cplusplus
 }

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

@@ -26,6 +26,9 @@ int32_t mndInitVgroup(SMnode *pMnode);
 void     mndCleanupVgroup(SMnode *pMnode);
 SVgObj  *mndAcquireVgroup(SMnode *pMnode, int32_t vgId);
 void     mndReleaseVgroup(SMnode *pMnode, SVgObj *pVgroup);
+int32_t  mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups);
+SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup);
+SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw);
 
 #ifdef __cplusplus
 }

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

@@ -143,22 +143,22 @@ static int32_t mndGetClusterMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_CLUSTER_ID_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
   strcpy(pSchema[cols].name, "create_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   strcpy(pMeta->tbFname, mndShowStr(pShow->type));
   pShow->numOfColumns = cols;
 

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

@@ -218,6 +218,15 @@ int32_t mndGetDnodeSize(SMnode *pMnode) {
   return sdbGetSize(pSdb, SDB_DNODE);
 }
 
+bool mndIsDnodeInReadyStatus(SMnode *pMnode, SDnodeObj *pDnode) {
+  int64_t ms = taosGetTimestampMs();
+  int64_t interval = ABS(pDnode->lastAccessTime - ms);
+  if (interval > 3000 * pMnode->cfg.statusInterval) {
+    return false;
+  }
+  return true;
+}
+
 static void mndGetDnodeData(SMnode *pMnode, SDnodeEps *pEps, int32_t numOfEps) {
   SSdb *pSdb = pMnode->pSdb;
 
@@ -552,16 +561,16 @@ static int32_t mndGetConfigMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg
   pShow->bytes[cols] = TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   tstrncpy(pSchema[cols].name, "name", sizeof(pSchema[cols].name));
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_CONIIG_VALUE_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   tstrncpy(pSchema[cols].name, "value", sizeof(pSchema[cols].name));
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;
@@ -629,46 +638,46 @@ static int32_t mndGetDnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
   pShow->bytes[cols] = 2;
   pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
   strcpy(pSchema[cols].name, "id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "end point");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "endpoint");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 2;
   pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
   strcpy(pSchema[cols].name, "vnodes");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 2;
   pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-  strcpy(pSchema[cols].name, "max vnodes");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "max_vnodes");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 10 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "status");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "create_time");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 24 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "offline reason");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "offline_reason");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;

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

@@ -380,46 +380,46 @@ static int32_t mndGetFuncMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *p
   pShow->bytes[cols] = TSDB_FUNC_NAME_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = PATH_MAX + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "comment");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "aggregate");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_TYPE_STR_MAX_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "outputtype");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
   strcpy(pSchema[cols].name, "create_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "code_len");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "bufsize");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;

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

@@ -368,34 +368,34 @@ static int32_t mndGetMnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
   pShow->bytes[cols] = 2;
   pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
   strcpy(pSchema[cols].name, "id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "end point");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "endpoint");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 12 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "role");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "role time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "role_time");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "create_time");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;

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

@@ -474,48 +474,48 @@ static int32_t mndGetConnsMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "connId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "user");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   // app name
   pShow->bytes[cols] = TSDB_APP_NAME_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "program");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   // app pid
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "pid");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "ip:port");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
   strcpy(pSchema[cols].name, "login_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
   strcpy(pSchema[cols].name, "last_access");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;
@@ -602,88 +602,88 @@ static int32_t mndGetQueryMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "queryId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "connId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "user");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "ip:port");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 24;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "qid");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
   strcpy(pSchema[cols].name, "created_time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_BIGINT;
   strcpy(pSchema[cols].name, "time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = QUERY_OBJ_ID_SIZE + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "sql_obj_id");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "pid");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_EP_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "ep");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 1;
   pSchema[cols].type = TSDB_DATA_TYPE_BOOL;
   strcpy(pSchema[cols].name, "stable_query");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "sub_queries");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_SHOW_SUBQUERY_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "sub_query_info");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "sql");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;
@@ -818,64 +818,64 @@ static int32_t mndGetStreamMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "streamId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "connId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "user");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-  strcpy(pSchema[cols].name, "dest table");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "destination");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_IPv4ADDR_LEN + 6 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "ip:port");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "created time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "create_time");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "exec time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "exec");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_BIGINT;
   strcpy(pSchema[cols].name, "time(us)");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "sql");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "cycles");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;

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

@@ -74,10 +74,12 @@ static SSdbRaw *mndStbActionEncode(SStbObj *pStb) {
   if (pRaw == NULL) return NULL;
 
   int32_t dataPos = 0;
-  SDB_SET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_NAME_LEN)
+  SDB_SET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN)
+  SDB_SET_BINARY(pRaw, dataPos, pStb->db, TSDB_FULL_DB_NAME_LEN)
   SDB_SET_INT64(pRaw, dataPos, pStb->createdTime)
   SDB_SET_INT64(pRaw, dataPos, pStb->updateTime)
   SDB_SET_INT64(pRaw, dataPos, pStb->uid)
+  SDB_SET_INT64(pRaw, dataPos, pStb->dbUid)
   SDB_SET_INT64(pRaw, dataPos, pStb->version)
   SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns)
   SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags)
@@ -113,10 +115,12 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
   if (pStb == NULL) return NULL;
 
   int32_t dataPos = 0;
-  SDB_GET_BINARY(pRaw, pRow, dataPos, pStb->name, TSDB_TABLE_NAME_LEN)
+  SDB_GET_BINARY(pRaw, pRow, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN)
+  SDB_GET_BINARY(pRaw, pRow, dataPos, pStb->db, TSDB_FULL_DB_NAME_LEN)
   SDB_GET_INT64(pRaw, pRow, dataPos, &pStb->createdTime)
   SDB_GET_INT64(pRaw, pRow, dataPos, &pStb->updateTime)
   SDB_GET_INT64(pRaw, pRow, dataPos, &pStb->uid)
+  SDB_GET_INT64(pRaw, pRow, dataPos, &pStb->dbUid)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pStb->version)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pStb->numOfColumns)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pStb->numOfTags)
@@ -570,28 +574,28 @@ static int32_t mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pM
   pShow->bytes[cols] = TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  strcpy(pSchema[cols].name, "create_time");
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 2;
   pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
   strcpy(pSchema[cols].name, "columns");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 2;
   pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
   strcpy(pSchema[cols].name, "tags");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;

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

@@ -410,28 +410,28 @@ static int32_t mndGetUserMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *p
   pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "name");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 10 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "privilege");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
   strcpy(pSchema[cols].name, "create time");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = TSDB_USER_LEN + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "account");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;

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

@@ -24,8 +24,6 @@
 #define TSDB_VGROUP_VER_NUM 1
 #define TSDB_VGROUP_RESERVE_SIZE 64
 
-static SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup);
-static SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw);
 static int32_t mndVgroupActionInsert(SSdb *pSdb, SVgObj *pVgroup);
 static int32_t mndVgroupActionDelete(SSdb *pSdb, SVgObj *pVgroup);
 static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOldVgroup, SVgObj *pNewVgroup);
@@ -70,8 +68,8 @@ int32_t mndInitVgroup(SMnode *pMnode) {
 
 void mndCleanupVgroup(SMnode *pMnode) {}
 
-static SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup) {
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, TSDB_VGROUP_VER_NUM, sizeof(SVgObj) + TSDB_VGROUP_RESERVE_SIZE);
+SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup) {
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_VGROUP, TSDB_VGROUP_VER_NUM, sizeof(SVgObj) + TSDB_VGROUP_RESERVE_SIZE);
   if (pRaw == NULL) return NULL;
 
   int32_t dataPos = 0;
@@ -79,7 +77,10 @@ static SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup) {
   SDB_SET_INT64(pRaw, dataPos, pVgroup->createdTime)
   SDB_SET_INT64(pRaw, dataPos, pVgroup->updateTime)
   SDB_SET_INT32(pRaw, dataPos, pVgroup->version)
+  SDB_SET_INT32(pRaw, dataPos, pVgroup->hashBegin)
+  SDB_SET_INT32(pRaw, dataPos, pVgroup->hashEnd)
   SDB_SET_BINARY(pRaw, dataPos, pVgroup->dbName, TSDB_FULL_DB_NAME_LEN)
+  SDB_SET_INT64(pRaw, dataPos, pVgroup->dbUid)
   SDB_SET_INT8(pRaw, dataPos, pVgroup->replica)
   for (int8_t i = 0; i < pVgroup->replica; ++i) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
@@ -92,7 +93,7 @@ static SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup) {
   return pRaw;
 }
 
-static SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw) {
+SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw) {
   int8_t sver = 0;
   if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
 
@@ -102,7 +103,7 @@ static SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw) {
     return NULL;
   }
 
-  SSdbRow *pRow = sdbAllocRow(sizeof(SDbObj));
+  SSdbRow *pRow = sdbAllocRow(sizeof(SVgObj));
   SVgObj  *pVgroup = sdbGetRowObj(pRow);
   if (pVgroup == NULL) return NULL;
 
@@ -111,7 +112,10 @@ static SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT64(pRaw, pRow, dataPos, &pVgroup->createdTime)
   SDB_GET_INT64(pRaw, pRow, dataPos, &pVgroup->updateTime)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pVgroup->version)
+  SDB_GET_INT32(pRaw, pRow, dataPos, &pVgroup->hashBegin)
+  SDB_GET_INT32(pRaw, pRow, dataPos, &pVgroup->hashEnd)
   SDB_GET_BINARY(pRaw, pRow, dataPos, pVgroup->dbName, TSDB_FULL_DB_NAME_LEN)
+  SDB_GET_INT64(pRaw, pRow, dataPos, &pVgroup->dbUid)
   SDB_GET_INT8(pRaw, pRow, dataPos, &pVgroup->replica)
   for (int8_t i = 0; i < pVgroup->replica; ++i) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
@@ -133,12 +137,6 @@ static int32_t mndVgroupActionDelete(SSdb *pSdb, SVgObj *pVgroup) {
   return 0;
 }
 
-static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pMsg) { return 0; }
-static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pMsg) { return 0; }
-static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg) { return 0; }
-static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pMsg) { return 0; }
-static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pMsg) { return 0; }
-
 static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOldVgroup, SVgObj *pNewVgroup) {
   mTrace("vgId:%d, perform update action", pOldVgroup->vgId);
   pOldVgroup->updateTime = pNewVgroup->updateTime;
@@ -158,6 +156,105 @@ void mndReleaseVgroup(SMnode *pMnode, SVgObj *pVgroup) {
   sdbRelease(pSdb, pVgroup);
 }
 
+static int32_t mndGetDefaultVgroupSize(SMnode *pMnode) {
+  // todo
+  return 2;
+}
+
+static int32_t mndGetAvailableDnode(SMnode *pMnode, SVgObj *pVgroup) {
+  SSdb   *pSdb = pMnode->pSdb;
+  int32_t allocedVnodes = 0;
+  void   *pIter = NULL;
+
+  while (allocedVnodes < pVgroup->replica) {
+    SDnodeObj *pDnode = NULL;
+    pIter = sdbFetch(pSdb, SDB_DNODE, pIter, (void **)&pDnode);
+    if (pIter == NULL) break;
+
+    // todo
+    if (mndIsDnodeInReadyStatus(pMnode, pDnode)) {
+      SVnodeGid *pVgid = &pVgroup->vnodeGid[allocedVnodes];
+      pVgid->dnodeId = pDnode->id;
+      if (pVgroup->replica == 1) {
+        pVgid->role = TAOS_SYNC_STATE_LEADER;
+      } else {
+        pVgid->role = TAOS_SYNC_STATE_FOLLOWER;
+      }
+      allocedVnodes++;
+    }
+    sdbRelease(pSdb, pDnode);
+  }
+
+  if (allocedVnodes != pVgroup->replica) {
+    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
+    return -1;
+  }
+  return 0;
+}
+
+int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) {
+  if (pDb->numOfVgroups != -1 &&
+      (pDb->numOfVgroups < TSDB_MIN_VNODES_PER_DB || pDb->numOfVgroups > TSDB_MAX_VNODES_PER_DB)) {
+    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    return -1;
+  }
+
+  if (pDb->numOfVgroups == -1) {
+    pDb->numOfVgroups = mndGetDefaultVgroupSize(pMnode);
+    if (pDb->numOfVgroups < 0) {
+      terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
+      return -1;
+    }
+  }
+
+  SVgObj *pVgroups = calloc(pDb->numOfVgroups, sizeof(SVgObj));
+  if (pVgroups == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  int32_t  alloceVgroups = 0;
+  int32_t  maxVgId = sdbGetMaxId(pMnode->pSdb, SDB_VGROUP);
+  uint32_t hashMin = 0;
+  uint32_t hashMax = UINT32_MAX;
+  uint32_t hashInterval = (hashMax - hashMin) / pDb->numOfVgroups;
+
+  for (uint32_t v = 0; v < pDb->numOfVgroups; v++) {
+    SVgObj *pVgroup = &pVgroups[v];
+    pVgroup->vgId = maxVgId++;
+    pVgroup->createdTime = taosGetTimestampMs();
+    pVgroup->updateTime = pVgroups->createdTime;
+    pVgroup->version = 1;
+    pVgroup->dbUid = pDb->uid;
+    pVgroup->hashBegin = hashMin + hashInterval * v;
+    if (v == pDb->numOfVgroups - 1) {
+      pVgroup->hashEnd = hashMax;
+    } else {
+      pVgroup->hashEnd = hashMin + hashInterval * (v + 1) - 1;
+    }
+
+    memcpy(pVgroup->dbName, pDb->name, TSDB_FULL_DB_NAME_LEN);
+    pVgroup->replica = pDb->cfg.replications;
+
+    if (mndGetAvailableDnode(pMnode, pVgroup) != 0) {
+      terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
+      free(pVgroups);
+      return -1;
+    }
+
+    alloceVgroups++;
+  }
+
+  *ppVgroups = pVgroups;
+  return 0;
+}
+
+static int32_t mndProcessCreateVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessAlterVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+
 static int32_t mndGetVgroupMaxReplica(SMnode *pMnode, char *dbName, int8_t *pReplica, int32_t *pNumOfVgroups) {
   SSdb *pSdb = pMnode->pSdb;
 
@@ -203,30 +300,30 @@ static int32_t mndGetVgroupMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "vgId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "tables");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   for (int32_t i = 0; i < pShow->replica; ++i) {
-    pShow->bytes[cols] = 4;
+    pShow->bytes[cols] = 2;
     pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
     snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "v%d_dnode", i + 1);
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
+    pSchema[cols].bytes = htonl(pShow->bytes[cols]);
     cols++;
 
     pShow->bytes[cols] = 9 + VARSTR_HEADER_SIZE;
     pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
     snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "v%d_status", i + 1);
-    pSchema[cols].bytes = htons(pShow->bytes[cols]);
+    pSchema[cols].bytes = htonl(pShow->bytes[cols]);
     cols++;
   }
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;
@@ -273,10 +370,6 @@ static int32_t mndRetrieveVgroups(SMnodeMsg *pMsg, SShowObj *pShow, char *data,
       cols++;
     }
 
-    pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int8_t *)pWrite = pVgroup->compact; 
-    cols++;
-    
     sdbRelease(pSdb, pVgroup);
     numOfRows++;
   }
@@ -309,16 +402,16 @@ static int32_t mndGetVnodeMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;
   strcpy(pSchema[cols].name, "vgId");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
   pShow->bytes[cols] = 12 + VARSTR_HEADER_SIZE;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "status");
-  pSchema[cols].bytes = htons(pShow->bytes[cols]);
+  pSchema[cols].bytes = htonl(pShow->bytes[cols]);
   cols++;
 
-  pMeta->numOfColumns = htons(cols);
+  pMeta->numOfColumns = htonl(cols);
   pShow->numOfColumns = cols;
 
   pShow->offset[0] = 0;

source/dnode/vnode/impl/inc/vnodeStateMgr.h

@@ -21,9 +21,9 @@ extern "C" {
 #endif
 
 typedef struct {
-  uint64_t processed;
-  uint64_t committed;
-  uint64_t applied;
+  int64_t processed;
+  int64_t committed;
+  int64_t applied;
 } SVState;
 
 #ifdef __cplusplus

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

@@ -15,16 +15,31 @@
 
 #include "vnodeDef.h"
 
+int vnodeProcessNoWalWMsgs(SVnode *pVnode, SRpcMsg *pMsg) {
+  SVnodeReq *pVnodeReq;
+
+  switch (pMsg->msgType) {
+    case TSDB_MSG_TYPE_MQ_SET:
+      if (tqSetCursor(pVnode->pTq, pMsg->pCont) < 0) {
+        // TODO: handle error
+      }
+      break;
+  }
+
+  void *pBuf = pMsg->pCont;
+  return 0;
+}
+
 int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
-  SRpcMsg *  pMsg;
+  SRpcMsg   *pMsg;
   SVnodeReq *pVnodeReq;
 
   for (int i = 0; i < taosArrayGetSize(pMsgs); i++) {
     pMsg = *(SRpcMsg **)taosArrayGet(pMsgs, i);
 
     // ser request version
-    void *   pBuf = pMsg->pCont;
-    uint64_t ver = pVnode->state.processed++;
+    void   *pBuf = pMsg->pCont;
+    int64_t ver = pVnode->state.processed++;
     taosEncodeFixedU64(&pBuf, ver);
 
     if (walWrite(pVnode->pWal, ver, pMsg->msgType, pMsg->pCont, pMsg->contLen) < 0) {

source/dnode/vnode/tq/inc/tqInt.h

@@ -22,16 +22,16 @@
 extern "C" {
 #endif
 
-//create persistent storage for meta info such as consuming offset
-//return value > 0: cgId
-//return value <= 0: error code
-//int tqCreateTCGroup(STQ*, const char* topic, int cgId, tqBufferHandle** handle);
-//create ring buffer in memory and load consuming offset
-//int tqOpenTCGroup(STQ*, const char* topic, int cgId);
-//destroy ring buffer and persist consuming offset
-//int tqCloseTCGroup(STQ*, const char* topic, int cgId);
-//delete persistent storage for meta info
-//int tqDropTCGroup(STQ*, const char* topic, int cgId);
+// create persistent storage for meta info such as consuming offset
+// return value > 0: cgId
+// return value <= 0: error code
+// int tqCreateTCGroup(STQ*, const char* topic, int cgId, tqBufferHandle** handle);
+// create ring buffer in memory and load consuming offset
+// int tqOpenTCGroup(STQ*, const char* topic, int cgId);
+// destroy ring buffer and persist consuming offset
+// int tqCloseTCGroup(STQ*, const char* topic, int cgId);
+// delete persistent storage for meta info
+// int tqDropTCGroup(STQ*, const char* topic, int cgId);
 
 #ifdef __cplusplus
 }

source/dnode/vnode/tq/inc/tqMetaStore.h

@@ -23,27 +23,22 @@
 extern "C" {
 #endif
 
-
-STqMetaStore*  tqStoreOpen(const char* path,
-    TqSerializeFun   pSerializer,
-    TqDeserializeFun pDeserializer,
-    TqDeleteFun      pDeleter,
-    int32_t          tqConfigFlag
-  );
+STqMetaStore* tqStoreOpen(const char* path, FTqSerialize pSerializer, FTqDeserialize pDeserializer, FTqDelete pDeleter,
+                          int32_t tqConfigFlag);
 int32_t       tqStoreClose(STqMetaStore*);
-//int32_t       tqStoreDelete(TqMetaStore*);
-//int32_t       tqStoreCommitAll(TqMetaStore*);
+// int32_t       tqStoreDelete(TqMetaStore*);
+// int32_t       tqStoreCommitAll(TqMetaStore*);
 int32_t tqStorePersist(STqMetaStore*);
-//clean deleted idx and data from persistent file
+// clean deleted idx and data from persistent file
 int32_t tqStoreCompact(STqMetaStore*);
 
 void* tqHandleGet(STqMetaStore*, int64_t key);
-//make it unpersist
+// make it unpersist
 void*   tqHandleTouchGet(STqMetaStore*, int64_t key);
 int32_t tqHandleMovePut(STqMetaStore*, int64_t key, void* value);
 int32_t tqHandleCopyPut(STqMetaStore*, int64_t key, void* value, size_t vsize);
-//delete committed kv pair
-//notice that a delete action still needs to be committed
+// delete committed kv pair
+// notice that a delete action still needs to be committed
 int32_t tqHandleDel(STqMetaStore*, int64_t key);
 int32_t tqHandleCommit(STqMetaStore*, int64_t key);
 int32_t tqHandleAbort(STqMetaStore*, int64_t key);

source/dnode/vnode/tq/test/tqMetaTest.cpp

@@ -9,17 +9,17 @@ struct Foo {
   int32_t a;
 };
 
-int FooSerializer(const void* pObj, TqSerializedHead** ppHead) {
+int FooSerializer(const void* pObj, STqSerializedHead** ppHead) {
   Foo* foo = (Foo*) pObj;
-  if((*ppHead) == NULL || (*ppHead)->ssize < sizeof(TqSerializedHead) + sizeof(int32_t)) {
-    *ppHead = (TqSerializedHead*)realloc(*ppHead, sizeof(TqSerializedHead) + sizeof(int32_t));
-    (*ppHead)->ssize = sizeof(TqSerializedHead) + sizeof(int32_t);
+  if((*ppHead) == NULL || (*ppHead)->ssize < sizeof(STqSerializedHead) + sizeof(int32_t)) {
+    *ppHead = (STqSerializedHead*)realloc(*ppHead, sizeof(STqSerializedHead) + sizeof(int32_t));
+    (*ppHead)->ssize = sizeof(STqSerializedHead) + sizeof(int32_t);
   }
   *(int32_t*)(*ppHead)->content = foo->a;
   return (*ppHead)->ssize;
 }
 
-const void* FooDeserializer(const TqSerializedHead* pHead, void** ppObj) {
+const void* FooDeserializer(const STqSerializedHead* pHead, void** ppObj) {
   if(*ppObj == NULL) {
     *ppObj = realloc(*ppObj, sizeof(int32_t));
   }

source/libs/catalog/CMakeLists.txt

@@ -10,3 +10,5 @@ target_link_libraries(
    catalog
    PRIVATE os util common transport query
 )
+
+ADD_SUBDIRECTORY(test)
\ No newline at end of file

source/libs/catalog/inc/catalogInt.h

@@ -70,9 +70,10 @@ extern int32_t ctgDebugFlag;
 #define ctgDebugL(...) do { if (ctgDebugFlag & DEBUG_DEBUG) { taosPrintLongString("CTG ", ctgDebugFlag, __VA_ARGS__); }} while(0)
 
 
-#define CTG_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { return _code; } } while (0)
-#define CTG_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { ctgError(__VA_ARGS__); return _code; } } while (0)
-#define CTG_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { goto _return; } } while (0)
+#define CTG_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0)
+#define CTG_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0)
+#define CTG_ERR_LRET(c,...) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { ctgError(__VA_ARGS__); terrno = _code; return _code; } } while (0)
+#define CTG_ERR_JRET(c) do { code = c; if (code != TSDB_CODE_SUCCESS) { terrno = code; goto _return; } } while (0)
 
 
 #ifdef __cplusplus

source/libs/catalog/test/CMakeLists.txt

+
+MESSAGE(STATUS "build catalog unit test")
+
+# GoogleTest requires at least C++11
+SET(CMAKE_CXX_STANDARD 11)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
+
+ADD_EXECUTABLE(catalogTest ${SOURCE_LIST})
+TARGET_LINK_LIBRARIES(
+        catalogTest
+        PUBLIC os util common catalog transport gtest query taos
+)
+
+TARGET_INCLUDE_DIRECTORIES(
+        catalogTest
+        PUBLIC "${CMAKE_SOURCE_DIR}/include/libs/catalog/"
+        PRIVATE "${CMAKE_SOURCE_DIR}/source/libs/catalog/inc"
+)

source/libs/catalog/test/catalogTests.cpp

+/*
+ * 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 <gtest/gtest.h>
+#include <tglobal.h>
+#include <iostream>
+#pragma GCC diagnostic ignored "-Wwrite-strings"
+
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#include "os.h"
+
+#include "taos.h"
+#include "tdef.h"
+#include "tvariant.h"
+#include "catalog.h"
+#include "tep.h"
+#include "trpc.h"
+
+typedef struct SAppInstInfo {
+  int64_t           numOfConns;
+  SCorEpSet         mgmtEp;
+} SAppInstInfo;
+
+typedef struct STscObj {
+  char               user[TSDB_USER_LEN];
+  char               pass[TSDB_PASSWORD_LEN];
+  char               acctId[TSDB_ACCT_ID_LEN];
+  char               db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN];
+  uint32_t           connId;
+  uint64_t           id;       // ref ID returned by taosAddRef
+//  struct SSqlObj    *sqlList;
+  void              *pTransporter;
+  pthread_mutex_t    mutex;     // used to protect the operation on db
+  int32_t            numOfReqs; // number of sqlObj from this tscObj
+  SAppInstInfo      *pAppInfo;
+} STscObj;
+
+namespace {
+
+void sendCreateDbMsg(void *shandle, SEpSet *pEpSet) {
+  SCreateDbMsg* pReq = (SCreateDbMsg*)rpcMallocCont(sizeof(SCreateDbMsg));
+  strcpy(pReq->db, "1.db1");
+  pReq->numOfVgroups = htonl(2);
+  pReq->cacheBlockSize = htonl(16);
+  pReq->totalBlocks = htonl(10);
+  pReq->daysPerFile = htonl(10);
+  pReq->daysToKeep0 = htonl(3650);
+  pReq->daysToKeep1 = htonl(3650);
+  pReq->daysToKeep2 = htonl(3650);
+  pReq->minRowsPerFileBlock = htonl(100);
+  pReq->maxRowsPerFileBlock = htonl(4096);
+  pReq->commitTime = htonl(3600);
+  pReq->fsyncPeriod = htonl(3000);
+  pReq->walLevel = 1;
+  pReq->precision = 0;
+  pReq->compression = 2;
+  pReq->replications = 1;
+  pReq->quorum = 1;
+  pReq->update = 0;
+  pReq->cacheLastRow = 0;
+  pReq->ignoreExist = 1;
+  
+  SRpcMsg rpcMsg = {0};
+  rpcMsg.pCont = pReq;
+  rpcMsg.contLen = sizeof(SCreateDbMsg);
+  rpcMsg.msgType = TSDB_MSG_TYPE_CREATE_DB;
+
+  SRpcMsg rpcRsp = {0};
+
+  rpcSendRecv(shandle, pEpSet, &rpcMsg, &rpcRsp);
+
+  ASSERT_EQ(rpcRsp.code, 0);
+}
+
+}
+
+TEST(testCase, normalCase) {
+  STscObj* pConn = (STscObj *)taos_connect("127.0.0.1", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  char *clusterId = "cluster1";
+  char *dbname = "1.db1";
+  char *tablename = "table1";
+  struct SCatalog* pCtg = NULL;
+  void *mockPointer = (void *)0x1;
+  SVgroupInfo vgInfo = {0};
+
+  msgInit();
+
+  sendCreateDbMsg(pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet);
+  
+  int32_t code = catalogInit(NULL);
+  ASSERT_EQ(code, 0);
+
+  code = catalogGetHandle(clusterId, &pCtg);
+  ASSERT_EQ(code, 0);
+
+  code = catalogGetTableHashVgroup(pCtg, pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet, dbname, tablename, &vgInfo);
+  ASSERT_EQ(code, 0);
+
+  taos_close(pConn);
+}
+
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+
+
+

source/libs/index/inc/indexInt.h

@@ -17,7 +17,10 @@
 #define _TD_INDEX_INT_H_
 
 #include "index.h"
+#include "index_fst.h"
 #include "tlog.h"
+#include "thash.h"
+#include "taos.h"
 
 #ifdef USE_LUCENE
 #include <lucene++/Lucene_c.h>
@@ -32,12 +35,20 @@ struct SIndex {
 #ifdef USE_LUCENE 
  index_t *index; 
 #endif  
+ void     *cache;
+ void     *tindex; 
+ SHashObj *fieldObj;  // <field name, field id> 
+ uint64_t suid; 
+ int      fieldId; 
+ pthread_mutex_t mtx;
 };   
 
 struct SIndexOpts {
 #ifdef USE_LUCENE 
   void *opts; 
 #endif  
+  int32_t numOfItermLimit;
+  int8_t  mergeInterval; 
 };
 
 struct SIndexMultiTermQuery {

include/util/tmacro.h → source/libs/index/inc/index_cache.h

@@ -12,31 +12,42 @@
  * 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 __INDEX_CACHE_H__
+#define __INDEX_CACHE_H__
 
-#ifndef _TD_UTIL_MACRO_H_
-#define _TD_UTIL_MACRO_H_
+#include "index.h"
+#include "tlockfree.h"
+// ----------------- row structure in skiplist ---------------------
 
-#include "os.h"
+/* A data row, the format is like below:
+ * |<--totalLen-->|<-- fieldId-->|<-- value len--->|<-- value-->|<--version--->|<-- itermType -->|
+ *
+ */
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-// Module init/clear MACRO definitions
-#define TD_MOD_UNINITIALIZED 0
-#define TD_MOD_INITIALIZED 1
+typedef struct IndexCache {
+  T_REF_DECLARE() 
+  int cVersion; // 
+} IndexCache;
+
 
-#define TD_MOD_UNCLEARD 0
-#define TD_MOD_CLEARD 1
+// 
+IndexCache *indexCacheCreate();
 
-typedef int8_t td_mode_flag_t;
+void indexCacheDestroy(IndexCache *cache);
 
-#define TD_CHECK_AND_SET_MODE_INIT(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_UNINITIALIZED, TD_MOD_INITIALIZED)
+int indexCachePut(IndexCache *cache, int32_t fieldId,  const char *fieldVale,  int32_t fvlen, uint64_t uid, int8_t operaType); 
 
-#define TD_CHECK_AND_SET_MOD_CLEAR(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_UNCLEARD, TD_MOD_CLEARD)
+int indexCacheGet(IndexCache *cache, uint64_t *rst);
+int indexCacheSearch(IndexCache *cache, SIndexMultiTermQuery *query, SArray *result);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_UTIL_MACRO_H_*/
+
\ No newline at end of file
+
+#endif

source/libs/index/src/index_fst.c

@@ -1330,7 +1330,7 @@ StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallb
   SArray *nodes = taosArrayInit(8, sizeof(FstNode *));  
   while (taosArrayGetSize(sws->stack) > 0) {
     StreamState *p = (StreamState *)taosArrayPop(sws->stack);     
-    if (p->trans >= FST_NODE_LEN(p->node) || automFuncs[aut->type].canMatch(aut, p->autState)) {
+    if (p->trans >= FST_NODE_LEN(p->node) || !automFuncs[aut->type].canMatch(aut, p->autState)) {
       if (FST_NODE_ADDR(p->node) != fstGetRootAddr(sws->fst)) {
         taosArrayPop(sws->inp);
       }

source/libs/index/src/index_fst_automation.c

@@ -87,9 +87,18 @@ static void* prefixAccept(AutomationCtx *ctx, void *state, uint8_t byte) {
   if (ssv == NULL || ctx == NULL) {return NULL;}
 
   char *data = ctx->data;
+  if (ssv->kind == Done) {
+    return startWithStateValueCreate(Done, FST_INT, &ssv->val);
+  }
   if ((strlen(data) > ssv->val) && data[ssv->val] == byte) {
     int val = ssv->val + 1;
-    return startWithStateValueCreate(Running, FST_INT, &val);
+    StartWithStateValue *nsv = startWithStateValueCreate(Running, FST_INT, &val);
+    if (prefixIsMatch(ctx, nsv)) {
+      nsv->kind = Done;
+    } else {
+      nsv->kind = Running;
+    } 
+    return nsv;
   } 
   return NULL;
 }

source/libs/parser/inc/astToMsg.h

+#ifndef TDENGINE_ASTTOMSG_H
+#define TDENGINE_ASTTOMSG_H
+
+#include "parserInt.h"
+#include "taosmsg.h"
+
+SCreateUserMsg* buildUserManipulationMsg(SSqlInfo* pInfo, int64_t id, char* msgBuf, int32_t msgLen);
+
+#endif  // TDENGINE_ASTTOMSG_H

source/libs/scheduler/CMakeLists.txt

@@ -9,5 +9,5 @@ target_include_directories(
 
 target_link_libraries(
         scheduler
-        PRIVATE os util planner
+        PRIVATE os util planner common query
 )
\ No newline at end of file