diff --git a/.gitignore b/.gitignore
index 2308ea7896..f0067d26ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -86,6 +86,7 @@ tests/comparisonTest/opentsdb/opentsdbtest/.settings/
 tests/examples/JDBC/JDBCDemo/.classpath
 tests/examples/JDBC/JDBCDemo/.project
 tests/examples/JDBC/JDBCDemo/.settings/
+source/libs/parser/inc/new_sql.*
 
 # Emacs
 # -*- mode: gitignore; -*-
@@ -101,4 +102,4 @@ TAGS
 
 contrib/*
 !contrib/CMakeLists.txt
-!contrib/test
\ No newline at end of file
+!contrib/test
diff --git a/cmake/cmake.options b/cmake/cmake.options
index faa45256fb..e84d02800c 100644
--- a/cmake/cmake.options
+++ b/cmake/cmake.options
@@ -50,6 +50,12 @@ option(
     OFF
 )
 
+option(
+    BUILD_WITH_UV_TRANS
+    "If build with libuv_trans " 
+    OFF 
+)
+
 option(
     BUILD_WITH_CRAFT
     "If build with canonical-raft"
diff --git a/include/client/taos.h b/include/client/taos.h
index 40772e9d2c..626264d94e 100644
--- a/include/client/taos.h
+++ b/include/client/taos.h
@@ -92,14 +92,16 @@ typedef struct taosField {
 
 typedef void (*__taos_async_fn_t)(void *param, TAOS_RES *, int code);
 
-DLL_EXPORT void  taos_cleanup(void);
-DLL_EXPORT int   taos_options(TSDB_OPTION option, const void *arg, ...);
-DLL_EXPORT TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
-DLL_EXPORT 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);
-DLL_EXPORT TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port);
-DLL_EXPORT void  taos_close(TAOS *taos);
+typedef struct tmq_t tmq_t;
+typedef struct tmq_conf_t tmq_conf_t;
+typedef struct tmq_list_t tmq_list_t;
 
-const char *taos_data_type(int type);
+typedef struct tmq_message_t       tmq_message_t;
+typedef struct tmq_message_topic_t tmq_message_topic_t;
+typedef struct tmq_message_tb_t    tmq_message_tb_t;
+typedef struct tmq_tb_iter_t       tmq_tb_iter_t;
+typedef struct tmq_message_col_t   tmq_message_col_t;
+typedef struct tmq_col_iter_t      tmq_col_iter_t;
 
 typedef struct TAOS_BIND {
   int            buffer_type;
@@ -134,6 +136,15 @@ typedef struct TAOS_MULTI_BIND {
   int            num;
 } TAOS_MULTI_BIND;
 
+DLL_EXPORT void  taos_cleanup(void);
+DLL_EXPORT int   taos_options(TSDB_OPTION option, const void *arg, ...);
+DLL_EXPORT TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
+DLL_EXPORT 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);
+DLL_EXPORT TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port);
+DLL_EXPORT void  taos_close(TAOS *taos);
+
+const char *taos_data_type(int type);
+
 DLL_EXPORT TAOS_STMT *taos_stmt_init(TAOS *taos);
 DLL_EXPORT int        taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length);
 DLL_EXPORT int        taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags);
@@ -192,16 +203,6 @@ DLL_EXPORT void taos_close_stream(TAOS_STREAM *tstr);
 
 DLL_EXPORT int taos_load_table_info(TAOS *taos, const char* tableNameList);
 DLL_EXPORT TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int protocol, int precision);
-typedef struct tmq_t tmq_t;
-typedef struct tmq_conf_t tmq_conf_t;
-typedef struct tmq_list_t tmq_list_t;
-
-typedef struct tmq_message_t       tmq_message_t;
-typedef struct tmq_message_topic_t tmq_message_topic_t;
-typedef struct tmq_message_tb_t    tmq_message_tb_t;
-typedef struct tmq_tb_iter_t       tmq_tb_iter_t;
-typedef struct tmq_message_col_t   tmq_message_col_t;
-typedef struct tmq_col_iter_t      tmq_col_iter_t;
 
 DLL_EXPORT tmq_list_t* tmq_list_new();
 DLL_EXPORT int32_t tmq_list_append(tmq_list_t*, char*);
diff --git a/include/common/common.h b/include/common/common.h
index 29ef6d953f..b1231be5ae 100644
--- a/include/common/common.h
+++ b/include/common/common.h
@@ -38,6 +38,12 @@
 //  int16_t bytes;
 //} SSchema;
 
+typedef struct {
+  uint32_t  numOfTables;
+  SArray   *pGroupList;
+  SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
+} STableGroupInfo;
+
 typedef struct SColumnDataAgg {
   int16_t colId;
   int64_t sum;
@@ -57,17 +63,12 @@ typedef struct SDataBlockInfo {
 
 typedef struct SConstantItem {
   SColumnInfo info;
-  int32_t     startIndex;    // run-length-encoding to save the space for multiple rows
-  int32_t     endIndex;
+  int32_t     startRow;    // run-length-encoding to save the space for multiple rows
+  int32_t     endRow;
   SVariant    value;
 } SConstantItem;
 
-typedef struct {
-  uint32_t  numOfTables;
-  SArray   *pGroupList;
-  SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
-} STableGroupInfo;
-
+// info.numOfCols = taosArrayGetSize(pDataBlock) + taosArrayGetSize(pConstantList);
 typedef struct SSDataBlock {
   SColumnDataAgg *pBlockAgg;
   SArray         *pDataBlock;    // SArray<SColumnInfoData>
@@ -75,9 +76,12 @@ typedef struct SSDataBlock {
   SDataBlockInfo  info;
 } SSDataBlock;
 
+// pBlockAgg->numOfNull == info.rows, all data are null
+// pBlockAgg->numOfNull == 0, no data are null.
 typedef struct SColumnInfoData {
-  SColumnInfo info;     // TODO filter info needs to be removed
-  char       *pData;    // the corresponding block data in memory
+  SColumnInfo info;      // TODO filter info needs to be removed
+  char       *nullbitmap;//
+  char       *pData;     // the corresponding block data in memory
 } SColumnInfoData;
 
 static FORCE_INLINE int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock) {
diff --git a/include/common/tep.h b/include/common/tep.h
index c8f45e4c82..69dd385a37 100644
--- a/include/common/tep.h
+++ b/include/common/tep.h
@@ -1,6 +1,10 @@
 #ifndef TDENGINE_TEP_H
 #define TDENGINE_TEP_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "os.h"
 #include "tmsg.h"
 
@@ -9,10 +13,16 @@ typedef struct SCorEpSet {
   SEpSet  epSet;
 } SCorEpSet;
 
-int taosGetFqdnPortFromEp(const char *ep, char *fqdn, uint16_t *port);
+int  taosGetFqdnPortFromEp(const char *ep, SEp *pEp);
+void addEpIntoEpSet(SEpSet *pEpSet, const char *fqdn, uint16_t port);
+
 bool isEpsetEqual(const SEpSet *s1, const SEpSet *s2);
 
-void updateEpSet_s(SCorEpSet *pEpSet, SEpSet *pNewEpSet);
+void   updateEpSet_s(SCorEpSet *pEpSet, SEpSet *pNewEpSet);
 SEpSet getEpSet_s(SCorEpSet *pEpSet);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif  // TDENGINE_TEP_H
diff --git a/include/common/tglobal.h b/include/common/tglobal.h
index 1b96cbdc78..4bc8c9fb86 100644
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@@ -64,7 +64,6 @@ extern int8_t  tsKeepOriginalColumnName;
 extern int8_t  tsDeadLockKillQuery;
 
 // client
-extern int32_t tsMaxSQLStringLen;
 extern int32_t tsMaxWildCardsLen;
 extern int32_t tsMaxRegexStringLen;
 extern int8_t  tsTscEnableRecordSql;
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 21d5ec021f..154973e20f 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -76,6 +76,13 @@ typedef enum {
   HEARTBEAT_TYPE_MAX
 } EHbType;
 
+enum {
+  HEARTBEAT_KEY_DBINFO = 1,
+  HEARTBEAT_KEY_STBINFO,
+  HEARTBEAT_KEY_MQ_TMP,
+};
+
+
 typedef enum _mgmt_table {
   TSDB_MGMT_TABLE_START,
   TSDB_MGMT_TABLE_ACCT,
@@ -147,17 +154,17 @@ typedef struct {
 } SBuildTableMetaInput;
 
 typedef struct {
-  char    db[TSDB_TABLE_FNAME_LEN];
+  char    db[TSDB_DB_FNAME_LEN];
   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
-typedef struct {
+typedef struct SEp {
   char     fqdn[TSDB_FQDN_LEN];
   uint16_t port;
-} SEpAddr;
+} SEp;
 
 typedef struct {
   int32_t contLen;
@@ -266,8 +273,7 @@ typedef struct {
 typedef struct SEpSet {
   int8_t   inUse;
   int8_t   numOfEps;
-  uint16_t port[TSDB_MAX_REPLICA];
-  char     fqdn[TSDB_MAX_REPLICA][TSDB_FQDN_LEN];
+  SEp      eps[TSDB_MAX_REPLICA];
 } SEpSet;
 
 static FORCE_INLINE int taosEncodeSEpSet(void** buf, const SEpSet* pEp) {
@@ -275,8 +281,8 @@ static FORCE_INLINE int taosEncodeSEpSet(void** buf, const SEpSet* pEp) {
   tlen += taosEncodeFixedI8(buf, pEp->inUse);
   tlen += taosEncodeFixedI8(buf, pEp->numOfEps);
   for (int i = 0; i < TSDB_MAX_REPLICA; i++) {
-    tlen += taosEncodeFixedU16(buf, pEp->port[i]);
-    tlen += taosEncodeString(buf, pEp->fqdn[i]);
+    tlen += taosEncodeFixedU16(buf, pEp->eps[i].port);
+    tlen += taosEncodeString(buf, pEp->eps[i].fqdn);
   }
   return tlen;
 }
@@ -285,11 +291,12 @@ static FORCE_INLINE void* taosDecodeSEpSet(void* buf, SEpSet* pEp) {
   buf = taosDecodeFixedI8(buf, &pEp->inUse);
   buf = taosDecodeFixedI8(buf, &pEp->numOfEps);
   for (int i = 0; i < TSDB_MAX_REPLICA; i++) {
-    buf = taosDecodeFixedU16(buf, &pEp->port[i]);
-    buf = taosDecodeStringTo(buf, pEp->fqdn[i]);
+    buf = taosDecodeFixedU16(buf, &pEp->eps[i].port);
+    buf = taosDecodeStringTo(buf, pEp->eps[i].fqdn);
   }
   return buf;
 }
+
 typedef struct {
   int32_t acctId;
   int64_t clusterId;
@@ -297,6 +304,7 @@ typedef struct {
   int8_t  superUser;
   int8_t  align[3];
   SEpSet  epSet;
+  char    sVersion[128];
 } SConnectRsp;
 
 typedef struct {
@@ -507,21 +515,26 @@ typedef struct {
 } SAlterDbReq;
 
 typedef struct {
-  char   db[TSDB_TABLE_FNAME_LEN];
+  char   db[TSDB_DB_FNAME_LEN];
   int8_t ignoreNotExists;
 } SDropDbReq;
 
 typedef struct {
-  char    db[TSDB_TABLE_FNAME_LEN];
+  char     db[TSDB_DB_FNAME_LEN];
+  uint64_t uid;
+} SDropDbRsp;
+
+typedef struct {
+  char    db[TSDB_DB_FNAME_LEN];
   int32_t vgVersion;
 } SUseDbReq;
 
 typedef struct {
-  char db[TSDB_TABLE_FNAME_LEN];
+  char db[TSDB_DB_FNAME_LEN];
 } SSyncDbReq;
 
 typedef struct {
-  char db[TSDB_TABLE_FNAME_LEN];
+  char db[TSDB_DB_FNAME_LEN];
 } SCompactDbReq;
 
 typedef struct {
@@ -617,8 +630,7 @@ typedef struct {
   int32_t  id;
   int8_t   isMnode;
   int8_t   align;
-  uint16_t port;
-  char     fqdn[TSDB_FQDN_LEN];
+  SEp      ep;
 } SDnodeEp;
 
 typedef struct {
@@ -691,24 +703,17 @@ typedef struct {
   char    tableNames[];
 } SMultiTableInfoReq;
 
+// todo refactor
 typedef struct SVgroupInfo {
   int32_t    vgId;
   uint32_t   hashBegin;
   uint32_t   hashEnd;
-  int8_t     inUse;
-  int8_t     numOfEps;
-  SEpAddr    epAddr[TSDB_MAX_REPLICA];
+  SEpSet     epset;
 } SVgroupInfo;
 
 typedef struct {
-  int32_t    vgId;
-  int8_t     numOfEps;
-  SEpAddr    epAddr[TSDB_MAX_REPLICA];
-} SVgroupMsg;
-
-typedef struct {
-  int32_t    numOfVgroups;
-  SVgroupMsg vgroups[];
+  int32_t     numOfVgroups;
+  SVgroupInfo vgroups[];
 } SVgroupsInfo;
 
 typedef struct {
@@ -747,7 +752,7 @@ typedef struct {
 
 typedef struct {
   char        db[TSDB_DB_FNAME_LEN];
-  int64_t     uid;
+  uint64_t    uid;
   int32_t     vgVersion;
   int32_t     vgNum;
   int8_t      hashMethod;
@@ -871,13 +876,21 @@ typedef struct {
   char   desc[TSDB_STEP_DESC_LEN];
 } SStartupReq;
 
+/**
+ * The layout of the query message payload is as following:
+ * +--------------------+---------------------------------+
+ * |Sql statement       | Physical plan                   |
+ * |(denoted by sqlLen) |(In JSON, denoted by contentLen) |
+ * +--------------------+---------------------------------+
+ */
 typedef struct SSubQueryMsg {
   SMsgHead header;
   uint64_t sId;
   uint64_t queryId;
   uint64_t taskId;
   int8_t   taskType;
-  uint32_t contentLen;
+  uint32_t sqlLen;     // the query sql,
+  uint32_t phyLen;
   char     msg[];
 } SSubQueryMsg;
 
@@ -1342,9 +1355,8 @@ static FORCE_INLINE void* taosDecodeSMqHbBatchRsp(void* buf, SMqHbBatchRsp* pBat
 }
 
 typedef struct {
-  int32_t keyLen;
+  int32_t key;
   int32_t valueLen;
-  void*   key;
   void*   value;
 } SKv;
 
@@ -1366,8 +1378,7 @@ typedef struct {
 typedef struct {
   SClientHbKey connKey;
   int32_t      status;
-  int32_t      bodyLen;
-  void*        body;
+  SArray*      info;  // Array<Skv>
 } SClientHbRsp;
 
 typedef struct {
@@ -1386,9 +1397,26 @@ void* tDeserializeSClientHbReq(void* buf, SClientHbReq* pReq);
 int   tSerializeSClientHbRsp(void** buf, const SClientHbRsp* pRsp);
 void* tDeserializeSClientHbRsp(void* buf, SClientHbRsp* pRsp);
 
+
+static FORCE_INLINE void tFreeReqKvHash(SHashObj*      info) {
+  void *pIter = taosHashIterate(info, NULL);
+  while (pIter != NULL) {
+    SKv* kv = (SKv*)pIter;
+
+    tfree(kv->value);
+
+    pIter = taosHashIterate(info, pIter);
+  }
+}
+
+
 static FORCE_INLINE void  tFreeClientHbReq(void *pReq) {
   SClientHbReq* req = (SClientHbReq*)pReq;
-  if (req->info) taosHashCleanup(req->info);
+  if (req->info) {
+    tFreeReqKvHash(req->info);
+  
+    taosHashCleanup(req->info);
+  }
 }
 
 int   tSerializeSClientHbBatchReq(void** buf, const SClientHbBatchReq* pReq);
@@ -1404,22 +1432,39 @@ static FORCE_INLINE void tFreeClientHbBatchReq(void* pReq, bool deep) {
   free(pReq);
 }
 
+static FORCE_INLINE void tFreeClientKv(void *pKv) {
+  SKv *kv = (SKv *)pKv;
+  if (kv) {
+    tfree(kv->value);
+  }
+}
+
+static FORCE_INLINE void  tFreeClientHbRsp(void *pRsp) {
+  SClientHbRsp* rsp = (SClientHbRsp*)pRsp;
+  if (rsp->info) taosArrayDestroyEx(rsp->info, tFreeClientKv);
+}
+
+
+static FORCE_INLINE void tFreeClientHbBatchRsp(void* pRsp) {
+  SClientHbBatchRsp *rsp = (SClientHbBatchRsp*)pRsp;
+  taosArrayDestroyEx(rsp->rsps, tFreeClientHbRsp);
+}
+
+
 int   tSerializeSClientHbBatchRsp(void** buf, const SClientHbBatchRsp* pBatchRsp);
 void* tDeserializeSClientHbBatchRsp(void* buf, SClientHbBatchRsp* pBatchRsp);
 
 static FORCE_INLINE int taosEncodeSKv(void** buf, const SKv* pKv) {
   int tlen = 0;
-  tlen += taosEncodeFixedI32(buf, pKv->keyLen);
+  tlen += taosEncodeFixedI32(buf, pKv->key);
   tlen += taosEncodeFixedI32(buf, pKv->valueLen);
-  tlen += taosEncodeBinary(buf, pKv->key, pKv->keyLen);
   tlen += taosEncodeBinary(buf, pKv->value, pKv->valueLen);
   return tlen;
 }
 
 static FORCE_INLINE void* taosDecodeSKv(void* buf, SKv* pKv) {
-  buf = taosDecodeFixedI32(buf, &pKv->keyLen);
+  buf = taosDecodeFixedI32(buf, &pKv->key);
   buf = taosDecodeFixedI32(buf, &pKv->valueLen);
-  buf = taosDecodeBinary(buf, &pKv->key, pKv->keyLen);
   buf = taosDecodeBinary(buf, &pKv->value, pKv->valueLen);
   return buf;
 }
@@ -1541,7 +1586,8 @@ static FORCE_INLINE int32_t tEncodeSSubQueryMsg(void** buf, const SSubQueryMsg*
   tlen += taosEncodeFixedU64(buf, pMsg->sId);
   tlen += taosEncodeFixedU64(buf, pMsg->queryId);
   tlen += taosEncodeFixedU64(buf, pMsg->taskId);
-  tlen += taosEncodeFixedU32(buf, pMsg->contentLen);
+  tlen += taosEncodeFixedU32(buf, pMsg->sqlLen);
+  tlen += taosEncodeFixedU32(buf, pMsg->phyLen);
   //tlen += taosEncodeBinary(buf, pMsg->msg, pMsg->contentLen);
   return tlen;
 }
@@ -1550,7 +1596,8 @@ static FORCE_INLINE void* tDecodeSSubQueryMsg(void* buf, SSubQueryMsg* pMsg) {
   buf = taosDecodeFixedU64(buf, &pMsg->sId);
   buf = taosDecodeFixedU64(buf, &pMsg->queryId);
   buf = taosDecodeFixedU64(buf, &pMsg->taskId);
-  buf = taosDecodeFixedU32(buf, &pMsg->contentLen);
+  buf = taosDecodeFixedU32(buf, &pMsg->sqlLen);
+  buf = taosDecodeFixedU32(buf, &pMsg->phyLen);
   //buf = taosDecodeBinaryTo(buf, pMsg->msg, pMsg->contentLen);
   return buf;
 }
diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h
index 90926da120..cbc8c0e87c 100644
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@@ -207,6 +207,36 @@
 #define TK_INTO                           189
 #define TK_VALUES                         190
 
+#define NEW_TK_UNION                            1
+#define NEW_TK_ALL                              2
+#define NEW_TK_MINUS                            3
+#define NEW_TK_EXCEPT                           4
+#define NEW_TK_INTERSECT                        5
+#define NEW_TK_NK_PLUS                          6
+#define NEW_TK_NK_MINUS                         7
+#define NEW_TK_NK_STAR                          8
+#define NEW_TK_NK_SLASH                         9
+#define NEW_TK_SHOW                            10
+#define NEW_TK_DATABASES                       11
+#define NEW_TK_NK_ID                           12
+#define NEW_TK_NK_LP                           13
+#define NEW_TK_NK_RP                           14
+#define NEW_TK_NK_COMMA                        15
+#define NEW_TK_NK_LITERAL                      16
+#define NEW_TK_NK_DOT                          17
+#define NEW_TK_SELECT                          18
+#define NEW_TK_DISTINCT                        19
+#define NEW_TK_AS                              20
+#define NEW_TK_FROM                            21
+#define NEW_TK_WITH                            22
+#define NEW_TK_RECURSIVE                       23
+#define NEW_TK_ORDER                           24
+#define NEW_TK_BY                              25
+#define NEW_TK_ASC                             26
+#define NEW_TK_DESC                            27
+#define NEW_TK_NULLS                           28
+#define NEW_TK_FIRST                           29
+#define NEW_TK_LAST                            30
 
 #define TK_SPACE                          300
 #define TK_COMMENT                        301
diff --git a/include/libs/catalog/catalog.h b/include/libs/catalog/catalog.h
index 70cff7ed1a..0b465b7b4e 100644
--- a/include/libs/catalog/catalog.h
+++ b/include/libs/catalog/catalog.h
@@ -59,6 +59,7 @@ typedef struct SSTableMetaVersion {
 } SSTableMetaVersion;
 
 typedef struct SDbVgVersion {
+  char    dbName[TSDB_DB_FNAME_LEN];
   int64_t dbId;
   int32_t vgVersion;
 } SDbVgVersion;
@@ -98,6 +99,8 @@ int32_t catalogGetDBVgroup(struct SCatalog* pCatalog, void *pTransporter, const
 
 int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDBVgroupInfo* dbInfo);
 
+int32_t catalogRemoveDBVgroup(struct SCatalog* pCatalog, SDbVgVersion* dbInfo);
+
 /**
  * Get a table's meta data. 
  * @param pCatalog (input, got with catalogGetHandle)
diff --git a/include/libs/parser/parsenodes.h b/include/libs/parser/parsenodes.h
index 374ae02e4a..d245d04166 100644
--- a/include/libs/parser/parsenodes.h
+++ b/include/libs/parser/parsenodes.h
@@ -35,7 +35,7 @@ typedef struct SQueryNode {
   int16_t type;
 } SQueryNode;
 
-#define nodeType(nodeptr) (((const SQueryNode*)(nodeptr))->type)
+#define queryNodeType(nodeptr) (((const SQueryNode*)(nodeptr))->type)
 
 typedef struct SField {
   char     name[TSDB_COL_NAME_LEN];
diff --git a/include/libs/qcom/query.h b/include/libs/qcom/query.h
index 1925f0e3bd..c7ca2d9e1d 100644
--- a/include/libs/qcom/query.h
+++ b/include/libs/qcom/query.h
@@ -82,7 +82,7 @@ typedef struct STableMeta {
 
 typedef struct SDBVgroupInfo {
   SRWLatch  lock;
-  int64_t   dbId;
+  uint64_t  dbId;
   int32_t   vgVersion;  
   int8_t    hashMethod;
   SHashObj *vgInfo;  //key:vgId, value:SVgroupInfo
@@ -94,7 +94,7 @@ typedef struct SUseDbOutput {
 } SUseDbOutput;
 
 enum {
-  META_TYPE_NON_TABLE = 1,
+  META_TYPE_NULL_TABLE = 1,
   META_TYPE_CTABLE,
   META_TYPE_TABLE,
   META_TYPE_BOTH_TABLE
@@ -128,20 +128,9 @@ typedef struct SMsgSendInfo {
 
 typedef struct SQueryNodeAddr {
   int32_t nodeId;  // vgId or qnodeId
-  int8_t  inUse;
-  int8_t  numOfEps;
-  SEpAddr epAddr[TSDB_MAX_REPLICA];
+  SEpSet  epset;
 } SQueryNodeAddr;
 
-static FORCE_INLINE void tConvertQueryAddrToEpSet(SEpSet* pEpSet, const SQueryNodeAddr* pAddr) {
-  pEpSet->inUse = pAddr->inUse;
-  pEpSet->numOfEps = pAddr->numOfEps;
-  for (int j = 0; j < TSDB_MAX_REPLICA; j++) {
-    pEpSet->port[j] = pAddr->epAddr[j].port;
-    memcpy(pEpSet->fqdn[j], pAddr->epAddr[j].fqdn, TSDB_FQDN_LEN);
-  }
-}
-
 int32_t initTaskQueue();
 int32_t cleanupTaskQueue();
 
@@ -174,7 +163,7 @@ extern int32_t (*queryBuildMsg[TDMT_MAX])(void* input, char **msg, int32_t msgSi
 extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char *msg, int32_t msgSize);
 
 
-#define SET_META_TYPE_NONE(t) (t) = META_TYPE_NON_TABLE
+#define SET_META_TYPE_NULL(t) (t) = META_TYPE_NULL_TABLE
 #define SET_META_TYPE_CTABLE(t) (t) = META_TYPE_CTABLE
 #define SET_META_TYPE_TABLE(t) (t) = META_TYPE_TABLE
 #define SET_META_TYPE_BOTH_TABLE(t) (t) = META_TYPE_BOTH_TABLE
diff --git a/include/libs/scheduler/scheduler.h b/include/libs/scheduler/scheduler.h
index 5a0da46490..e856adaf31 100644
--- a/include/libs/scheduler/scheduler.h
+++ b/include/libs/scheduler/scheduler.h
@@ -72,7 +72,7 @@ int32_t schedulerInit(SSchedulerCfg *cfg);
  * @param nodeList  Qnode/Vnode address list, element is SQueryNodeAddr
  * @return
  */
-int32_t schedulerExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, struct SSchJob** pJob, SQueryResult *pRes);
+int32_t schedulerExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, struct SSchJob** pJob, const char* sql, SQueryResult *pRes);
 
 /**
  * Process the query job, generated according to the query physical plan.
@@ -80,7 +80,7 @@ int32_t schedulerExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, str
  * @param pNodeList  Qnode/Vnode address list, element is SQueryNodeAddr
  * @return
  */
-int32_t schedulerAsyncExecJob(void *transport, SArray *pNodeList, SQueryDag* pDag, struct SSchJob** pJob);
+int32_t schedulerAsyncExecJob(void *transport, SArray *pNodeList, SQueryDag* pDag, const char* sql, struct SSchJob** pJob);
 
 /**
  * Fetch query result from the remote query executor
diff --git a/include/libs/transport/transport.h b/include/libs/transport/transport.h
index a05a76931a..f5ffc125ea 100644
--- a/include/libs/transport/transport.h
+++ b/include/libs/transport/transport.h
@@ -20,21 +20,6 @@
 extern "C" {
 #endif
 
-//typedef struct SEpAddr {
-//  char       fqdn[TSDB_FQDN_LEN];
-//  uint16_t   port;
-//} SEpAddr;
-//
-//typedef struct SVgroup {
-//  int32_t    vgId;
-//  int8_t     numOfEps;
-//  SEpAddr    epAddr[TSDB_MAX_REPLICA];
-//} SVgroup;
-//
-//typedef struct SVgroupsInfo {
-//  int32_t    numOfVgroups;
-//  SVgroup    vgroups[];
-//} SVgroupsInfo;
 
 #ifdef __cplusplus
 }
diff --git a/include/nodes/nodes.h b/include/nodes/nodes.h
index e6b41adf14..e297059bc8 100644
--- a/include/nodes/nodes.h
+++ b/include/nodes/nodes.h
@@ -20,7 +20,6 @@
 extern "C" {
 #endif
 
-#include "tarray.h"
 #include "tdef.h"
 
 typedef enum ENodeType {
@@ -35,12 +34,14 @@ typedef enum ENodeType {
   QUERY_NODE_JOIN_TABLE,
   QUERY_NODE_GROUPING_SET,
   QUERY_NODE_ORDER_BY_EXPR,
+  QUERY_NODE_LIMIT,
   QUERY_NODE_STATE_WINDOW,
   QUERY_NODE_SESSION_WINDOW,
   QUERY_NODE_INTERVAL_WINDOW,
 
   QUERY_NODE_SET_OPERATOR,
-  QUERY_NODE_SELECT_STMT
+  QUERY_NODE_SELECT_STMT,
+  QUERY_NODE_SHOW_STMT
 } ENodeType;
 
 /**
@@ -52,6 +53,27 @@ typedef struct SNode {
 } SNode;
 
 #define nodeType(nodeptr) (((const SNode*)(nodeptr))->type)
+#define setNodeType(nodeptr, type) (((SNode*)(nodeptr))->type = (type))
+
+typedef struct SListCell {
+  SNode* pNode;
+  struct SListCell* pNext;
+} SListCell;
+
+typedef struct SNodeList {
+  int16_t length;
+  SListCell* pHeader;
+} SNodeList;
+
+#define LIST_LENGTH(l) (NULL != (l) ? (l)->length : 0)
+
+#define FOREACH(node, list)	\
+  for (SListCell* cell = (NULL != (list) ? (list)->pHeader : NULL); (NULL != cell ? (node = cell->pNode, true) : (node = NULL, false)); cell = cell->pNext)
+
+#define FORBOTH(node1, list1, node2, list2) \
+  for (SListCell* cell1 = (NULL != (list1) ? (list1)->pHeader : NULL), *cell2 = (NULL != (list2) ? (list2)->pHeader : NULL); \
+    (NULL == cell1 ? (node1 = NULL, false) : (node1 = cell1->pNode, true)), (NULL == cell2 ? (node2 = NULL, false) : (node2 = cell2->pNode, true)), (node1 != NULL && node2 != NULL); \
+    cell1 = cell1->pNext, cell2 = cell2->pNext)
 
 typedef struct SDataType {
   uint8_t type;
@@ -128,7 +150,7 @@ typedef enum ELogicConditionType {
 typedef struct SLogicConditionNode {
   ENodeType type; // QUERY_NODE_LOGIC_CONDITION
   ELogicConditionType condType;
-  SArray* pParameterList;
+  SNodeList* pParameterList;
 } SLogicConditionNode;
 
 typedef struct SIsNullCondNode {
@@ -141,7 +163,7 @@ typedef struct SFunctionNode {
   SExprNode type; // QUERY_NODE_FUNCTION
   char functionName[TSDB_FUNC_NAME_LEN];
   int32_t funcId;
-  SArray* pParameterList; // SNode
+  SNodeList* pParameterList; // SNode
 } SFunctionNode;
 
 typedef struct STableNode {
@@ -151,12 +173,12 @@ typedef struct STableNode {
 } STableNode;
 
 typedef struct SRealTableNode {
-  STableNode type; // QUERY_NODE_REAL_TABLE
+  STableNode table; // QUERY_NODE_REAL_TABLE
   char dbName[TSDB_DB_NAME_LEN];
 } SRealTableNode;
 
 typedef struct STempTableNode {
-  STableNode type; // QUERY_NODE_TEMP_TABLE
+  STableNode table; // QUERY_NODE_TEMP_TABLE
   SNode* pSubquery;
 } STempTableNode;
 
@@ -165,7 +187,7 @@ typedef enum EJoinType {
 } EJoinType;
 
 typedef struct SJoinTableNode {
-  STableNode type; // QUERY_NODE_JOIN_TABLE
+  STableNode table; // QUERY_NODE_JOIN_TABLE
   EJoinType joinType;
   SNode* pLeft;
   SNode* pRight;
@@ -179,7 +201,7 @@ typedef enum EGroupingSetType {
 typedef struct SGroupingSetNode {
   ENodeType type; // QUERY_NODE_GROUPING_SET
   EGroupingSetType groupingSetType;
-  SArray* pParameterList; 
+  SNodeList* pParameterList; 
 } SGroupingSetNode;
 
 typedef enum EOrder {
@@ -188,7 +210,8 @@ typedef enum EOrder {
 } EOrder;
 
 typedef enum ENullOrder {
-  NULL_ORDER_FIRST = 1,
+  NULL_ORDER_DEFAULT = 1,
+  NULL_ORDER_FIRST,
   NULL_ORDER_LAST
 } ENullOrder;
 
@@ -199,10 +222,11 @@ typedef struct SOrderByExprNode {
   ENullOrder nullOrder;
 } SOrderByExprNode;
 
-typedef struct SLimitInfo {
+typedef struct SLimitNode {
+  ENodeType type; // QUERY_NODE_LIMIT
   uint64_t limit;
   uint64_t offset;
-} SLimitInfo;
+} SLimitNode;
 
 typedef struct SStateWindowNode {
   ENodeType type; // QUERY_NODE_STATE_WINDOW
@@ -225,15 +249,16 @@ typedef struct SIntervalWindowNode {
 typedef struct SSelectStmt {
   ENodeType type; // QUERY_NODE_SELECT_STMT
   bool isDistinct;
-  SArray* pProjectionList; // SNode
+  bool isStar;
+  SNodeList* pProjectionList; // SNode
   SNode* pFromTable;
   SNode* pWhereCond;
-  SArray* pPartitionByList; // SNode
+  SNodeList* pPartitionByList; // SNode
   SNode* pWindowClause;
-  SArray* pGroupByList; // SGroupingSetNode
-  SArray* pOrderByList; // SOrderByExprNode
-  SLimitInfo limit;
-  SLimitInfo slimit;
+  SNodeList* pGroupByList; // SGroupingSetNode
+  SNodeList* pOrderByList; // SOrderByExprNode
+  SLimitNode limit;
+  SLimitNode slimit;
 } SSelectStmt;
 
 typedef enum ESetOperatorType {
@@ -249,20 +274,24 @@ typedef struct SSetOperator {
 
 typedef bool (*FQueryNodeWalker)(SNode* pNode, void* pContext);
 
-bool nodeArrayWalker(SArray* pArray, FQueryNodeWalker walker, void* pContext);
-bool nodeTreeWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext);
+bool nodesWalkNode(SNode* pNode, FQueryNodeWalker walker, void* pContext);
+bool nodesWalkNodeList(SNodeList* pNodeList, FQueryNodeWalker walker, void* pContext);
 
-bool stmtWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext);
+bool nodesWalkStmt(SNode* pNode, FQueryNodeWalker walker, void* pContext);
 
-bool nodeEqual(const SNode* a, const SNode* b);
+bool nodesEqualNode(const SNode* a, const SNode* b);
 
-void cloneNode(const SNode* pNode);
+void nodesCloneNode(const SNode* pNode);
 
-int32_t nodeToString(const SNode* pNode, char** pStr, int32_t* pLen);
-int32_t stringToNode(const char* pStr, SNode** pNode);
+int32_t nodesNodeToString(const SNode* pNode, char** pStr, int32_t* pLen);
+int32_t nodesStringToNode(const char* pStr, SNode** pNode);
 
-bool isTimeorderQuery(const SNode* pQuery);
-bool isTimelineQuery(const SNode* pQuery);
+bool nodesIsTimeorderQuery(const SNode* pQuery);
+bool nodesIsTimelineQuery(const SNode* pQuery);
+
+SNode* nodesMakeNode(ENodeType type);
+void nodesDestroyNode(SNode* pNode);
+void nodesDestroyNodeList(SNodeList* pList);
 
 #ifdef __cplusplus
 }
diff --git a/include/nodes/nodesShowStmts.h b/include/nodes/nodesShowStmts.h
new file mode 100644
index 0000000000..312fbbc4f4
--- /dev/null
+++ b/include/nodes/nodesShowStmts.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_NODES_SHOW_STMTS_H_
+#define _TD_NODES_SHOW_STMTS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "nodes.h"
+
+typedef enum EShowStmtType {
+  SHOW_TYPE_DATABASE = 1
+} EShowStmtType;
+
+typedef struct SShowStmt {
+  ENodeType type; // QUERY_NODE_SHOW_STMT
+  EShowStmtType showType;
+} SShowStmt;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_NODES_SHOW_STMTS_H_*/
diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h
index c61f3da6bd..77249e3f0b 100644
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@@ -35,9 +35,13 @@ extern "C" {
 
 typedef struct SAppInstInfo SAppInstInfo;
 
-typedef int32_t (*FHbRspHandle)(SClientHbRsp* pReq);
+typedef struct SHbConnInfo {
+  void         *param;
+  SClientHbReq *req;
+} SHbConnInfo;
 
 typedef struct SAppHbMgr {
+  char   *key;
   // statistics
   int32_t reportCnt;
   int32_t connKeyCnt;
@@ -49,9 +53,15 @@ typedef struct SAppHbMgr {
   SAppInstInfo* pAppInstInfo;
   // info
   SHashObj* activeInfo;    // hash<SClientHbKey, SClientHbReq>
-  SHashObj* getInfoFuncs;  // hash<SClientHbKey, FGetConnInfo>
+  SHashObj* connInfo;      // hash<SClientHbKey, SHbConnInfo>
 } SAppHbMgr;
 
+
+typedef int32_t (*FHbRspHandle)(struct SAppHbMgr *pAppHbMgr, SClientHbRsp* pRsp);
+
+typedef int32_t (*FHbReqHandle)(SClientHbKey *connKey, void* param, SClientHbReq *req);
+
+
 typedef struct SClientHbMgr {
   int8_t inited;
   // ctl
@@ -59,12 +69,10 @@ typedef struct SClientHbMgr {
   pthread_t       thread;
   pthread_mutex_t lock;       // used when app init and cleanup
   SArray*         appHbMgrs;  // SArray<SAppHbMgr*> one for each cluster
-  FHbRspHandle    handle[HEARTBEAT_TYPE_MAX];
+  FHbReqHandle    reqHandle[HEARTBEAT_TYPE_MAX];
+  FHbRspHandle    rspHandle[HEARTBEAT_TYPE_MAX];
 } SClientHbMgr;
 
-// TODO: embed param into function
-// return type: SArray<Skv>
-typedef SArray* (*FGetConnInfo)(SClientHbKey connKey, void* param);
 
 typedef struct SQueryExecMetric {
   int64_t      start;    // start timestamp
@@ -114,6 +122,7 @@ typedef struct STscObj {
   char             user[TSDB_USER_LEN];
   char             pass[TSDB_PASSWORD_LEN];
   char             db[TSDB_DB_FNAME_LEN];
+  char             ver[128];
   int32_t          acctId;
   uint32_t         connId;
   int32_t          connType;
@@ -217,11 +226,11 @@ void hbMgrCleanUp();
 int  hbHandleRsp(SClientHbBatchRsp* hbRsp);
 
 // cluster level
-SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo);
+SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo, char *key);
 void appHbMgrCleanup(SAppHbMgr* pAppHbMgr);
 
 // conn level
-int  hbRegisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, FGetConnInfo func);
+int  hbRegisterConn(SAppHbMgr* pAppHbMgr, int32_t connId, int64_t clusterId, int32_t hbType);
 void hbDeregisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey);
 
 int hbAddConnInfo(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, void* key, void* value, int32_t keyLen, int32_t valueLen);
diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 28faa76785..cb73701bfa 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -127,6 +127,8 @@ void* openTransporter(const char *user, const char *auth, int32_t numOfThread) {
 void destroyTscObj(void *pObj) {
   STscObj *pTscObj = pObj;
 
+  SClientHbKey connKey = {.connId = pTscObj->connId, .hbType = pTscObj->connType};
+  hbDeregisterConn(pTscObj->pAppInfo->pAppHbMgr, connKey);
   atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
   tscDebug("connObj 0x%"PRIx64" destroyed, totalConn:%"PRId64, pTscObj->id, pTscObj->pAppInfo->numOfConns);
   pthread_mutex_destroy(&pTscObj->mutex);
@@ -517,4 +519,4 @@ setConfRet taos_set_config(const char *config){
   pthread_mutex_unlock(&setConfMutex);
   return ret;
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c
index 0f4ff6f725..f6c473333c 100644
--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@@ -15,33 +15,237 @@
 
 #include "clientInt.h"
 #include "trpc.h"
+#include "catalog.h"
+#include "clientLog.h"
 
 static SClientHbMgr clientHbMgr = {0};
 
 static int32_t hbCreateThread();
 static void    hbStopThread();
 
-static int32_t hbMqHbRspHandle(SClientHbRsp* pRsp) {
+static int32_t hbMqHbRspHandle(struct SAppHbMgr *pAppHbMgr, SClientHbRsp* pRsp) {
   return 0;
 }
 
-static int32_t hbMqAsyncCallBack(void* param, const SDataBuf* pMsg, int32_t code) {
-  if (code != 0) {
-    return -1;
+static int32_t hbProcessDBInfoRsp(void *value, int32_t valueLen, struct SCatalog *pCatalog) {
+  int32_t msgLen = 0;
+  int32_t code = 0;
+  
+  while (msgLen < valueLen) {
+    SUseDbRsp *rsp = (SUseDbRsp *)((char *)value + msgLen);
+
+    rsp->vgVersion = ntohl(rsp->vgVersion);
+    rsp->vgNum = ntohl(rsp->vgNum);
+    rsp->uid = be64toh(rsp->uid);
+
+    tscDebug("hb db rsp, db:%s, vgVersion:%d, uid:%"PRIx64, rsp->db, rsp->vgVersion, rsp->uid);
+    
+    if (rsp->vgVersion < 0) {
+      SDbVgVersion dbInfo;
+      strcpy(dbInfo.dbName, rsp->db);
+      dbInfo.dbId = rsp->uid;
+      dbInfo.vgVersion = rsp->vgVersion;
+      
+      code = catalogRemoveDBVgroup(pCatalog, &dbInfo);
+    } else {
+      SDBVgroupInfo vgInfo = {0};
+      vgInfo.dbId = rsp->uid;
+      vgInfo.vgVersion = rsp->vgVersion;
+      vgInfo.hashMethod = rsp->hashMethod;
+      vgInfo.vgInfo = taosHashInit(rsp->vgNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK);
+      if (NULL == vgInfo.vgInfo) {
+        tscError("hash init[%d] failed", rsp->vgNum);
+        return TSDB_CODE_TSC_OUT_OF_MEMORY;
+      }
+
+      for (int32_t i = 0; i < rsp->vgNum; ++i) {
+        rsp->vgroupInfo[i].vgId = ntohl(rsp->vgroupInfo[i].vgId);
+        rsp->vgroupInfo[i].hashBegin = ntohl(rsp->vgroupInfo[i].hashBegin);
+        rsp->vgroupInfo[i].hashEnd = ntohl(rsp->vgroupInfo[i].hashEnd);
+
+        for (int32_t n = 0; n < rsp->vgroupInfo[i].epset.numOfEps; ++n) {
+          rsp->vgroupInfo[i].epset.eps[n].port = ntohs(rsp->vgroupInfo[i].epset.eps[n].port);
+        }
+
+        if (0 != taosHashPut(vgInfo.vgInfo, &rsp->vgroupInfo[i].vgId, sizeof(rsp->vgroupInfo[i].vgId), &rsp->vgroupInfo[i], sizeof(rsp->vgroupInfo[i]))) {
+          tscError("hash push failed, errno:%d", errno);
+          taosHashCleanup(vgInfo.vgInfo);
+          return TSDB_CODE_TSC_OUT_OF_MEMORY;
+        }
+      }  
+      
+      code = catalogUpdateDBVgroup(pCatalog, rsp->db, &vgInfo);
+      if (code) {
+        taosHashCleanup(vgInfo.vgInfo);
+      }
+    }
+
+    if (code) {
+      return code;
+    }
+
+    msgLen += sizeof(SUseDbRsp) + rsp->vgNum * sizeof(SVgroupInfo);
   }
-  SClientHbRsp* pRsp = (SClientHbRsp*) pMsg->pData;
-  return hbMqHbRspHandle(pRsp);
+
+  return TSDB_CODE_SUCCESS;
 }
 
-void hbMgrInitMqHbRspHandle() {
-  clientHbMgr.handle[HEARTBEAT_TYPE_MQ] = hbMqHbRspHandle;
+static int32_t hbQueryHbRspHandle(struct SAppHbMgr *pAppHbMgr, SClientHbRsp* pRsp) {
+  SHbConnInfo * info = taosHashGet(pAppHbMgr->connInfo, &pRsp->connKey, sizeof(SClientHbKey));
+  if (NULL == info) {
+    tscWarn("fail to get connInfo, may be dropped, connId:%d, type:%d", pRsp->connKey.connId, pRsp->connKey.hbType);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  int32_t kvNum = pRsp->info ? taosArrayGetSize(pRsp->info) : 0;
+
+  tscDebug("hb got %d rsp kv", kvNum);
+  
+  for (int32_t i = 0; i < kvNum; ++i) {
+    SKv *kv = taosArrayGet(pRsp->info, i);
+    switch (kv->key) {
+      case HEARTBEAT_KEY_DBINFO: {
+        if (kv->valueLen <= 0 || NULL == kv->value) {
+          tscError("invalid hb db info, len:%d, value:%p", kv->valueLen, kv->value);
+          break;
+        }
+
+        int64_t *clusterId = (int64_t *)info->param;
+        struct SCatalog *pCatalog = NULL;
+        
+        int32_t code = catalogGetHandle(*clusterId, &pCatalog);
+        if (code != TSDB_CODE_SUCCESS) {
+          tscWarn("catalogGetHandle failed, clusterId:%"PRIx64", error:%s", *clusterId, tstrerror(code));
+          break;
+        }
+
+        hbProcessDBInfoRsp(kv->value, kv->valueLen, pCatalog);
+        break;
+      }
+      case HEARTBEAT_KEY_STBINFO:
+
+        break;
+      default:
+        tscError("invalid hb key type:%d", kv->key);
+        break;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t hbMqAsyncCallBack(void* param, const SDataBuf* pMsg, int32_t code) {
+  static int32_t emptyRspNum = 0;
+  if (code != 0) {
+    tfree(param);
+    return -1;
+  }
+  char *key = (char *)param;
+  SClientHbBatchRsp pRsp = {0};
+  tDeserializeSClientHbBatchRsp(pMsg->pData, &pRsp);
+  
+  int32_t rspNum = taosArrayGetSize(pRsp.rsps);
+
+  SAppInstInfo** pInst = taosHashGet(appInfo.pInstMap, key, strlen(key));
+  if (pInst == NULL || NULL == *pInst) {
+    tscError("cluster not exist, key:%s", key);    
+    tfree(param);
+    tFreeClientHbBatchRsp(&pRsp);
+    return -1;
+  }
+
+  tfree(param);
+
+  if (rspNum) {
+    tscDebug("hb got %d rsp, %d empty rsp prior", rspNum, atomic_val_compare_exchange_32(&emptyRspNum, emptyRspNum, 0));
+  } else {
+    atomic_add_fetch_32(&emptyRspNum, 1);
+  }
+
+  for (int32_t i = 0; i < rspNum; ++i) {
+    SClientHbRsp* rsp = taosArrayGet(pRsp.rsps, i);
+    code = (*clientHbMgr.rspHandle[rsp->connKey.hbType])((*pInst)->pAppHbMgr, rsp);
+    if (code) {
+      break;
+    }
+  }
+
+  tFreeClientHbBatchRsp(&pRsp);
+  
+  return code;
+}
+
+int32_t hbGetExpiredDBInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SClientHbReq *req) {
+  SDbVgVersion *dbs = NULL;
+  uint32_t dbNum = 0;
+  int32_t code = 0;
+
+  code = catalogGetExpiredDBs(pCatalog, &dbs, &dbNum);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
+
+  if (dbNum <= 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  for (int32_t i = 0; i < dbNum; ++i) {
+    SDbVgVersion *db = &dbs[i];
+    db->dbId = htobe64(db->dbId);
+    db->vgVersion = htonl(db->vgVersion);
+  }
+
+  SKv kv = {.key = HEARTBEAT_KEY_DBINFO, .valueLen = sizeof(SDbVgVersion) * dbNum, .value = dbs};
+
+  tscDebug("hb got %d expired db, valueLen:%d", dbNum, kv.valueLen);
+
+  taosHashPut(req->info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t hbQueryHbReqHandle(SClientHbKey *connKey, void* param, SClientHbReq *req) {
+  int64_t *clusterId = (int64_t *)param;
+  struct SCatalog *pCatalog = NULL;
+
+  int32_t code = catalogGetHandle(*clusterId, &pCatalog);
+  if (code != TSDB_CODE_SUCCESS) {
+    tscWarn("catalogGetHandle failed, clusterId:%"PRIx64", error:%s", *clusterId, tstrerror(code));
+    return code;
+  }
+  
+  code = hbGetExpiredDBInfo(connKey, pCatalog, req);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
+
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t hbMqHbReqHandle(SClientHbKey *connKey, void* param, SClientHbReq *req) {
+
+}
+
+void hbMgrInitMqHbHandle() {
+  clientHbMgr.reqHandle[HEARTBEAT_TYPE_QUERY] = hbQueryHbReqHandle;
+  clientHbMgr.reqHandle[HEARTBEAT_TYPE_MQ] = hbMqHbReqHandle;
+  clientHbMgr.rspHandle[HEARTBEAT_TYPE_QUERY] = hbQueryHbRspHandle;
+  clientHbMgr.rspHandle[HEARTBEAT_TYPE_MQ] = hbMqHbRspHandle;
 }
 
 static FORCE_INLINE void hbMgrInitHandle() {
   // init all handle
-  hbMgrInitMqHbRspHandle();
+  hbMgrInitMqHbHandle();
 }
 
+void hbFreeReq(void *req) {
+  SClientHbReq *pReq = (SClientHbReq *)req;
+  tFreeReqKvHash(pReq->info);
+}
+
+
+
 SClientHbBatchReq* hbGatherAllInfo(SAppHbMgr *pAppHbMgr) {
   SClientHbBatchReq* pBatchReq = malloc(sizeof(SClientHbBatchReq));
   if (pBatchReq == NULL) {
@@ -51,38 +255,58 @@ SClientHbBatchReq* hbGatherAllInfo(SAppHbMgr *pAppHbMgr) {
   int32_t connKeyCnt = atomic_load_32(&pAppHbMgr->connKeyCnt);
   pBatchReq->reqs = taosArrayInit(connKeyCnt, sizeof(SClientHbReq));
 
+  int32_t code = 0;
   void *pIter = taosHashIterate(pAppHbMgr->activeInfo, NULL);
   while (pIter != NULL) {
     SClientHbReq* pOneReq = pIter;
+
+    SHbConnInfo * info = taosHashGet(pAppHbMgr->connInfo, &pOneReq->connKey, sizeof(SClientHbKey));
+    if (info) {
+      code = (*clientHbMgr.reqHandle[pOneReq->connKey.hbType])(&pOneReq->connKey, info->param, pOneReq);
+      if (code) {
+        taosHashCancelIterate(pAppHbMgr->activeInfo, pIter);
+        break;
+      }
+    }
+
     taosArrayPush(pBatchReq->reqs, pOneReq);
-    taosHashClear(pOneReq->info);
 
     pIter = taosHashIterate(pAppHbMgr->activeInfo, pIter);
   }
 
-#if 0
-  pIter = taosHashIterate(pAppHbMgr->getInfoFuncs, NULL);
-  while (pIter != NULL) {
-    FGetConnInfo getConnInfoFp = (FGetConnInfo)pIter;
-    SClientHbKey connKey;
-    taosHashCopyKey(pIter, &connKey);
-    SArray* pArray = getConnInfoFp(connKey, NULL);
-
-    pIter = taosHashIterate(pAppHbMgr->getInfoFuncs, pIter);
+  if (code) {
+    taosArrayDestroyEx(pBatchReq->reqs, hbFreeReq);
+    tfree(pBatchReq);
   }
-#endif
 
   return pBatchReq;
 }
 
+
+void hbClearReqInfo(SAppHbMgr *pAppHbMgr) {
+  void *pIter = taosHashIterate(pAppHbMgr->activeInfo, NULL);
+  while (pIter != NULL) {
+    SClientHbReq* pOneReq = pIter;
+
+    tFreeReqKvHash(pOneReq->info);
+    taosHashClear(pOneReq->info);
+
+    pIter = taosHashIterate(pAppHbMgr->activeInfo, pIter);
+  }
+}
+
+
+
 static void* hbThreadFunc(void* param) {
   setThreadName("hb");
   while (1) {
-    int8_t threadStop = atomic_load_8(&clientHbMgr.threadStop);
-    if(threadStop) {
+    int8_t threadStop = atomic_val_compare_exchange_8(&clientHbMgr.threadStop, 1, 2);
+    if(1 == threadStop) {
       break;
     }
 
+    pthread_mutex_lock(&clientHbMgr.lock);
+
     int sz = taosArrayGetSize(clientHbMgr.appHbMgrs);
     for(int i = 0; i < sz; i++) {
       SAppHbMgr* pAppHbMgr = taosArrayGetP(clientHbMgr.appHbMgrs, i);
@@ -98,7 +322,9 @@ static void* hbThreadFunc(void* param) {
       int tlen = tSerializeSClientHbBatchReq(NULL, pReq);
       void *buf = malloc(tlen);
       if (buf == NULL) {
-        //TODO: error handling
+        terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        tFreeClientHbBatchReq(pReq, false);
+        hbClearReqInfo(pAppHbMgr);
         break;
       }
       void *abuf = buf;
@@ -107,6 +333,7 @@ static void* hbThreadFunc(void* param) {
       if (pInfo == NULL) {
         terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
         tFreeClientHbBatchReq(pReq, false);
+        hbClearReqInfo(pAppHbMgr);
         free(buf);
         break;
       }
@@ -114,7 +341,7 @@ static void* hbThreadFunc(void* param) {
       pInfo->msgInfo.pData = buf;
       pInfo->msgInfo.len = tlen;
       pInfo->msgType = TDMT_MND_HEARTBEAT;
-      pInfo->param = NULL;
+      pInfo->param = strdup(pAppHbMgr->key);
       pInfo->requestId = generateRequestId();
       pInfo->requestObjRefId = 0;
 
@@ -122,10 +349,14 @@ static void* hbThreadFunc(void* param) {
       int64_t transporterId = 0;
       SEpSet epSet = getEpSet_s(&pAppInstInfo->mgmtEp);
       asyncSendMsgToServer(pAppInstInfo->pTransporter, &epSet, &transporterId, pInfo);
-      tFreeClientHbBatchReq(pReq, false);
+      tFreeClientHbBatchReq(pReq, false);      
+      hbClearReqInfo(pAppHbMgr);
 
       atomic_add_fetch_32(&pAppHbMgr->reportCnt, 1);
     }
+
+    pthread_mutex_unlock(&clientHbMgr.lock);
+    
     taosMsleep(HEARTBEAT_INTERVAL);
   }
   return NULL;
@@ -145,10 +376,19 @@ static int32_t hbCreateThread() {
 }
 
 static void hbStopThread() {
-  atomic_store_8(&clientHbMgr.threadStop, 1);
+  if (atomic_val_compare_exchange_8(&clientHbMgr.threadStop, 0, 1)) {
+    tscDebug("hb thread already stopped");
+    return;
+  }
+  
+  while (2 != atomic_load_8(&clientHbMgr.threadStop)) {
+    usleep(10);
+  }
+
+  tscDebug("hb thread stopped");  
 }
 
-SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo) {
+SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo, char *key) {
   hbMgrInit();
   SAppHbMgr* pAppHbMgr = malloc(sizeof(SAppHbMgr)); 
   if (pAppHbMgr == NULL) {
@@ -160,6 +400,7 @@ SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo) {
   pAppHbMgr->connKeyCnt = 0;
   pAppHbMgr->reportCnt = 0;
   pAppHbMgr->reportBytes = 0;
+  pAppHbMgr->key = strdup(key);
 
   // init app info
   pAppHbMgr->pAppInstInfo = pAppInstInfo;
@@ -174,19 +415,26 @@ SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo) {
   }
   pAppHbMgr->activeInfo->freeFp = tFreeClientHbReq;
   // init getInfoFunc
-  pAppHbMgr->getInfoFuncs = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);
+  pAppHbMgr->connInfo = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);
 
-  if (pAppHbMgr->getInfoFuncs == NULL) {
+  if (pAppHbMgr->connInfo == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     free(pAppHbMgr);
     return NULL;
   }
 
+  pthread_mutex_lock(&clientHbMgr.lock);
   taosArrayPush(clientHbMgr.appHbMgrs, &pAppHbMgr);
+  pthread_mutex_unlock(&clientHbMgr.lock);
+  
   return pAppHbMgr;
 }
 
 void appHbMgrCleanup(SAppHbMgr* pAppHbMgr) {
+  if (NULL == pAppHbMgr) {
+    return;
+  }
+  
   pthread_mutex_lock(&clientHbMgr.lock);
 
   int sz = taosArrayGetSize(clientHbMgr.appHbMgrs);
@@ -194,7 +442,9 @@ void appHbMgrCleanup(SAppHbMgr* pAppHbMgr) {
     SAppHbMgr* pTarget = taosArrayGetP(clientHbMgr.appHbMgrs, i);
     if (pAppHbMgr == pTarget) {
       taosHashCleanup(pTarget->activeInfo);
-      taosHashCleanup(pTarget->getInfoFuncs);
+      pTarget->activeInfo = NULL;
+      taosHashCleanup(pTarget->connInfo);
+      pTarget->connInfo = NULL;
     }
   }
 
@@ -219,31 +469,20 @@ int hbMgrInit() {
 }
 
 void hbMgrCleanUp() {
+  hbStopThread();
+  
   // destroy all appHbMgr
   int8_t old = atomic_val_compare_exchange_8(&clientHbMgr.inited, 1, 0);
   if (old == 0) return;
 
-  taosArrayDestroy(clientHbMgr.appHbMgrs);
+  pthread_mutex_lock(&clientHbMgr.lock);
+  taosArrayDestroy(clientHbMgr.appHbMgrs);  
+  pthread_mutex_unlock(&clientHbMgr.lock);
+  
+  clientHbMgr.appHbMgrs = NULL;
 }
 
-int hbHandleRsp(SClientHbBatchRsp* hbRsp) {
-  int64_t reqId = hbRsp->reqId;
-  int64_t rspId = hbRsp->rspId;
-
-  SArray* rsps = hbRsp->rsps;
-  int32_t sz = taosArrayGetSize(rsps);
-  for (int i = 0; i < sz; i++) {
-    SClientHbRsp* pRsp = taosArrayGet(rsps, i);
-    if (pRsp->connKey.hbType < HEARTBEAT_TYPE_MAX) {
-      clientHbMgr.handle[pRsp->connKey.hbType](pRsp);
-    } else {
-      // discard rsp
-    }
-  }
-  return 0;
-}
-
-int hbRegisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, FGetConnInfo func) {
+int hbRegisterConnImpl(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, SHbConnInfo *info) {
   // init hash in activeinfo
   void* data = taosHashGet(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
   if (data != NULL) {
@@ -252,20 +491,53 @@ int hbRegisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey, FGetConnInfo func
   SClientHbReq hbReq;
   hbReq.connKey = connKey;
   hbReq.info = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);
+  
   taosHashPut(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey), &hbReq, sizeof(SClientHbReq));
+ 
   // init hash
-  if (func != NULL) {
-    taosHashPut(pAppHbMgr->getInfoFuncs, &connKey, sizeof(SClientHbKey), func, sizeof(FGetConnInfo));
+  if (info != NULL) {
+    SClientHbReq * pReq = taosHashGet(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
+    info->req = pReq;
+    taosHashPut(pAppHbMgr->connInfo, &connKey, sizeof(SClientHbKey), info, sizeof(SHbConnInfo));
   }
 
   atomic_add_fetch_32(&pAppHbMgr->connKeyCnt, 1);
   return 0;
 }
 
+int hbRegisterConn(SAppHbMgr* pAppHbMgr, int32_t connId, int64_t clusterId, int32_t hbType) {
+  SClientHbKey connKey = {.connId = connId, .hbType = HEARTBEAT_TYPE_QUERY};
+  SHbConnInfo info = {0};
+
+  switch (hbType) {
+    case HEARTBEAT_TYPE_QUERY: {
+      int64_t *pClusterId = malloc(sizeof(int64_t));
+      *pClusterId = clusterId;
+
+      info.param = pClusterId;
+      break;
+    }
+    case HEARTBEAT_TYPE_MQ: {
+      break;
+    }
+    default:
+      break;
+  }
+  
+  return hbRegisterConnImpl(pAppHbMgr, connKey, &info);
+}
+
 void hbDeregisterConn(SAppHbMgr* pAppHbMgr, SClientHbKey connKey) {
-  taosHashRemove(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
-  taosHashRemove(pAppHbMgr->getInfoFuncs, &connKey, sizeof(SClientHbKey));
+  int32_t code = 0;
+  code = taosHashRemove(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey));
+  code = taosHashRemove(pAppHbMgr->connInfo, &connKey, sizeof(SClientHbKey));
+  if (code) {
+    return;
+  }
   atomic_sub_fetch_32(&pAppHbMgr->connKeyCnt, 1);
+  if (atomic_load_32(&pAppHbMgr->connKeyCnt) <= 0) {
+    appHbMgrCleanup(pAppHbMgr);
+  }
 }
 
 int hbAddConnInfo(SAppHbMgr *pAppHbMgr, SClientHbKey connKey, void* key, void* value, int32_t keyLen, int32_t valueLen) {
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 227377c4a4..1378533949 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -101,7 +101,7 @@ TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass,
     }
 
     if (port) {
-      epSet.epSet.port[0] = port;
+      epSet.epSet.eps[0].port = port;
     }
   } else {
     if (initEpSetFromCfg(tsFirst, tsSecond, &epSet) < 0) {
@@ -119,7 +119,7 @@ TAOS *taos_connect_internal(const char *ip, const char *user, const char *pass,
     SAppInstInfo* p = calloc(1, sizeof(struct SAppInstInfo));
     p->mgmtEp       = epSet;
     p->pTransporter = openTransporter(user, secretEncrypt, tsNumOfCores);
-    /*p->pAppHbMgr = appHbMgrInit(p);*/
+    p->pAppHbMgr = appHbMgrInit(p, key);
     taosHashPut(appInfo.pInstMap, key, strlen(key), &p, POINTER_BYTES);
 
     pInst = &p;
@@ -218,12 +218,10 @@ int32_t getPlan(SRequestObj* pRequest, SQueryNode* pQueryNode, SQueryDag** pDag,
 
   if (pQueryNode->type == TSDB_SQL_SELECT) {
     setResSchemaInfo(&pRequest->body.resInfo, pSchema, numOfCols);
-    tfree(pSchema);
     pRequest->type = TDMT_VND_QUERY;
-  } else {
-    tfree(pSchema);
   }
 
+  tfree(pSchema);
   return code;
 }
 
@@ -241,9 +239,10 @@ void setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t
 }
 
 int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, SArray* pNodeList) {
+  void* pTransporter = pRequest->pTscObj->pAppInfo->pTransporter;
   if (TSDB_SQL_INSERT == pRequest->type || TSDB_SQL_CREATE_TABLE == pRequest->type) {
     SQueryResult res = {.code = 0, .numOfRows = 0, .msgSize = ERROR_MSG_BUF_DEFAULT_SIZE, .msg = pRequest->msgBuf};
-    int32_t code = schedulerExecJob(pRequest->pTscObj->pAppInfo->pTransporter, NULL, pDag, &pRequest->body.pQueryJob, &res);
+    int32_t code = schedulerExecJob(pTransporter, NULL, pDag, &pRequest->body.pQueryJob, pRequest->sqlstr, &res);
     if (code != TSDB_CODE_SUCCESS) {
       // handle error and retry
     } else {
@@ -257,7 +256,7 @@ int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, SArray* pNodeList)
     return pRequest->code;
   }
 
-  return schedulerAsyncExecJob(pRequest->pTscObj->pAppInfo->pTransporter, pNodeList, pDag, &pRequest->body.pQueryJob);
+  return schedulerAsyncExecJob(pTransporter, pNodeList, pDag, pRequest->sqlstr, &pRequest->body.pQueryJob);
 }
 
 
@@ -481,13 +480,8 @@ SArray* tmqGetConnInfo(SClientHbKey connKey, void* param) {
     return NULL;
   }
   SKv kv = {0};
-  kv.key = malloc(256);
-  if (kv.key == NULL) {
-    taosArrayDestroy(pArray);
-    return NULL;
-  }
-  strcpy(kv.key, "mq-tmp");
-  kv.keyLen = strlen("mq-tmp") + 1;
+  kv.key = HEARTBEAT_KEY_MQ_TMP;
+
   SMqHbMsg* pMqHb = malloc(sizeof(SMqHbMsg));
   if (pMqHb == NULL) {
     return pArray;
@@ -541,8 +535,8 @@ TAOS_RES *taos_create_topic(TAOS* taos, const char* topicName, const char* sql,
     goto _return;
   }
 
-  if (sqlLen > tsMaxSQLStringLen) {
-    tscError("sql string exceeds max length:%d", tsMaxSQLStringLen);
+  if (sqlLen > TSDB_MAX_ALLOWED_SQL_LEN) {
+    tscError("sql string exceeds max length:%d", TSDB_MAX_ALLOWED_SQL_LEN);
     terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
     goto _return;
   }
@@ -854,8 +848,8 @@ void tmq_message_destroy(tmq_message_t* tmq_message) {
 
 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);
+  if (sqlLen > (size_t) TSDB_MAX_ALLOWED_SQL_LEN) {
+    tscError("sql string exceeds max length:%d", TSDB_MAX_ALLOWED_SQL_LEN);
     terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
     return NULL;
   }
@@ -873,7 +867,6 @@ TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen) {
   if (qIsDdlQuery(pQueryNode)) {
     CHECK_CODE_GOTO(execDdlQuery(pRequest, pQueryNode), _return);
   } else {
-
     CHECK_CODE_GOTO(getPlan(pRequest, pQueryNode, &pRequest->body.pDag, pNodeList), _return);
     CHECK_CODE_GOTO(scheduleQuery(pRequest, pRequest->body.pDag, pNodeList), _return);
     pRequest->code = terrno;
@@ -903,7 +896,7 @@ int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSe
       return -1;
     }
 
-    taosGetFqdnPortFromEp(firstEp, mgmtEpSet->fqdn[0], &(mgmtEpSet->port[0]));
+    taosGetFqdnPortFromEp(firstEp, &mgmtEpSet->eps[0]);
     mgmtEpSet->numOfEps++;
   }
 
@@ -913,7 +906,7 @@ int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSe
       return -1;
     }
 
-    taosGetFqdnPortFromEp(secondEp, mgmtEpSet->fqdn[mgmtEpSet->numOfEps], &(mgmtEpSet->port[mgmtEpSet->numOfEps]));
+    taosGetFqdnPortFromEp(secondEp, &mgmtEpSet->eps[mgmtEpSet->numOfEps]);
     mgmtEpSet->numOfEps++;
   }
 
@@ -1118,14 +1111,7 @@ void* doFetchRow(SRequestObj* pRequest) {
       SShowReqInfo* pShowReqInfo = &pRequest->body.showInfo;
       SVgroupInfo* pVgroupInfo = taosArrayGet(pShowReqInfo->pArray, pShowReqInfo->currentIndex);
 
-      epSet.numOfEps = pVgroupInfo->numOfEps;
-      epSet.inUse = pVgroupInfo->inUse;
-
-      for (int32_t i = 0; i < epSet.numOfEps; ++i) {
-        strncpy(epSet.fqdn[i], pVgroupInfo->epAddr[i].fqdn, tListLen(epSet.fqdn[i]));
-        epSet.port[i] = pVgroupInfo->epAddr[i].port;
-      }
-
+      epSet = pVgroupInfo->epset;
     } else if (pRequest->type == TDMT_VND_SHOW_TABLES_FETCH) {
       pRequest->type = TDMT_VND_SHOW_TABLES;
       SShowReqInfo* pShowReqInfo = &pRequest->body.showInfo;
@@ -1142,14 +1128,7 @@ void* doFetchRow(SRequestObj* pRequest) {
       pRequest->body.requestMsg.pData = pShowReq;
 
       SMsgSendInfo* body = buildMsgInfoImpl(pRequest);
-
-      epSet.numOfEps = pVgroupInfo->numOfEps;
-      epSet.inUse = pVgroupInfo->inUse;
-
-      for (int32_t i = 0; i < epSet.numOfEps; ++i) {
-        strncpy(epSet.fqdn[i], pVgroupInfo->epAddr[i].fqdn, tListLen(epSet.fqdn[i]));
-        epSet.port[i] = pVgroupInfo->epAddr[i].port;
-      }
+      epSet = pVgroupInfo->epset;
 
       int64_t  transporterId = 0;
       STscObj *pTscObj = pRequest->pTscObj;
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index ba2a21d7ea..bdf3115981 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -46,6 +46,8 @@ void taos_cleanup(void) {
   clientConnRefPool = -1;
   taosCloseRef(id);
 
+  hbMgrCleanUp();
+
   rpcCleanup();
   catalogDestroy();
   taosCloseLog();
@@ -275,3 +277,70 @@ int taos_affected_rows(TAOS_RES *res) {
 }
 
 int taos_result_precision(TAOS_RES *res) { return TSDB_TIME_PRECISION_MILLI; }
+
+int taos_select_db(TAOS *taos, const char *db) {
+  STscObj *pObj = (STscObj *)taos;
+  if (pObj == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (db == NULL || strlen(db) == 0) {
+    terrno = TSDB_CODE_TSC_INVALID_INPUT;
+    return terrno;
+  }
+
+  char sql[256] = {0};
+  snprintf(sql, tListLen(sql), "use %s", db);
+
+  TAOS_RES* pRequest = taos_query(taos, sql);
+  int32_t code = taos_errno(pRequest);
+
+  taos_free_result(pRequest);
+  return code;
+}
+
+void taos_stop_query(TAOS_RES *res) {
+  if (res == NULL) {
+    return;
+  }
+
+  SRequestObj* pRequest = (SRequestObj*) res;
+  int32_t numOfFields = taos_num_fields(pRequest);
+
+  // It is not a query, no need to stop.
+  if (numOfFields == 0) {
+    return;
+  }
+
+//  scheduleCancelJob(pRequest->body.pQueryJob);
+}
+
+bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
+  return false;
+}
+
+int  taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
+  return 0;
+}
+
+int  taos_validate_sql(TAOS *taos, const char *sql) {
+  return true;
+}
+
+const char *taos_get_server_info(TAOS *taos) {
+  if (taos == NULL) {
+    return NULL;
+  }
+
+  STscObj* pTscObj = (STscObj*) taos;
+  return pTscObj->ver;
+}
+
+void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param) {
+  // TODO
+}
+
+void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
+  // TODO
+}
\ No newline at end of file
diff --git a/source/client/src/clientMsgHandler.c b/source/client/src/clientMsgHandler.c
index 1e056293be..24d1c0f03c 100644
--- a/source/client/src/clientMsgHandler.c
+++ b/source/client/src/clientMsgHandler.c
@@ -18,6 +18,7 @@
 #include "tname.h"
 #include "clientInt.h"
 #include "clientLog.h"
+#include "catalog.h"
 
 int (*handleRequestRspFp[TDMT_MAX])(void*, const SDataBuf* pMsg, int32_t code);
 
@@ -53,7 +54,7 @@ int processConnectRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 
   assert(pConnect->epSet.numOfEps > 0);
   for(int32_t i = 0; i < pConnect->epSet.numOfEps; ++i) {
-    pConnect->epSet.port[i] = htons(pConnect->epSet.port[i]);
+    pConnect->epSet.eps[i].port = htons(pConnect->epSet.eps[i].port);
   }
 
   if (!isEpsetEqual(&pTscObj->pAppInfo->mgmtEp.epSet, &pConnect->epSet)) {
@@ -61,18 +62,21 @@ int processConnectRsp(void* param, const SDataBuf* pMsg, int32_t code) {
   }
 
   for (int i = 0; i < pConnect->epSet.numOfEps; ++i) {
-    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);
+    tscDebug("0x%" PRIx64 " epSet.fqdn[%d]:%s port:%d, connObj:0x%"PRIx64, pRequest->requestId, i, pConnect->epSet.eps[i].fqdn,
+        pConnect->epSet.eps[i].port, pTscObj->id);
   }
 
   pTscObj->connId = pConnect->connId;
   pTscObj->acctId = pConnect->acctId;
+  tstrncpy(pTscObj->ver, pConnect->sVersion, tListLen(pTscObj->ver));
 
   // update the appInstInfo
   pTscObj->pAppInfo->clusterId = pConnect->clusterId;
   atomic_add_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
 
-  /*SClientHbKey connKey = {.connId = pConnect->connId, .hbType = HEARTBEAT_TYPE_QUERY};*/
-  /*hbRegisterConn(pTscObj->pAppInfo->pAppHbMgr, connKey, NULL);*/
+  pTscObj->connType = HEARTBEAT_TYPE_QUERY;
+
+  hbRegisterConn(pTscObj->pAppInfo->pAppHbMgr, pConnect->connId, pConnect->clusterId, HEARTBEAT_TYPE_QUERY);
 
   //  pRequest->body.resInfo.pRspMsg = pMsg->pData;
   tscDebug("0x%" PRIx64 " clusterId:%" PRId64 ", totalConn:%" PRId64, pRequest->requestId, pConnect->clusterId,
@@ -288,7 +292,6 @@ int32_t processCreateTableRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 }
 
 int32_t processDropDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
-  // todo: Remove cache in catalog cache.
   SRequestObj* pRequest = param;
   if (code != TSDB_CODE_SUCCESS) {
     setErrno(pRequest, code);
@@ -296,6 +299,18 @@ int32_t processDropDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
     return code;
   }
 
+  SDropDbRsp *rsp = (SDropDbRsp *)pMsg->pData;
+
+  SDbVgVersion dbVer = {0};
+  struct SCatalog *pCatalog = NULL;
+  
+  strncpy(dbVer.dbName, rsp->db, sizeof(dbVer.dbName));
+  dbVer.dbId = be64toh(rsp->uid);
+
+  catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &pCatalog);
+  
+  catalogRemoveDBVgroup(pCatalog, &dbVer);
+
   tsem_post(&pRequest->body.rspSem);
   return code;
 }
diff --git a/source/client/test/clientTests.cpp b/source/client/test/clientTests.cpp
index b2a6724e72..3d57a5de1d 100644
--- a/source/client/test/clientTests.cpp
+++ b/source/client/test/clientTests.cpp
@@ -61,473 +61,508 @@ TEST(testCase, connect_Test) {
   taos_close(pConn);
 }
 
-//TEST(testCase, create_user_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
+TEST(testCase, create_user_Test) {
+  TAOS* pConn = taos_connect("localhost", "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_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);
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
+
+TEST(testCase, create_account_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "create account aabc 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, drop_account_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "drop account aabc");
+  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("localhost", "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_free_result(pRes);
+  taos_close(pConn);
+}
+
+TEST(testCase, drop_user_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "drop user 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_db_Test) {
+  TAOS* pConn = taos_connect("localhost", "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);
+}
+
+TEST(testCase, create_db_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "create database abc1 vgroups 2");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+  }
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  ASSERT_TRUE(pFields == NULL);
+
+  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_EQ(numOfFields, 0);
+
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create database abc1 vgroups 4");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_close(pConn);
+}
+
+TEST(testCase, create_dnode_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "create dnode abc1 port 7000");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create dnode, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create dnode 1.1.1.1 port 9000");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create dnode, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  taos_close(pConn);
+}
+
+TEST(testCase, drop_dnode_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "drop dnode 3");
+  if (taos_errno(pRes) != 0) {
+    printf("error in drop dnode, reason:%s\n", taos_errstr(pRes));
+  }
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  ASSERT_TRUE(pFields == NULL);
+
+  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_EQ(numOfFields, 0);
+
+  pRes = taos_query(pConn, "drop dnode 4");
+  if (taos_errno(pRes) != 0) {
+    printf("error in drop dnode, reason:%s\n", taos_errstr(pRes));
+  }
+
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
+
+TEST(testCase, use_db_test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+  }
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  ASSERT_TRUE(pFields == NULL);
+
+  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_EQ(numOfFields, 0);
+
+  taos_close(pConn);
+}
+
+// TEST(testCase, drop_db_test) {
+//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+//  assert(pConn != NULL);
+//
+//  showDB(pConn);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "drop database abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to drop db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_free_result(pRes);
+//
+//  showDB(pConn);
+//
+//  pRes = taos_query(pConn, "create database abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("create to drop db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_free_result(pRes);
+//  taos_close(pConn);
 //}
 
-//TEST(testCase, create_account_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "create account aabc 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, drop_account_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "drop account aabc");
-  //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("localhost", "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_free_result(pRes);
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, drop_user_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "drop user 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_db_Test) {
-  //TAOS* pConn = taos_connect("localhost", "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);
-//}
-
-//TEST(testCase, create_db_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "create database abc1 vgroups 2");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in create db, reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  //ASSERT_TRUE(pFields == NULL);
-
-  //int32_t numOfFields = taos_num_fields(pRes);
-  //ASSERT_EQ(numOfFields, 0);
-
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create database abc1 vgroups 4");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in create db, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, create_dnode_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "create dnode abc1 port 7000");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in create dnode, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create dnode 1.1.1.1 port 9000");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create dnode, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, drop_dnode_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "drop dnode 3");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in drop dnode, reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  //ASSERT_TRUE(pFields == NULL);
-
-  //int32_t numOfFields = taos_num_fields(pRes);
-  //ASSERT_EQ(numOfFields, 0);
-
-  //pRes = taos_query(pConn, "drop dnode 4");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in drop dnode, reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //taos_free_result(pRes);
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, use_db_test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "use abc1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in use db, reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  //ASSERT_TRUE(pFields == NULL);
-
-  //int32_t numOfFields = taos_num_fields(pRes);
-  //ASSERT_EQ(numOfFields, 0);
-
-  //taos_close(pConn);
-//}
-
- //TEST(testCase, drop_db_test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //showDB(pConn);
-
-  //TAOS_RES* pRes = taos_query(pConn, "drop database abc1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to drop db, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //showDB(pConn);
-
-  //pRes = taos_query(pConn, "create database abc1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("create to drop db, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, create_stable_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 2");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in create db, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create table if not exists abc1.st1(ts timestamp, k int) tags(a int)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in create stable, reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  //ASSERT_TRUE(pFields == NULL);
-
-  //int32_t numOfFields = taos_num_fields(pRes);
-  //ASSERT_EQ(numOfFields, 0);
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create stable if not exists abc1.`123_$^)` (ts timestamp, `abc` int) tags(a int)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create super table 123_$^), reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //pRes = taos_query(pConn, "use abc1");
-  //taos_free_result(pRes);
-  //pRes = taos_query(pConn, "drop stable `123_$^)`");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to drop super table 123_$^), reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, create_table_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "use abc1");
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create table if not exists tm0(ts timestamp, k int)");
-  //ASSERT_EQ(taos_errno(pRes), 0);
-
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create table if not exists tm0(ts timestamp, k blob)");
-  //ASSERT_NE(taos_errno(pRes), 0);
-
-  //taos_free_result(pRes);
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, create_ctable_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "use abc1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to use db, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create stable if not exists st1 (ts timestamp, k int ) tags(a int)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create stable, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create table tm0 using st1 tags(1)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create child table tm0, reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //taos_free_result(pRes);
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, show_stable_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != nullptr);
-
-  //TAOS_RES* pRes = taos_query(pConn, "show abc1.stables");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to show stables, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-    //ASSERT_TRUE(false);
-  //}
-
-  //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_free_result(pRes);
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, show_vgroup_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "use abc1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to use db, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "show vgroups");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to show vgroups, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-    //ASSERT_TRUE(false);
-  //}
-
-  //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_free_result(pRes);
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, create_multiple_tables) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //ASSERT_NE(pConn, nullptr);
-
-  //TAOS_RES* pRes = taos_query(pConn, "use abc1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to use db, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-    //taos_close(pConn);
-    //return;
-  //}
-
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "create table t_2 using st1 tags(1)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create multiple tables, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-    //ASSERT_TRUE(false);
-  //}
-
-  //taos_free_result(pRes);
-  //pRes = taos_query(pConn, "create table t_3 using st1 tags(2)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create multiple tables, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-    //ASSERT_TRUE(false);
-  //}
-
-  //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_free_result(pRes);
-
-  //for (int32_t i = 0; i < 20; ++i) {
-    //char sql[512] = {0};
-    //snprintf(sql, tListLen(sql),
-             //"create table t_x_%d using st1 tags(2) t_x_%d using st1 tags(5) t_x_%d using st1 tags(911)", i,
-             //(i + 1) * 30, (i + 2) * 40);
-    //TAOS_RES* pres = taos_query(pConn, sql);
-    //if (taos_errno(pres) != 0) {
-      //printf("failed to create table %d\n, reason:%s", i, taos_errstr(pres));
-    //}
-    //taos_free_result(pres);
-  //}
-
-  //taos_close(pConn);
-//}
-
-//TEST(testCase, show_table_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != NULL);
-
-  //TAOS_RES* pRes = taos_query(pConn, "show tables");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to show tables, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-  //}
-
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "show abc1.tables");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to show tables, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-  //}
-
-  //TAOS_ROW    pRow = NULL;
-  //TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  //int32_t     numOfFields = taos_num_fields(pRes);
-
-  //int32_t count = 0;
-  //char str[512] = {0};
-
-  //while ((pRow = taos_fetch_row(pRes)) != NULL) {
-    //int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
-    //printf("%d: %s\n", ++count, str);
-  //}
-
-  //taos_free_result(pRes);
-  //taos_close(pConn);
-//}
+TEST(testCase, create_stable_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1 vgroups 2");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists abc1.st1(ts timestamp, k int) tags(a int)");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create stable, reason:%s\n", taos_errstr(pRes));
+  }
+
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  ASSERT_TRUE(pFields == NULL);
+
+  int32_t numOfFields = taos_num_fields(pRes);
+  ASSERT_EQ(numOfFields, 0);
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create stable if not exists abc1.`123_$^)` (ts timestamp, `abc` int) tags(a int)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table 123_$^), reason:%s\n", taos_errstr(pRes));
+  }
+
+  pRes = taos_query(pConn, "use abc1");
+  taos_free_result(pRes);
+  pRes = taos_query(pConn, "drop stable `123_$^)`");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to drop super table 123_$^), reason:%s\n", taos_errstr(pRes));
+  }
+
+  taos_close(pConn);
+}
+
+TEST(testCase, create_table_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists tm0(ts timestamp, k int)");
+  ASSERT_EQ(taos_errno(pRes), 0);
+
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists tm0(ts timestamp, k blob)");
+  ASSERT_NE(taos_errno(pRes), 0);
+
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
+
+TEST(testCase, create_ctable_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to use db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create stable if not exists st1 (ts timestamp, k int ) tags(a int)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create stable, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table tm0 using st1 tags(1)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table tm0, reason:%s\n", taos_errstr(pRes));
+  }
+
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
+
+TEST(testCase, show_stable_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != nullptr);
+
+  TAOS_RES* pRes = taos_query(pConn, "show abc1.stables");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to show stables, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    ASSERT_TRUE(false);
+  }
+
+  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_free_result(pRes);
+  taos_close(pConn);
+}
+
+TEST(testCase, show_vgroup_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to use db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "show vgroups");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to show vgroups, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    ASSERT_TRUE(false);
+  }
+
+  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_free_result(pRes);
+  taos_close(pConn);
+}
+
+TEST(testCase, create_multiple_tables) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(pConn, nullptr);
+
+  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create db, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    taos_close(pConn);
+    return;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to use db, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    taos_close(pConn);
+    return;
+  }
+
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create stable if not exists st1 (ts timestamp, k int) tags(a int)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create stable tables, reason:%s\n", taos_errstr(pRes));
+  }
+
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table t_2 using st1 tags(1)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create multiple tables, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    ASSERT_TRUE(false);
+  }
+
+  taos_free_result(pRes);
+  pRes = taos_query(pConn, "create table t_3 using st1 tags(2)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create multiple tables, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    ASSERT_TRUE(false);
+  }
+
+  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_free_result(pRes);
+
+  for (int32_t i = 0; i < 20; ++i) {
+    char sql[512] = {0};
+    snprintf(sql, tListLen(sql),
+             "create table t_x_%d using st1 tags(2) t_x_%d using st1 tags(5) t_x_%d using st1 tags(911)", i,
+             (i + 1) * 30, (i + 2) * 40);
+    TAOS_RES* pres = taos_query(pConn, sql);
+    if (taos_errno(pres) != 0) {
+      printf("failed to create table %d\n, reason:%s", i, taos_errstr(pres));
+    }
+    taos_free_result(pres);
+  }
+
+  taos_close(pConn);
+}
+
+TEST(testCase, show_table_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "show tables");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to show tables, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+  }
+
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "show abc1.tables");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to show tables, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+  }
+
+  TAOS_ROW    pRow = NULL;
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  int32_t     numOfFields = taos_num_fields(pRes);
+
+  int32_t count = 0;
+  char str[512] = {0};
+
+  while ((pRow = taos_fetch_row(pRes)) != NULL) {
+    int32_t code = taos_print_row(str, pRow, pFields, numOfFields);
+    printf("%d: %s\n", ++count, str);
+  }
+
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
 
 //TEST(testCase, drop_stable_Test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //assert(pConn != nullptr);
-
-  //TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in creating db, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "use abc1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("error in using db, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "drop stable st1");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to drop stable, reason:%s\n", taos_errstr(pRes));
-  //}
-
-  //taos_free_result(pRes);
-  //taos_close(pConn);
+//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+//  assert(pConn != nullptr);
+//
+//  TAOS_RES* pRes = taos_query(pConn, "create database if not exists abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in creating db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "use abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in using db, reason:%s\n", taos_errstr(pRes));
+//  }
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "drop stable st1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to drop stable, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  taos_free_result(pRes);
+//  taos_close(pConn);
 //}
 
-//TEST(testCase, generated_request_id_test) {
-  //SHashObj* phash = taosHashInit(10000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
+TEST(testCase, generated_request_id_test) {
+  SHashObj* phash = taosHashInit(10000, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
 
-  //for (int32_t i = 0; i < 50000; ++i) {
-    //uint64_t v = generateRequestId();
-    //void*    result = taosHashGet(phash, &v, sizeof(v));
-    //if (result != nullptr) {
-      //printf("0x%lx, index:%d\n", v, i);
-    //}
-    //assert(result == nullptr);
-    //taosHashPut(phash, &v, sizeof(v), NULL, 0);
-  //}
+  for (int32_t i = 0; i < 50000; ++i) {
+    uint64_t v = generateRequestId();
+    void*    result = taosHashGet(phash, &v, sizeof(v));
+    if (result != nullptr) {
+      printf("0x%lx, index:%d\n", v, i);
+    }
+    assert(result == nullptr);
+    taosHashPut(phash, &v, sizeof(v), NULL, 0);
+  }
 
-  //taosHashCleanup(phash);
-//}
+  taosHashCleanup(phash);
+}
 
+TEST(testCase, insert_test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(pConn, nullptr);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into t_2 values(now, 1)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create into table t_2, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    ASSERT_TRUE(false);
+  }
+
+  taos_free_result(pRes);
+  taos_close(pConn);
+}
+
+#if 0
 TEST(testCase, create_topic_Test) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
   assert(pConn != NULL);
@@ -552,23 +587,6 @@ TEST(testCase, create_topic_Test) {
   taos_close(pConn);
 }
 
-//TEST(testCase, insert_test) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //ASSERT_NE(pConn, nullptr);
-
-  //TAOS_RES* pRes = taos_query(pConn, "use abc1");
-  //taos_free_result(pRes);
-
-  //pRes = taos_query(pConn, "insert into t_2 values(now, 1)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create multiple tables, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-    //ASSERT_TRUE(false);
-  //}
-
-  //taos_free_result(pRes);
-  //taos_close(pConn);
-//}
 
 TEST(testCase, tmq_subscribe_Test) {
   TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
@@ -583,17 +601,18 @@ TEST(testCase, tmq_subscribe_Test) {
   tmq_conf_t* conf = tmq_conf_new();
   tmq_conf_set(conf, "group.id", "tg1");
   tmq_t* tmq = taos_consumer_new(pConn, conf, NULL, 0);
-  
+
   tmq_list_t* topic_list = tmq_list_new();
   tmq_list_append(topic_list, "test_topic_1");
   tmq_subscribe(tmq, topic_list);
 
   while (1) {
-    tmq_message_t* msg = tmq_consume_poll(tmq, 1000);
-    //printf("get msg\n");
+    tmq_message_t* msg = tmq_consume_poll(tmq, 0);
+    printf("get msg\n");
     //if (msg == NULL) break;
   }
 }
+#endif
 
 TEST(testCase, tmq_consume_Test) {
 }
@@ -601,135 +620,117 @@ TEST(testCase, tmq_consume_Test) {
 TEST(testCase, tmq_commit_TEST) {
 }
 
-//TEST(testCase, insert_test) {
-//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-//  ASSERT_NE(pConn, nullptr);
-//
-//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
-//  taos_free_result(pRes);
-//
-//  pRes = taos_query(pConn, "insert into t_2 values(now, 1)");
-//  if (taos_errno(pRes) != 0) {
-//    printf("failed to create multiple tables, reason:%s\n", taos_errstr(pRes));
-//    taos_free_result(pRes);
-//    ASSERT_TRUE(false);
-//  }
-//
-//  taos_free_result(pRes);
-//  taos_close(pConn);
-//}
+TEST(testCase, projection_query_tables) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(pConn, nullptr);
 
-//TEST(testCase, projection_query_tables) {
-  //TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  //ASSERT_NE(pConn, nullptr);
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  taos_free_result(pRes);
 
-  //TAOS_RES* pRes = taos_query(pConn, "use abc1");
-  //taos_free_result(pRes);
+  pRes = taos_query(pConn, "create stable st1 (ts timestamp, k int) tags(a int)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create table tu, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
 
-  //pRes = taos_query(pConn, "create stable st1 (ts timestamp, k int) tags(a int)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create table tu, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
+  pRes = taos_query(pConn, "create table tu using st1 tags(1)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create table tu, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
 
-  //pRes = taos_query(pConn, "create table tu using st1 tags(1)");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to create table tu, reason:%s\n", taos_errstr(pRes));
-  //}
-  //taos_free_result(pRes);
+  for(int32_t i = 0; i < 100000; ++i) {
+    char sql[512] = {0};
+    sprintf(sql, "insert into tu values(now+%da, %d)", i, i);
+    TAOS_RES* p = taos_query(pConn, sql);
+    if (taos_errno(p) != 0) {
+      printf("failed to insert data, reason:%s\n", taos_errstr(p));
+    }
 
-  //for(int32_t i = 0; i < 100000; ++i) {
-    //char sql[512] = {0};
-    //sprintf(sql, "insert into tu values(now+%da, %d)", i, i);
-    //TAOS_RES* p = taos_query(pConn, sql);
-    //if (taos_errno(p) != 0) {
-      //printf("failed to insert data, reason:%s\n", taos_errstr(p));
-    //}
+    taos_free_result(p);
+  }
 
-    //taos_free_result(p);
-  //}
+  pRes = taos_query(pConn, "select * from tu");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    ASSERT_TRUE(false);
+  }
 
-  //pRes = taos_query(pConn, "select * from tu");
-  //if (taos_errno(pRes) != 0) {
-    //printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
-    //taos_free_result(pRes);
-    //ASSERT_TRUE(false);
-  //}
+  TAOS_ROW    pRow = NULL;
+  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+  int32_t     numOfFields = taos_num_fields(pRes);
 
-  //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);
+  }
 
-  //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_free_result(pRes);
+  taos_close(pConn);
+}
 
-  //taos_free_result(pRes);
-  //taos_close(pConn);
-//}
+TEST(testCase, projection_query_stables) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(pConn, nullptr);
 
-//TEST(testCase, projection_query_stables) {
-//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-//  ASSERT_NE(pConn, nullptr);
-//
-//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
-//  taos_free_result(pRes);
-//
-//  pRes = taos_query(pConn, "select ts from m1");
-//  if (taos_errno(pRes) != 0) {
-//    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
-//    taos_free_result(pRes);
-//    ASSERT_TRUE(false);
-//  }
-//
-//  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_free_result(pRes);
-//  taos_close(pConn);
-//}
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  taos_free_result(pRes);
 
-//TEST(testCase, agg_query_tables) {
-//  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-//  ASSERT_NE(pConn, nullptr);
-//
-//  TAOS_RES* pRes = taos_query(pConn, "use dbv");
-//  taos_free_result(pRes);
-//
-//  pRes = taos_query(pConn, "create table tx using st tags(111111111111111)");
-//  if (taos_errno(pRes) != 0) {
-//    printf("failed to create table, reason:%s\n", taos_errstr(pRes));
-//  }
-//  taos_free_result(pRes);
-//
-//  pRes = taos_query(pConn, "select count(*) from tu");
-//  if (taos_errno(pRes) != 0) {
-//    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
-//    taos_free_result(pRes);
-//    ASSERT_TRUE(false);
-//  }
-//
-//  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_free_result(pRes);
-//  taos_close(pConn);
-//}
+  pRes = taos_query(pConn, "select ts from st1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    ASSERT_TRUE(false);
+  }
+
+  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_free_result(pRes);
+  taos_close(pConn);
+}
+
+TEST(testCase, agg_query_tables) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  ASSERT_NE(pConn, nullptr);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table tx using st1 tags(111111111111111)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create table, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "select count(*) from t_x_19");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to select from table, reason:%s\n", taos_errstr(pRes));
+    taos_free_result(pRes);
+    ASSERT_TRUE(false);
+  }
+
+  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_free_result(pRes);
+  taos_close(pConn);
+}
 
 #pragma GCC diagnostic pop
diff --git a/source/common/src/tep.c b/source/common/src/tep.c
index 9cc99e7f51..45587a8856 100644
--- a/source/common/src/tep.c
+++ b/source/common/src/tep.c
@@ -1,33 +1,45 @@
 #include "tep.h"
+#include "common.h"
 #include "tglobal.h"
 #include "tlockfree.h"
 
-int taosGetFqdnPortFromEp(const char *ep, char *fqdn, uint16_t *port) {
-  *port = 0;
-  strcpy(fqdn, ep);
+int taosGetFqdnPortFromEp(const char *ep, SEp* pEp) {
+  pEp->port = 0;
+  strcpy(pEp->fqdn, ep);
 
-  char *temp = strchr(fqdn, ':');
+  char *temp = strchr(pEp->fqdn, ':');
   if (temp) {
     *temp = 0;
-    *port = atoi(temp+1);
+    pEp->port = atoi(temp+1);
   }
 
-  if (*port == 0) {
-    *port = tsServerPort;
+  if (pEp->port == 0) {
+    pEp->port = tsServerPort;
     return -1;
   }
 
   return 0;
 }
 
+void addEpIntoEpSet(SEpSet *pEpSet, const char* fqdn, uint16_t port) {
+  if (pEpSet == NULL || fqdn == NULL || strlen(fqdn) == 0) {
+    return;
+  }
+
+  int32_t index = pEpSet->numOfEps;
+  tstrncpy(pEpSet->eps[index].fqdn, fqdn, tListLen(pEpSet->eps[index].fqdn));
+  pEpSet->eps[index].port = port;
+  pEpSet->numOfEps += 1;
+}
+
 bool isEpsetEqual(const SEpSet *s1, const SEpSet *s2) {
   if (s1->numOfEps != s2->numOfEps || s1->inUse != s2->inUse) {
     return false;
   }
 
   for (int32_t i = 0; i < s1->numOfEps; i++) {
-    if (s1->port[i] != s2->port[i]
-        || strncmp(s1->fqdn[i], s2->fqdn[i], TSDB_FQDN_LEN) != 0)
+    if (s1->eps[i].port != s2->eps[i].port
+        || strncmp(s1->eps[i].fqdn, s2->eps[i].fqdn, TSDB_FQDN_LEN) != 0)
       return false;
   }
   return true;
@@ -48,3 +60,99 @@ SEpSet getEpSet_s(SCorEpSet *pEpSet) {
   return ep;
 }
 
+bool colDataIsNull(const SColumnInfoData* pColumnInfoData, uint32_t totalRows, uint32_t row, SColumnDataAgg* pColAgg) {
+  if (pColAgg != NULL) {
+    if (pColAgg->numOfNull == totalRows) {
+      ASSERT(pColumnInfoData->nullbitmap == NULL);
+      return true;
+    } else if (pColAgg->numOfNull == 0) {
+      ASSERT(pColumnInfoData->nullbitmap == NULL);
+      return false;
+    }
+  }
+
+  if (pColumnInfoData->nullbitmap == NULL) {
+    return false;
+  }
+
+  uint8_t v = (pColumnInfoData->nullbitmap[row>>3] & (1<<(8 - (row&0x07))));
+  return (v == 1);
+}
+
+bool colDataIsNull_f(const char* bitmap, uint32_t row) {
+  return (bitmap[row>>3] & (1<<(8 - (row&0x07))));
+}
+
+void colDataSetNull_f(char* bitmap, uint32_t row) { // TODO
+  return;
+}
+
+void* colDataGet(const SColumnInfoData* pColumnInfoData, uint32_t row) {
+  if (IS_VAR_DATA_TYPE(pColumnInfoData->info.type)) {
+    uint32_t offset = ((uint32_t*)pColumnInfoData->pData)[row];
+    return (char*)(pColumnInfoData->pData) + offset; // the first part is the pointer to the true binary data
+  } else {
+    return (char*)(pColumnInfoData->pData) + (row * pColumnInfoData->info.bytes);
+  }
+}
+
+int32_t colDataAppend(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, bool isNull) {
+  ASSERT(pColumnInfoData != NULL);
+
+  if (isNull) {
+    // TODO set null value in the nullbitmap
+    return 0;
+  }
+
+  int32_t type = pColumnInfoData->info.type;
+  if (IS_VAR_DATA_TYPE(type)) {
+    // TODO continue append var_type
+  } else {
+    char* p = pColumnInfoData->pData + pColumnInfoData->info.bytes * currentRow;
+    switch(type) {
+      case TSDB_DATA_TYPE_TINYINT:
+      case TSDB_DATA_TYPE_UTINYINT: {*(int8_t*) p = *(int8_t*) pData;break;}
+      default:
+        assert(0);
+    }
+
+  }
+
+  return 0;
+}
+
+size_t colDataGetCols(const SSDataBlock* pBlock) {
+  ASSERT(pBlock);
+
+  size_t constantCols = (pBlock->pConstantList != NULL)? taosArrayGetSize(pBlock->pConstantList):0;
+  ASSERT( pBlock->info.numOfCols == taosArrayGetSize(pBlock->pDataBlock) + constantCols);
+  return pBlock->info.numOfCols;
+}
+
+size_t colDataGetRows(const SSDataBlock* pBlock) {
+  return pBlock->info.rows;
+}
+
+int32_t colDataUpdateTsWindow(SSDataBlock* pDataBlock) {
+  if (pDataBlock == NULL || pDataBlock->info.rows <= 0) {
+    return 0;
+  }
+
+  if (pDataBlock->info.numOfCols <= 0) {
+    return -1;
+  }
+
+  SColumnInfoData* pColInfoData = taosArrayGet(pDataBlock->pDataBlock, 0);
+  if (pColInfoData->info.type != TSDB_DATA_TYPE_TIMESTAMP) {
+    return 0;
+  }
+
+  ASSERT(pColInfoData->nullbitmap == NULL);
+  pDataBlock->info.window.skey = *(TSKEY*) colDataGet(pColInfoData, 0);
+  pDataBlock->info.window.ekey = *(TSKEY*) colDataGet(pColInfoData, (pDataBlock->info.rows - 1));
+  return 0;
+}
+
+
+
+
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index 7a0966df57..afba1190ba 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -78,7 +78,6 @@ int32_t tsCompressColData = -1;
 int32_t tsCompatibleModel = 1;
 
 // client
-int32_t tsMaxSQLStringLen = TSDB_MAX_ALLOWED_SQL_LEN;
 int32_t tsMaxWildCardsLen = TSDB_PATTERN_STRING_DEFAULT_LEN;
 int32_t tsMaxRegexStringLen = TSDB_REGEX_STRING_DEFAULT_LEN;
 
@@ -594,16 +593,6 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosAddConfigOption(cfg);
 
-  cfg.option = "maxSQLLength";
-  cfg.ptr = &tsMaxSQLStringLen;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = TSDB_MAX_SQL_LEN;
-  cfg.maxValue = TSDB_MAX_ALLOWED_SQL_LEN;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_BYTE;
-  taosAddConfigOption(cfg);
-
   cfg.option = "maxWildCardsLength";
   cfg.ptr = &tsMaxWildCardsLen;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -1080,9 +1069,7 @@ static void doInitGlobalConfig(void) {
 void taosInitGlobalCfg() { pthread_once(&tsInitGlobalCfgOnce, doInitGlobalConfig); }
 
 int32_t taosCheckAndPrintCfg() {
-  char     fqdn[TSDB_FQDN_LEN];
-  uint16_t port;
-
+  SEp ep = {0};
   if (debugFlag & DEBUG_TRACE || debugFlag & DEBUG_DEBUG || debugFlag & DEBUG_DUMP) {
     taosSetAllDebugFlag();
   }
@@ -1097,15 +1084,15 @@ int32_t taosCheckAndPrintCfg() {
   if (tsFirst[0] == 0) {
     strcpy(tsFirst, tsLocalEp);
   } else {
-    taosGetFqdnPortFromEp(tsFirst, fqdn, &port);
-    snprintf(tsFirst, sizeof(tsFirst), "%s:%u", fqdn, port);
+    taosGetFqdnPortFromEp(tsFirst, &ep);
+    snprintf(tsFirst, sizeof(tsFirst), "%s:%u", ep.fqdn, ep.port);
   }
 
   if (tsSecond[0] == 0) {
     strcpy(tsSecond, tsLocalEp);
   } else {
-    taosGetFqdnPortFromEp(tsSecond, fqdn, &port);
-    snprintf(tsSecond, sizeof(tsSecond), "%s:%u", fqdn, port);
+    taosGetFqdnPortFromEp(tsSecond, &ep);
+    snprintf(tsSecond, sizeof(tsSecond), "%s:%u", ep.fqdn, ep.port);
   }
 
   taosCheckDataDirCfg();
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index 48e9dce3c1..34b55fd812 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -91,13 +91,11 @@ int tSerializeSClientHbReq(void **buf, const SClientHbReq *pReq) {
 
   int32_t kvNum = taosHashGetSize(pReq->info);
   tlen += taosEncodeFixedI32(buf, kvNum);
-  SKv kv;
+  SKv *kv;
   void* pIter = taosHashIterate(pReq->info, NULL);
   while (pIter != NULL) {
-    taosHashGetKey(pIter, &kv.key, (size_t *)&kv.keyLen);
-    kv.valueLen = taosHashGetDataLen(pIter);
-    kv.value = pIter;
-    tlen += taosEncodeSKv(buf, &kv);
+    kv = pIter;
+    tlen += taosEncodeSKv(buf, kv);
 
     pIter = taosHashIterate(pReq->info, pIter);
   }
@@ -116,7 +114,7 @@ void *tDeserializeSClientHbReq(void *buf, SClientHbReq *pReq) {
   for(int i = 0; i < kvNum; i++) {
     SKv kv;
     buf = taosDecodeSKv(buf, &kv);
-    taosHashPut(pReq->info, kv.key, kv.keyLen, kv.value, kv.valueLen);
+    taosHashPut(pReq->info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
   }
 
   return buf;
@@ -124,17 +122,28 @@ void *tDeserializeSClientHbReq(void *buf, SClientHbReq *pReq) {
 
 int   tSerializeSClientHbRsp(void** buf, const SClientHbRsp* pRsp) {
   int tlen = 0;
+  int32_t kvNum = taosArrayGetSize(pRsp->info);
   tlen += taosEncodeSClientHbKey(buf, &pRsp->connKey);
   tlen += taosEncodeFixedI32(buf, pRsp->status);
-  tlen += taosEncodeFixedI32(buf, pRsp->bodyLen);
-  tlen += taosEncodeBinary(buf, pRsp->body, pRsp->bodyLen);
+  tlen += taosEncodeFixedI32(buf, kvNum);
+  for (int i = 0; i < kvNum; i++) {
+    SKv *kv = (SKv *)taosArrayGet(pRsp->info, i);
+    tlen += taosEncodeSKv(buf, kv);
+  }
   return tlen;
 }
 void* tDeserializeSClientHbRsp(void* buf, SClientHbRsp* pRsp) {
+  int32_t kvNum = 0;
   buf = taosDecodeSClientHbKey(buf, &pRsp->connKey);
   buf = taosDecodeFixedI32(buf, &pRsp->status);
-  buf = taosDecodeFixedI32(buf, &pRsp->bodyLen);
-  buf = taosDecodeBinary(buf, &pRsp->body, pRsp->bodyLen);
+  buf = taosDecodeFixedI32(buf, &kvNum);
+  pRsp->info = taosArrayInit(kvNum, sizeof(SKv));
+  for (int i = 0; i < kvNum; i++) {
+    SKv kv = {0};
+    buf = taosDecodeSKv(buf, &kv);
+    taosArrayPush(pRsp->info, &kv);
+  }
+  
   return buf;
 }
 
@@ -155,6 +164,7 @@ void* tDeserializeSClientHbBatchReq(void* buf, SClientHbBatchReq* pBatchReq) {
   if (pBatchReq->reqs == NULL) {
     pBatchReq->reqs = taosArrayInit(0, sizeof(SClientHbReq));
   }
+ 
   int32_t reqNum;
   buf = taosDecodeFixedI32(buf, &reqNum);
   for (int i = 0; i < reqNum; i++) {
diff --git a/source/dnode/mgmt/impl/src/dndMgmt.c b/source/dnode/mgmt/impl/src/dndMgmt.c
index dce5c01895..0674d719b9 100644
--- a/source/dnode/mgmt/impl/src/dndMgmt.c
+++ b/source/dnode/mgmt/impl/src/dndMgmt.c
@@ -57,13 +57,13 @@ void dndGetDnodeEp(SDnode *pDnode, int32_t dnodeId, char *pEp, char *pFqdn, uint
   SDnodeEp *pDnodeEp = taosHashGet(pMgmt->dnodeHash, &dnodeId, sizeof(int32_t));
   if (pDnodeEp != NULL) {
     if (pPort != NULL) {
-      *pPort = pDnodeEp->port;
+      *pPort = pDnodeEp->ep.port;
     }
     if (pFqdn != NULL) {
-      tstrncpy(pFqdn, pDnodeEp->fqdn, TSDB_FQDN_LEN);
+      tstrncpy(pFqdn, pDnodeEp->ep.fqdn, TSDB_FQDN_LEN);
     }
     if (pEp != NULL) {
-      snprintf(pEp, TSDB_EP_LEN, "%s:%u", pDnodeEp->fqdn, pDnodeEp->port);
+      snprintf(pEp, TSDB_EP_LEN, "%s:%u", pDnodeEp->ep.fqdn, pDnodeEp->ep.port);
     }
   }
 
@@ -85,12 +85,12 @@ void dndSendRedirectRsp(SDnode *pDnode, SRpcMsg *pReq) {
 
   dDebug("RPC %p, req:%s is redirected, num:%d use:%d", pReq->handle, TMSG_INFO(msgType), epSet.numOfEps, epSet.inUse);
   for (int32_t i = 0; i < epSet.numOfEps; ++i) {
-    dDebug("mnode index:%d %s:%u", i, epSet.fqdn[i], epSet.port[i]);
-    if (strcmp(epSet.fqdn[i], pDnode->cfg.localFqdn) == 0 && epSet.port[i] == pDnode->cfg.serverPort) {
+    dDebug("mnode index:%d %s:%u", i, epSet.eps[i].fqdn, epSet.eps[i].port);
+    if (strcmp(epSet.eps[i].fqdn, pDnode->cfg.localFqdn) == 0 && epSet.eps[i].port == pDnode->cfg.serverPort) {
       epSet.inUse = (i + 1) % epSet.numOfEps;
     }
 
-    epSet.port[i] = htons(epSet.port[i]);
+    epSet.eps[i].port = htons(epSet.eps[i].port);
   }
 
   rpcSendRedirectRsp(pReq->handle, &epSet);
@@ -104,7 +104,7 @@ static void dndUpdateMnodeEpSet(SDnode *pDnode, SEpSet *pEpSet) {
 
   pMgmt->mnodeEpSet = *pEpSet;
   for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
-    dInfo("mnode index:%d %s:%u", i, pEpSet->fqdn[i], pEpSet->port[i]);
+    dInfo("mnode index:%d %s:%u", i, pEpSet->eps[i].fqdn, pEpSet->eps[i].port);
   }
 
   taosWUnLockLatch(&pMgmt->latch);
@@ -116,7 +116,7 @@ static void dndPrintDnodes(SDnode *pDnode) {
   dDebug("print dnode ep list, num:%d", pMgmt->dnodeEps->num);
   for (int32_t i = 0; i < pMgmt->dnodeEps->num; i++) {
     SDnodeEp *pEp = &pMgmt->dnodeEps->eps[i];
-    dDebug("dnode:%d, fqdn:%s port:%u isMnode:%d", pEp->id, pEp->fqdn, pEp->port, pEp->isMnode);
+    dDebug("dnode:%d, fqdn:%s port:%u isMnode:%d", pEp->id, pEp->ep.fqdn, pEp->ep.port, pEp->isMnode);
   }
 }
 
@@ -145,8 +145,8 @@ static void dndResetDnodes(SDnode *pDnode, SDnodeEps *pDnodeEps) {
     if (!pDnodeEp->isMnode) continue;
     if (mIndex >= TSDB_MAX_REPLICA) continue;
     pMgmt->mnodeEpSet.numOfEps++;
-    strcpy(pMgmt->mnodeEpSet.fqdn[mIndex], pDnodeEp->fqdn);
-    pMgmt->mnodeEpSet.port[mIndex] = pDnodeEp->port;
+
+    pMgmt->mnodeEpSet.eps[mIndex] = pDnodeEp->ep;
     mIndex++;
   }
 
@@ -167,7 +167,7 @@ static bool dndIsEpChanged(SDnode *pDnode, int32_t dnodeId, char *pEp) {
   SDnodeEp *pDnodeEp = taosHashGet(pMgmt->dnodeHash, &dnodeId, sizeof(int32_t));
   if (pDnodeEp != NULL) {
     char epstr[TSDB_EP_LEN + 1];
-    snprintf(epstr, TSDB_EP_LEN, "%s:%u", pDnodeEp->fqdn, pDnodeEp->port);
+    snprintf(epstr, TSDB_EP_LEN, "%s:%u", pDnodeEp->ep.fqdn, pDnodeEp->ep.port);
     changed = strcmp(pEp, epstr) != 0;
   }
 
@@ -251,11 +251,12 @@ static int32_t dndReadDnodes(SDnode *pDnode) {
 
     SDnodeEp *pDnodeEp = &pMgmt->dnodeEps->eps[i];
 
-    cJSON *dnodeId = cJSON_GetObjectItem(node, "id");
-    if (!dnodeId || dnodeId->type != cJSON_Number) {
+    cJSON *did = cJSON_GetObjectItem(node, "id");
+    if (!did || did->type != cJSON_Number) {
       dError("failed to read %s since dnodeId not found", pMgmt->file);
       goto PRASE_DNODE_OVER;
     }
+
     pDnodeEp->id = dnodeId->valueint;
 
     cJSON *dnodeFqdn = cJSON_GetObjectItem(node, "fqdn");
@@ -263,14 +264,15 @@ static int32_t dndReadDnodes(SDnode *pDnode) {
       dError("failed to read %s since dnodeFqdn not found", pMgmt->file);
       goto PRASE_DNODE_OVER;
     }
-    tstrncpy(pDnodeEp->fqdn, dnodeFqdn->valuestring, TSDB_FQDN_LEN);
+    tstrncpy(pDnodeEp->ep.fqdn, dnodeFqdn->valuestring, TSDB_FQDN_LEN);
 
     cJSON *dnodePort = cJSON_GetObjectItem(node, "port");
     if (!dnodePort || dnodePort->type != cJSON_Number) {
       dError("failed to read %s since dnodePort not found", pMgmt->file);
       goto PRASE_DNODE_OVER;
     }
-    pDnodeEp->port = dnodePort->valueint;
+
+    pDnodeEp->ep.port = dnodePort->valueint;
 
     cJSON *isMnode = cJSON_GetObjectItem(node, "isMnode");
     if (!isMnode || isMnode->type != cJSON_Number) {
@@ -298,7 +300,8 @@ PRASE_DNODE_OVER:
     pMgmt->dnodeEps = calloc(1, sizeof(SDnodeEps) + sizeof(SDnodeEp));
     pMgmt->dnodeEps->num = 1;
     pMgmt->dnodeEps->eps[0].isMnode = 1;
-    taosGetFqdnPortFromEp(pDnode->cfg.firstEp, pMgmt->dnodeEps->eps[0].fqdn, &pMgmt->dnodeEps->eps[0].port);
+
+    taosGetFqdnPortFromEp(pDnode->cfg.firstEp, &(pMgmt->dnodeEps->eps[0].ep));
   }
 
   dndResetDnodes(pDnode, pMgmt->dnodeEps);
@@ -329,8 +332,8 @@ static int32_t dndWriteDnodes(SDnode *pDnode) {
   for (int32_t i = 0; i < pMgmt->dnodeEps->num; ++i) {
     SDnodeEp *pDnodeEp = &pMgmt->dnodeEps->eps[i];
     len += snprintf(content + len, maxLen - len, "    \"id\": %d,\n", pDnodeEp->id);
-    len += snprintf(content + len, maxLen - len, "    \"fqdn\": \"%s\",\n", pDnodeEp->fqdn);
-    len += snprintf(content + len, maxLen - len, "    \"port\": %u,\n", pDnodeEp->port);
+    len += snprintf(content + len, maxLen - len, "    \"fqdn\": \"%s\",\n", pDnodeEp->ep.fqdn);
+    len += snprintf(content + len, maxLen - len, "    \"port\": %u,\n", pDnodeEp->ep.port);
     len += snprintf(content + len, maxLen - len, "    \"isMnode\": %d\n", pDnodeEp->isMnode);
     if (i < pMgmt->dnodeEps->num - 1) {
       len += snprintf(content + len, maxLen - len, "  },{\n");
@@ -395,7 +398,7 @@ void dndSendStatusReq(SDnode *pDnode) {
 static void dndUpdateDnodeCfg(SDnode *pDnode, SDnodeCfg *pCfg) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
   if (pMgmt->dnodeId == 0) {
-    dInfo("set dnodeId:%d clusterId:%" PRId64, pCfg->dnodeId, pCfg->clusterId);
+    dInfo("set dnodeId:%d clusterId:0x%" PRId64, pCfg->dnodeId, pCfg->clusterId);
     taosWLockLatch(&pMgmt->latch);
     pMgmt->dnodeId = pCfg->dnodeId;
     pMgmt->clusterId = pCfg->clusterId;
@@ -450,7 +453,7 @@ static void dndProcessStatusRsp(SDnode *pDnode, SRpcMsg *pRsp) {
     pDnodeEps->num = htonl(pDnodeEps->num);
     for (int32_t i = 0; i < pDnodeEps->num; ++i) {
       pDnodeEps->eps[i].id = htonl(pDnodeEps->eps[i].id);
-      pDnodeEps->eps[i].port = htons(pDnodeEps->eps[i].port);
+      pDnodeEps->eps[i].ep.port = htons(pDnodeEps->eps[i].ep.port);
     }
 
     dndUpdateDnodeEps(pDnode, pDnodeEps);
diff --git a/source/dnode/mgmt/impl/src/dndVnodes.c b/source/dnode/mgmt/impl/src/dndVnodes.c
index dcb73d13c7..c4d14ef697 100644
--- a/source/dnode/mgmt/impl/src/dndVnodes.c
+++ b/source/dnode/mgmt/impl/src/dndVnodes.c
@@ -16,6 +16,7 @@
 #define _DEFAULT_SOURCE
 #include "dndVnodes.h"
 #include "dndTransport.h"
+#include "dndMgmt.h"
 
 typedef struct {
   int32_t  vgId;
@@ -527,7 +528,6 @@ static void dndGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
   pCfg->vgId = pCreate->vgId;
   pCfg->wsize = pCreate->cacheBlockSize;
   pCfg->ssize = pCreate->cacheBlockSize;
-  pCfg->wsize = pCreate->cacheBlockSize;
   pCfg->lsize = pCreate->cacheBlockSize;
   pCfg->isHeapAllocator = true;
   pCfg->ttl = 4;
@@ -578,6 +578,12 @@ int32_t dndProcessCreateVnodeReq(SDnode *pDnode, SRpcMsg *pReq) {
   SWrapperCfg wrapperCfg = {0};
   dndGenerateWrapperCfg(pDnode, pCreate, &wrapperCfg);
 
+  if (pCreate->dnodeId != dndGetDnodeId(pDnode)) {
+    terrno = TSDB_CODE_DND_VNODE_INVALID_OPTION;
+    dDebug("vgId:%d, failed to create vnode since %s", pCreate->vgId, terrstr());
+    return -1;
+  }
+
   SVnodeObj *pVnode = dndAcquireVnode(pDnode, pCreate->vgId);
   if (pVnode != NULL) {
     dDebug("vgId:%d, already exist", pCreate->vgId);
diff --git a/source/dnode/mgmt/impl/test/sut/src/client.cpp b/source/dnode/mgmt/impl/test/sut/src/client.cpp
index 3d61db8268..8403dbf034 100644
--- a/source/dnode/mgmt/impl/test/sut/src/client.cpp
+++ b/source/dnode/mgmt/impl/test/sut/src/client.cpp
@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "tep.h"
 #include "sut.h"
 
 static void processClientRsp(void* parent, SRpcMsg* pRsp, SEpSet* pEpSet) {
@@ -61,11 +62,7 @@ void TestClient::Cleanup() {
 
 SRpcMsg* TestClient::SendReq(SRpcMsg* pReq) {
   SEpSet epSet = {0};
-  epSet.inUse = 0;
-  epSet.numOfEps = 1;
-  epSet.port[0] = port;
-  memcpy(epSet.fqdn[0], fqdn, TSDB_FQDN_LEN);
-
+  addEpIntoEpSet(&epSet, fqdn, port);
   rpcSendRequest(clientRpc, &epSet, pReq, NULL);
   tsem_wait(&sem);
 
diff --git a/source/dnode/mgmt/impl/test/vnode/vnode.cpp b/source/dnode/mgmt/impl/test/vnode/vnode.cpp
index 1799bf66b0..17092ed737 100644
--- a/source/dnode/mgmt/impl/test/vnode/vnode.cpp
+++ b/source/dnode/mgmt/impl/test/vnode/vnode.cpp
@@ -68,6 +68,44 @@ TEST_F(DndTestVnode, 01_Create_Vnode) {
       ASSERT_EQ(pRsp->code, TSDB_CODE_DND_VNODE_ALREADY_DEPLOYED);
     }
   }
+
+  {
+    int32_t contLen = sizeof(SCreateVnodeReq);
+
+    SCreateVnodeReq* pReq = (SCreateVnodeReq*)rpcMallocCont(contLen);
+    pReq->vgId = htonl(2);
+    pReq->dnodeId = htonl(3);
+    strcpy(pReq->db, "1.d1");
+    pReq->dbUid = htobe64(9527);
+    pReq->vgVersion = htonl(1);
+    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->minRows = htonl(100);
+    pReq->minRows = htonl(4096);
+    pReq->commitTime = htonl(3600);
+    pReq->fsyncPeriod = htonl(3000);
+    pReq->walLevel = 1;
+    pReq->precision = 0;
+    pReq->compression = 2;
+    pReq->replica = 1;
+    pReq->quorum = 1;
+    pReq->update = 0;
+    pReq->cacheLastRow = 0;
+    pReq->selfIndex = 0;
+    for (int r = 0; r < pReq->replica; ++r) {
+      SReplica* pReplica = &pReq->replicas[r];
+      pReplica->id = htonl(1);
+      pReplica->port = htons(9527);
+    }
+
+    SRpcMsg* pRsp = test.SendReq(TDMT_DND_CREATE_VNODE, pReq, contLen);
+    ASSERT_NE(pRsp, nullptr);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_DND_VNODE_INVALID_OPTION);
+  }
 }
 
 TEST_F(DndTestVnode, 02_ALTER_Vnode) {
diff --git a/source/dnode/mnode/impl/inc/mndDb.h b/source/dnode/mnode/impl/inc/mndDb.h
index 91f502be7d..5a3e6ed26e 100644
--- a/source/dnode/mnode/impl/inc/mndDb.h
+++ b/source/dnode/mnode/impl/inc/mndDb.h
@@ -26,6 +26,7 @@ int32_t mndInitDb(SMnode *pMnode);
 void    mndCleanupDb(SMnode *pMnode);
 SDbObj *mndAcquireDb(SMnode *pMnode, char *db);
 void    mndReleaseDb(SMnode *pMnode, SDbObj *pDb);
+int32_t mndValidateDBInfo(SMnode *pMnode, SDbVgVersion *dbs, int32_t num, void **rsp, int32_t *rspLen);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h
index 891f731a42..9cce25ed6a 100644
--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@@ -128,6 +128,8 @@ typedef struct {
   int32_t    failedTimes;
   void*      rpcHandle;
   void*      rpcAHandle;
+  void*      rpcRsp;
+  int32_t    rpcRspLen;
   SArray*    redoLogs;
   SArray*    undoLogs;
   SArray*    commitLogs;
diff --git a/source/dnode/mnode/impl/inc/mndTrans.h b/source/dnode/mnode/impl/inc/mndTrans.h
index fda3fed13d..f1a213790c 100644
--- a/source/dnode/mnode/impl/inc/mndTrans.h
+++ b/source/dnode/mnode/impl/inc/mndTrans.h
@@ -36,16 +36,17 @@ typedef struct {
 int32_t mndInitTrans(SMnode *pMnode);
 void    mndCleanupTrans(SMnode *pMnode);
 
-STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, SRpcMsg *pMsg);
+STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, const SRpcMsg *pReq);
 void    mndTransDrop(STrans *pTrans);
 int32_t mndTransAppendRedolog(STrans *pTrans, SSdbRaw *pRaw);
 int32_t mndTransAppendUndolog(STrans *pTrans, SSdbRaw *pRaw);
 int32_t mndTransAppendCommitlog(STrans *pTrans, SSdbRaw *pRaw);
 int32_t mndTransAppendRedoAction(STrans *pTrans, STransAction *pAction);
 int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction);
+void    mndTransSetRpcRsp(STrans *pTrans, void *pCont, int32_t contLen);
 
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);
-void    mndTransProcessRsp(SMnodeMsg *pMsg);
+void    mndTransProcessRsp(SMnodeMsg *pRsp);
 void    mndTransPullup(SMnode *pMnode);
 
 #ifdef __cplusplus
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 39be41a4e5..5e6f457a67 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -226,10 +226,10 @@ static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
   if (pCfg->cacheBlockSize < TSDB_MIN_CACHE_BLOCK_SIZE || pCfg->cacheBlockSize > TSDB_MAX_CACHE_BLOCK_SIZE) return -1;
   if (pCfg->totalBlocks < TSDB_MIN_TOTAL_BLOCKS || pCfg->totalBlocks > TSDB_MAX_TOTAL_BLOCKS) return -1;
   if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return -1;
-  if (pCfg->daysToKeep0 < pCfg->daysPerFile) return -1;
   if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) return -1;
   if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP) return -1;
   if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > TSDB_MAX_KEEP) return -1;
+  if (pCfg->daysToKeep0 < pCfg->daysPerFile) return -1;
   if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return -1;
   if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return -1;
   if (pCfg->minRows < TSDB_MIN_MIN_ROW_FBLOCK || pCfg->minRows > TSDB_MAX_MIN_ROW_FBLOCK) return -1;
@@ -498,7 +498,7 @@ static int32_t mndProcessCreateDbReq(SMnodeMsg *pReq) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
-static int32_t mndSetDbCfgFromAlterDbMsg(SDbObj *pDb, SAlterDbReq *pAlter) {
+static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
   terrno = TSDB_CODE_MND_DB_OPTION_UNCHANGED;
 
   if (pAlter->totalBlocks >= 0 && pAlter->totalBlocks != pDb->cfg.totalBlocks) {
@@ -649,7 +649,7 @@ static int32_t mndProcessAlterDbReq(SMnodeMsg *pReq) {
   SDbObj dbObj = {0};
   memcpy(&dbObj, pDb, sizeof(SDbObj));
 
-  int32_t code = mndSetDbCfgFromAlterDbMsg(&dbObj, pAlter);
+  int32_t code = mndSetDbCfgFromAlterDbReq(&dbObj, pAlter);
   if (code != 0) {
     mndReleaseDb(pMnode, pDb);
     mError("db:%s, failed to alter since %s", pAlter->db, tstrerror(code));
@@ -767,6 +767,14 @@ static int32_t mndDropDb(SMnode *pMnode, SMnodeMsg *pReq, SDbObj *pDb) {
   if (mndSetDropDbRedoLogs(pMnode, pTrans, pDb) != 0) goto DROP_DB_OVER;
   if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) goto DROP_DB_OVER;
   if (mndSetDropDbRedoActions(pMnode, pTrans, pDb) != 0) goto DROP_DB_OVER;
+
+  int32_t     rspLen = sizeof(SDropDbRsp);
+  SDropDbRsp *pRsp = rpcMallocCont(rspLen);
+  if (pRsp == NULL) goto DROP_DB_OVER;
+  memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
+  pRsp->uid = htobe64(pDb->uid);
+  mndTransSetRpcRsp(pTrans, pRsp, rspLen);
+
   if (mndTransPrepare(pMnode, pTrans) != 0) goto DROP_DB_OVER;
 
   code = 0;
@@ -805,6 +813,44 @@ static int32_t mndProcessDropDbReq(SMnodeMsg *pReq) {
   return TSDB_CODE_MND_ACTION_IN_PROGRESS;
 }
 
+static void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SVgroupInfo *vgList, int32_t *vgNum) {
+  int32_t vindex = 0;
+  SSdb *pSdb = pMnode->pSdb;
+
+  void *pIter = NULL;
+  while (vindex < pDb->cfg.numOfVgroups) {
+    SVgObj *pVgroup = NULL;
+    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
+    if (pIter == NULL) break;
+
+    if (pVgroup->dbUid == pDb->uid) {
+      SVgroupInfo *pInfo = &vgList[vindex];
+      pInfo->vgId = htonl(pVgroup->vgId);
+      pInfo->hashBegin = htonl(pVgroup->hashBegin);
+      pInfo->hashEnd = htonl(pVgroup->hashEnd);
+      pInfo->epset.numOfEps = pVgroup->replica;
+      for (int32_t gid = 0; gid < pVgroup->replica; ++gid) {
+        SVnodeGid  *pVgid = &pVgroup->vnodeGid[gid];
+        SEp *       pEp = &pInfo->epset.eps[gid];
+        SDnodeObj  *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
+        if (pDnode != NULL) {
+          memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
+          pEp->port = htons(pDnode->port);
+        }
+        mndReleaseDnode(pMnode, pDnode);
+        if (pVgid->role == TAOS_SYNC_STATE_LEADER) {
+          pInfo->epset.inUse = gid;
+        }
+      }
+      vindex++;
+    }
+
+    sdbRelease(pSdb, pVgroup);
+  }
+
+  *vgNum = vindex;
+}
+
 static int32_t mndProcessUseDbReq(SMnodeMsg *pReq) {
   SMnode    *pMnode = pReq->pMnode;
   SSdb      *pSdb = pMnode->pSdb;
@@ -826,45 +872,16 @@ static int32_t mndProcessUseDbReq(SMnodeMsg *pReq) {
     return -1;
   }
 
-  int32_t vindex = 0;
+  int32_t vgNum = 0;
 
   if (pUse->vgVersion < pDb->vgVersion) {
-    void *pIter = NULL;
-    while (vindex < pDb->cfg.numOfVgroups) {
-      SVgObj *pVgroup = NULL;
-      pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
-      if (pIter == NULL) break;
-
-      if (pVgroup->dbUid == pDb->uid) {
-        SVgroupInfo *pInfo = &pRsp->vgroupInfo[vindex];
-        pInfo->vgId = htonl(pVgroup->vgId);
-        pInfo->hashBegin = htonl(pVgroup->hashBegin);
-        pInfo->hashEnd = htonl(pVgroup->hashEnd);
-        pInfo->numOfEps = pVgroup->replica;
-        for (int32_t gid = 0; gid < pVgroup->replica; ++gid) {
-          SVnodeGid  *pVgid = &pVgroup->vnodeGid[gid];
-          SEpAddr *pEpArrr = &pInfo->epAddr[gid];
-          SDnodeObj  *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
-          if (pDnode != NULL) {
-            memcpy(pEpArrr->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
-            pEpArrr->port = htons(pDnode->port);
-          }
-          mndReleaseDnode(pMnode, pDnode);
-          if (pVgid->role == TAOS_SYNC_STATE_LEADER) {
-            pInfo->inUse = gid;
-          }
-        }
-        vindex++;
-      }
-
-      sdbRelease(pSdb, pVgroup);
-    }
+    mndBuildDBVgroupInfo(pDb, pMnode, pRsp->vgroupInfo, &vgNum);
   }
 
   memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
   pRsp->uid = htobe64(pDb->uid);
   pRsp->vgVersion = htonl(pDb->vgVersion);
-  pRsp->vgNum = htonl(vindex);
+  pRsp->vgNum = htonl(vgNum);
   pRsp->hashMethod = pDb->hashMethod;
 
   pReq->pCont = pRsp;
@@ -874,6 +891,77 @@ static int32_t mndProcessUseDbReq(SMnodeMsg *pReq) {
   return 0;
 }
 
+int32_t mndValidateDBInfo(SMnode *pMnode, SDbVgVersion *dbs, int32_t num, void **rsp, int32_t *rspLen) {
+  SSdb *pSdb = pMnode->pSdb;
+  int32_t bufSize = num * (sizeof(SUseDbRsp) + TSDB_DEFAULT_VN_PER_DB * sizeof(SVgroupInfo));
+  void *buf = malloc(bufSize);
+  int32_t len = 0;
+  int32_t contLen = 0;
+  int32_t bufOffset = 0;
+  SUseDbRsp *pRsp = NULL;
+
+  for (int32_t i = 0; i < num; ++i) {
+    SDbVgVersion *db = &dbs[i];
+    db->dbId = be64toh(db->dbId);
+    db->vgVersion = ntohl(db->vgVersion);
+
+    len = 0;
+    
+    SDbObj *pDb = mndAcquireDb(pMnode, db->dbName);
+    if (pDb == NULL) {
+      mInfo("db %s not exist", db->dbName);
+      
+      len = sizeof(SUseDbRsp);
+    } else if (pDb->uid != db->dbId || db->vgVersion < pDb->vgVersion) {
+      len = sizeof(SUseDbRsp) + pDb->cfg.numOfVgroups * sizeof(SVgroupInfo);
+    }
+
+    if (0 == len) {
+      mndReleaseDb(pMnode, pDb);
+      
+      continue;
+    }
+    
+    contLen += len;
+    
+    if (contLen > bufSize) {
+      buf = realloc(buf, contLen);
+    }
+    
+    pRsp = (SUseDbRsp *)((char *)buf + bufOffset);
+    memcpy(pRsp->db, db->dbName, TSDB_DB_FNAME_LEN);
+    if (pDb) {
+      int32_t vgNum = 0;
+      mndBuildDBVgroupInfo(pDb, pMnode, pRsp->vgroupInfo, &vgNum);
+
+      pRsp->uid = htobe64(pDb->uid);
+      pRsp->vgVersion = htonl(pDb->vgVersion);
+      pRsp->vgNum = htonl(vgNum);
+      pRsp->hashMethod = pDb->hashMethod;
+    } else {
+      pRsp->uid = htobe64(db->dbId);
+      pRsp->vgNum = htonl(0);
+      pRsp->hashMethod = 0;
+      pRsp->vgVersion = htonl(-1);
+    }
+
+    bufOffset += len;
+    
+    mndReleaseDb(pMnode, pDb);
+  }
+
+  if (contLen > 0) {
+    *rsp = buf;
+    *rspLen = contLen;
+  } else {
+    *rsp = NULL;
+    tfree(buf);
+    *rspLen = 0;
+  }
+
+  return 0;
+}
+
 static int32_t mndProcessSyncDbReq(SMnodeMsg *pReq) {
   SMnode     *pMnode = pReq->pMnode;
   SSyncDbReq *pSync = pReq->rpcMsg.pCont;
@@ -1143,7 +1231,7 @@ static int32_t mndRetrieveDbs(SMnodeMsg *pReq, SShowObj *pShow, char *data, int3
         prec = TSDB_TIME_PRECISION_NANO_STR;
         break;
       default:
-        assert(false);
+        prec = "none";
         break;
     }
     STR_WITH_SIZE_TO_VARSTR(pWrite, prec, 2);
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index efdacf957b..9a96bdb0df 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -203,8 +203,8 @@ void mndReleaseDnode(SMnode *pMnode, SDnodeObj *pDnode) {
 }
 
 SEpSet mndGetDnodeEpset(SDnodeObj *pDnode) {
-  SEpSet epSet = {.inUse = 0, .numOfEps = 1, .port[0] = pDnode->port};
-  memcpy(epSet.fqdn[0], pDnode->fqdn, TSDB_FQDN_LEN);
+  SEpSet epSet = {0};
+  addEpIntoEpSet(&epSet, pDnode->fqdn, pDnode->port);
   return epSet;
 }
 
@@ -261,8 +261,8 @@ static void mndGetDnodeData(SMnode *pMnode, SDnodeEps *pEps, int32_t maxEps) {
 
     SDnodeEp *pEp = &pEps->eps[numOfEps];
     pEp->id = htonl(pDnode->id);
-    pEp->port = htons(pDnode->port);
-    memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
+    pEp->ep.port = htons(pDnode->port);
+    memcpy(pEp->ep.fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
     pEp->isMnode = 0;
     if (mndIsMnode(pMnode, pDnode->id)) {
       pEp->isMnode = 1;
diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c
index f9dde7bc75..0e086fdb22 100644
--- a/source/dnode/mnode/impl/src/mndFunc.c
+++ b/source/dnode/mnode/impl/src/mndFunc.c
@@ -20,6 +20,7 @@
 #include "mndTrans.h"
 
 #define SDB_FUNC_VER 1
+#define SDB_FUNC_RESERVE_SIZE 64
 
 static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc);
 static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw);
@@ -60,7 +61,7 @@ void mndCleanupFunc(SMnode *pMnode) {}
 static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) {
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
-  int32_t  size = pFunc->commentSize + pFunc->codeSize + sizeof(SFuncObj);
+  int32_t  size = pFunc->commentSize + pFunc->codeSize + sizeof(SFuncObj) + SDB_FUNC_RESERVE_SIZE;
   SSdbRaw *pRaw = sdbAllocRaw(SDB_FUNC, SDB_FUNC_VER, size);
   if (pRaw == NULL) goto FUNC_ENCODE_OVER;
 
@@ -78,6 +79,7 @@ static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) {
   SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, FUNC_ENCODE_OVER)
   SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_ENCODE_OVER)
   SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_ENCODE_OVER)
+  SDB_SET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_ENCODE_OVER)
   SDB_SET_DATALEN(pRaw, dataPos, FUNC_ENCODE_OVER);
 
   terrno = 0;
@@ -131,6 +133,7 @@ static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
 
   SDB_GET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_DECODE_OVER)
   SDB_GET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_DECODE_OVER)
+  SDB_GET_RESERVE(pRaw, dataPos, SDB_FUNC_RESERVE_SIZE, FUNC_DECODE_OVER)
 
   terrno = 0;
 
diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c
index 75ed5b0a1e..a969c0162f 100644
--- a/source/dnode/mnode/impl/src/mndMnode.c
+++ b/source/dnode/mnode/impl/src/mndMnode.c
@@ -237,13 +237,11 @@ void mndGetMnodeEpSet(SMnode *pMnode, SEpSet *pEpSet) {
     if (pIter == NULL) break;
     if (pObj->pDnode == NULL) break;
 
-    pEpSet->port[pEpSet->numOfEps] = htons(pObj->pDnode->port);
-    memcpy(pEpSet->fqdn[pEpSet->numOfEps], pObj->pDnode->fqdn, TSDB_FQDN_LEN);
     if (pObj->role == TAOS_SYNC_STATE_LEADER) {
       pEpSet->inUse = pEpSet->numOfEps;
     }
 
-    pEpSet->numOfEps++;
+    addEpIntoEpSet(pEpSet, pObj->pDnode->fqdn, htons(pObj->pDnode->port));
     sdbRelease(pSdb, pObj);
   }
 }
diff --git a/source/dnode/mnode/impl/src/mndProfile.c b/source/dnode/mnode/impl/src/mndProfile.c
index 76fabc96ce..d379d294ab 100644
--- a/source/dnode/mnode/impl/src/mndProfile.c
+++ b/source/dnode/mnode/impl/src/mndProfile.c
@@ -14,14 +14,15 @@
  */
 
 #define _DEFAULT_SOURCE
+#include "tglobal.h"
 #include "mndProfile.h"
-#include "mndConsumer.h"
+//#include "mndConsumer.h"
 #include "mndDb.h"
 #include "mndMnode.h"
 #include "mndShow.h"
-#include "mndTopic.h"
+//#include "mndTopic.h"
 #include "mndUser.h"
-#include "mndVgroup.h"
+//#include "mndVgroup.h"
 
 #define QUERY_ID_SIZE 20
 #define QUERY_OBJ_ID_SIZE 18
@@ -230,10 +231,12 @@ static int32_t mndProcessConnectReq(SMnodeMsg *pReq) {
     goto CONN_OVER;
   }
 
-  pRsp->acctId = htonl(pUser->acctId);
+  pRsp->acctId    = htonl(pUser->acctId);
   pRsp->superUser = pUser->superUser;
   pRsp->clusterId = htobe64(pMnode->clusterId);
-  pRsp->connId = htonl(pConn->id);
+  pRsp->connId    = htonl(pConn->id);
+
+  snprintf(pRsp->sVersion, tListLen(pRsp->sVersion), "ver:%s\nbuild:%s\ngitinfo:%s", version, buildinfo, gitinfo);
   mndGetMnodeEpSet(pMnode, &pRsp->epSet);
 
   pReq->contLen = sizeof(SConnectRsp);
@@ -351,7 +354,41 @@ static int32_t mndProcessHeartBeatReq(SMnodeMsg *pReq) {
   for (int i = 0; i < sz; i++) {
     SClientHbReq* pHbReq = taosArrayGet(pArray, i);
     if (pHbReq->connKey.hbType == HEARTBEAT_TYPE_QUERY) {
+      int32_t kvNum = taosHashGetSize(pHbReq->info);
+      if (NULL == pHbReq->info || kvNum <= 0) {
+        continue;
+      }
 
+      SClientHbRsp hbRsp = {.connKey = pHbReq->connKey, .status = 0, .info = taosArrayInit(kvNum, sizeof(SKv))};
+
+      void *pIter = taosHashIterate(pHbReq->info, NULL);
+      while (pIter != NULL) {
+        SKv* kv = pIter;
+      
+        switch (kv->key) {
+          case HEARTBEAT_KEY_DBINFO: {
+            void *rspMsg = NULL;
+            int32_t rspLen = 0;
+            mndValidateDBInfo(pMnode, (SDbVgVersion *)kv->value, kv->valueLen/sizeof(SDbVgVersion), &rspMsg, &rspLen);
+            if (rspMsg && rspLen > 0) {
+              SKv kv = {.key = HEARTBEAT_KEY_DBINFO, .valueLen = rspLen, .value = rspMsg};
+              taosArrayPush(hbRsp.info, &kv);
+            }
+            break;
+          }
+          case HEARTBEAT_KEY_STBINFO:
+
+            break;
+          default:
+            mError("invalid kv key:%d", kv->key);
+            hbRsp.status = TSDB_CODE_MND_APP_ERROR;
+            break;
+        }
+              
+        pIter = taosHashIterate(pHbReq->info, pIter);
+      }
+
+      taosArrayPush(batchRsp.rsps, &hbRsp);
     } else if (pHbReq->connKey.hbType == HEARTBEAT_TYPE_MQ) {
       SClientHbRsp *pRsp = mndMqHbBuildRsp(pMnode, pHbReq);
       if (pRsp != NULL) {
@@ -366,6 +403,18 @@ static int32_t mndProcessHeartBeatReq(SMnodeMsg *pReq) {
   void* buf = rpcMallocCont(tlen);
   void* abuf = buf;
   tSerializeSClientHbBatchRsp(&abuf, &batchRsp);
+  
+  int32_t rspNum = (int32_t)taosArrayGetSize(batchRsp.rsps);
+  for (int32_t i = 0; i < rspNum; ++i) {
+    SClientHbRsp *rsp = taosArrayGet(batchRsp.rsps, i);
+    int32_t kvNum = (rsp->info) ? taosArrayGetSize(rsp->info): 0;
+    for (int32_t n = 0; n < kvNum; ++n) {
+      SKv *kv = taosArrayGet(rsp->info, n);
+      tfree(kv->value);
+    }
+    taosArrayDestroy(rsp->info);
+  }
+
   taosArrayDestroy(batchRsp.rsps);
   pReq->contLen = tlen;
   pReq->pCont = buf;
diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c
index 82173833ab..0c0d8bd349 100644
--- a/source/dnode/mnode/impl/src/mndSubscribe.c
+++ b/source/dnode/mnode/impl/src/mndSubscribe.c
@@ -273,12 +273,11 @@ static int mndInitUnassignedVg(SMnode *pMnode, SMqTopicObj *pTopic, SArray *unas
   SArray    *inner = taosArrayGet(pDag->pSubplans, 0);
   SSubplan  *plan = taosArrayGetP(inner, 0);
 
-  plan->execNode.inUse = 0;
-  strcpy(plan->execNode.epAddr[0].fqdn, "localhost");
-  plan->execNode.epAddr[0].port = 6030;
   plan->execNode.nodeId = 2;
-  plan->execNode.numOfEps = 1;
+  SEpSet* pEpSet = &plan->execNode.epset;
 
+  pEpSet->inUse = 0;
+  addEpIntoEpSet(pEpSet, "localhost", 6030);
   if (schedulerConvertDagToTaskList(pDag, &pArray) < 0) {
     return -1;
   }
@@ -290,7 +289,8 @@ static int mndInitUnassignedVg(SMnode *pMnode, SMqTopicObj *pTopic, SArray *unas
     CEp.consumerId = -1;
     CEp.lastConsumerHbTs = CEp.lastVgHbTs = -1;
     STaskInfo *pTaskInfo = taosArrayGet(pArray, i);
-    tConvertQueryAddrToEpSet(&CEp.epSet, &pTaskInfo->addr);
+    CEp.epSet = pTaskInfo->addr.epset;
+    
     /*mDebug("subscribe convert ep %d %s %s %s %s %s\n", CEp.epSet.numOfEps, CEp.epSet.fqdn[0], CEp.epSet.fqdn[1],
      * CEp.epSet.fqdn[2], CEp.epSet.fqdn[3], CEp.epSet.fqdn[4]);*/
     CEp.vgId = pTaskInfo->addr.nodeId;
diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c
index 808e6dcbe5..6686c0887f 100644
--- a/source/dnode/mnode/impl/src/mndTrans.c
+++ b/source/dnode/mnode/impl/src/mndTrans.c
@@ -308,6 +308,11 @@ static void mndTransDropData(STrans *pTrans) {
   mndTransDropLogs(pTrans->commitLogs);
   mndTransDropActions(pTrans->redoActions);
   mndTransDropActions(pTrans->undoActions);
+  if (pTrans->rpcRsp != NULL) {
+    rpcFreeCont(pTrans->rpcRsp);
+    pTrans->rpcRsp = NULL;
+    pTrans->rpcRspLen = 0;
+  }
 }
 
 static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans) {
@@ -339,7 +344,7 @@ void mndReleaseTrans(SMnode *pMnode, STrans *pTrans) {
   sdbRelease(pSdb, pTrans);
 }
 
-STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, SRpcMsg *pMsg) {
+STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, const SRpcMsg *pReq) {
   STrans *pTrans = calloc(1, sizeof(STrans));
   if (pTrans == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -350,8 +355,8 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, SRpcMsg *pMsg) {
   pTrans->id = sdbGetMaxId(pMnode->pSdb, SDB_TRANS);
   pTrans->stage = TRN_STAGE_PREPARE;
   pTrans->policy = policy;
-  pTrans->rpcHandle = pMsg->handle;
-  pTrans->rpcAHandle = pMsg->ahandle;
+  pTrans->rpcHandle = pReq->handle;
+  pTrans->rpcAHandle = pReq->ahandle;
   pTrans->redoLogs = taosArrayInit(MND_TRANS_ARRAY_SIZE, sizeof(void *));
   pTrans->undoLogs = taosArrayInit(MND_TRANS_ARRAY_SIZE, sizeof(void *));
   pTrans->commitLogs = taosArrayInit(MND_TRANS_ARRAY_SIZE, sizeof(void *));
@@ -436,6 +441,11 @@ int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction) {
   return mndTransAppendAction(pTrans->undoActions, pAction);
 }
 
+void mndTransSetRpcRsp(STrans *pTrans, void *pCont, int32_t contLen) {
+  pTrans->rpcRsp = pCont;
+  pTrans->rpcRspLen = contLen;
+}
+
 static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) {
   SSdbRaw *pRaw = mndTransActionEncode(pTrans);
   if (pRaw == NULL) {
@@ -479,6 +489,11 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
 
   pNew->rpcHandle = pTrans->rpcHandle;
   pNew->rpcAHandle = pTrans->rpcAHandle;
+  pNew->rpcRsp = pTrans->rpcRsp;
+  pNew->rpcRspLen = pTrans->rpcRspLen;
+  pTrans->rpcRsp = NULL;
+  pTrans->rpcRspLen = 0;
+
   mndTransExecute(pMnode, pNew);
   mndReleaseTrans(pMnode, pNew);
   return 0;
@@ -529,15 +544,21 @@ static void mndTransSendRpcRsp(STrans *pTrans) {
   if (sendRsp && pTrans->rpcHandle != NULL) {
     mDebug("trans:%d, send rsp, code:0x%x stage:%d app:%p", pTrans->id, pTrans->code & 0xFFFF, pTrans->stage,
            pTrans->rpcAHandle);
-    SRpcMsg rspMsg = {.handle = pTrans->rpcHandle, .code = pTrans->code, .ahandle = pTrans->rpcAHandle};
+    SRpcMsg rspMsg = {.handle = pTrans->rpcHandle,
+                      .code = pTrans->code,
+                      .ahandle = pTrans->rpcAHandle,
+                      .pCont = pTrans->rpcRsp,
+                      .contLen = pTrans->rpcRspLen};
     rpcSendResponse(&rspMsg);
     pTrans->rpcHandle = NULL;
+    pTrans->rpcRsp = NULL;
+    pTrans->rpcRspLen = 0;
   }
 }
 
-void mndTransProcessRsp(SMnodeMsg *pMsg) {
-  SMnode *pMnode = pMsg->pMnode;
-  int64_t signature = (int64_t)(pMsg->rpcMsg.ahandle);
+void mndTransProcessRsp(SMnodeMsg *pRsp) {
+  SMnode *pMnode = pRsp->pMnode;
+  int64_t signature = (int64_t)(pRsp->rpcMsg.ahandle);
   int32_t transId = (int32_t)(signature >> 32);
   int32_t action = (int32_t)((signature << 32) >> 32);
 
@@ -571,10 +592,10 @@ void mndTransProcessRsp(SMnodeMsg *pMsg) {
   STransAction *pAction = taosArrayGet(pArray, action);
   if (pAction != NULL) {
     pAction->msgReceived = 1;
-    pAction->errCode = pMsg->rpcMsg.code;
+    pAction->errCode = pRsp->rpcMsg.code;
   }
 
-  mDebug("trans:%d, action:%d response is received, code:0x%x, accept:0x%x", transId, action, pMsg->rpcMsg.code,
+  mDebug("trans:%d, action:%d response is received, code:0x%x, accept:0x%x", transId, action, pRsp->rpcMsg.code,
          pAction->acceptableCode);
   mndTransExecute(pMnode, pTrans);
 
@@ -921,7 +942,7 @@ static int32_t mndProcessTransMsg(SMnodeMsg *pMsg) {
 
 void mndTransPullup(SMnode *pMnode) {
   STrans *pTrans = NULL;
-  void *  pIter = NULL;
+  void   *pIter = NULL;
 
   while (1) {
     pIter = sdbFetch(pMnode->pSdb, SDB_TRANS, pIter, (void **)&pTrans);
diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c
index 04fedbb3ce..01d39ebdc2 100644
--- a/source/dnode/mnode/impl/src/mndVgroup.c
+++ b/source/dnode/mnode/impl/src/mndVgroup.c
@@ -178,7 +178,7 @@ static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOld, SVgObj *pNew) {
 SVgObj *mndAcquireVgroup(SMnode *pMnode, int32_t vgId) {
   SSdb   *pSdb = pMnode->pSdb;
   SVgObj *pVgroup = sdbAcquire(pSdb, SDB_VGROUP, &vgId);
-  if (pVgroup == NULL) {
+  if (pVgroup == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
     terrno = TSDB_CODE_MND_VGROUP_NOT_EXIST;
   }
   return pVgroup;
@@ -424,9 +424,7 @@ SEpSet mndGetVgroupEpset(SMnode *pMnode, SVgObj *pVgroup) {
       epset.inUse = epset.numOfEps;
     }
 
-    epset.port[epset.numOfEps] = pDnode->port;
-    memcpy(&epset.fqdn[epset.numOfEps], pDnode->fqdn, TSDB_FQDN_LEN);
-    epset.numOfEps++;
+    addEpIntoEpSet(&epset, pDnode->fqdn, pDnode->port);
     mndReleaseDnode(pMnode, pDnode);
   }
 
diff --git a/source/dnode/mnode/impl/test/db/db.cpp b/source/dnode/mnode/impl/test/db/db.cpp
index 5d5947b644..2d1574467e 100644
--- a/source/dnode/mnode/impl/test/db/db.cpp
+++ b/source/dnode/mnode/impl/test/db/db.cpp
@@ -202,6 +202,10 @@ TEST_F(MndTestDb, 02_Create_Alter_Drop_Db) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+
+    SDropDbRsp* pDrop = (SDropDbRsp*)pRsp->pCont;
+    pDrop->uid = htobe64(pDrop->uid);
+    EXPECT_STREQ(pDrop->db, "1.d1");
   }
 
   test.SendShowMetaReq(TSDB_MGMT_TABLE_DB, "");
@@ -249,6 +253,8 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
   EXPECT_EQ(test.GetShowRows(), 1);
   CheckBinary("d2", TSDB_DB_NAME_LEN - 1);
 
+  uint64_t d2_uid = 0;
+
   {
     int32_t contLen = sizeof(SUseDbReq);
 
@@ -262,6 +268,8 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
 
     SUseDbRsp* pRsp = (SUseDbRsp*)pMsg->pCont;
     EXPECT_STREQ(pRsp->db, "1.d2");
+    pRsp->uid = htobe64(pRsp->uid);
+    d2_uid = pRsp->uid;
     pRsp->vgVersion = htonl(pRsp->vgVersion);
     pRsp->vgNum = htonl(pRsp->vgNum);
     pRsp->hashMethod = pRsp->hashMethod;
@@ -277,9 +285,9 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
       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);
-      SEpAddr* pAddr = &pInfo->epAddr[0];
+      EXPECT_EQ(pInfo->epset.inUse, 0);
+      EXPECT_EQ(pInfo->epset.numOfEps, 1);
+      SEp* pAddr = &pInfo->epset.eps[0];
       pAddr->port = htons(pAddr->port);
       EXPECT_EQ(pAddr->port, 9030);
       EXPECT_STREQ(pAddr->fqdn, "localhost");
@@ -293,9 +301,9 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
       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);
-      SEpAddr* pAddr = &pInfo->epAddr[0];
+      EXPECT_EQ(pInfo->epset.inUse, 0);
+      EXPECT_EQ(pInfo->epset.numOfEps, 1);
+      SEp* pAddr = &pInfo->epset.eps[0];
       pAddr->port = htons(pAddr->port);
       EXPECT_EQ(pAddr->port, 9030);
       EXPECT_STREQ(pAddr->fqdn, "localhost");
@@ -311,5 +319,10 @@ TEST_F(MndTestDb, 03_Create_Use_Restart_Use_Db) {
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_DROP_DB, pReq, contLen);
     ASSERT_NE(pRsp, nullptr);
     ASSERT_EQ(pRsp->code, 0);
+
+    SDropDbRsp* pDrop = (SDropDbRsp*)pRsp->pCont;
+    pDrop->uid = htobe64(pDrop->uid);
+    EXPECT_STREQ(pDrop->db, "1.d2");
+    EXPECT_EQ(pDrop->uid, d2_uid);
   }
 }
diff --git a/source/dnode/mnode/impl/test/profile/profile.cpp b/source/dnode/mnode/impl/test/profile/profile.cpp
index 4ad979cdd3..ccf13d5d66 100644
--- a/source/dnode/mnode/impl/test/profile/profile.cpp
+++ b/source/dnode/mnode/impl/test/profile/profile.cpp
@@ -44,7 +44,7 @@ TEST_F(MndTestProfile, 01_ConnectMsg) {
   pRsp->acctId = htonl(pRsp->acctId);
   pRsp->clusterId = htobe64(pRsp->clusterId);
   pRsp->connId = htonl(pRsp->connId);
-  pRsp->epSet.port[0] = htons(pRsp->epSet.port[0]);
+  pRsp->epSet.eps[0].port = htons(pRsp->epSet.eps[0].port);
 
   EXPECT_EQ(pRsp->acctId, 1);
   EXPECT_GT(pRsp->clusterId, 0);
@@ -53,8 +53,8 @@ TEST_F(MndTestProfile, 01_ConnectMsg) {
 
   EXPECT_EQ(pRsp->epSet.inUse, 0);
   EXPECT_EQ(pRsp->epSet.numOfEps, 1);
-  EXPECT_EQ(pRsp->epSet.port[0], 9031);
-  EXPECT_STREQ(pRsp->epSet.fqdn[0], "localhost");
+  EXPECT_EQ(pRsp->epSet.eps[0].port, 9031);
+  EXPECT_STREQ(pRsp->epSet.eps[0].fqdn, "localhost");
 
   connId = pRsp->connId;
 }
@@ -102,11 +102,10 @@ TEST_F(MndTestProfile, 04_HeartBeatMsg) {
   req.connKey = {.connId = 123, .hbType = HEARTBEAT_TYPE_MQ};
   req.info = taosHashInit(64, hbKeyHashFunc, 1, HASH_ENTRY_LOCK);
   SKv kv;
-  kv.key = (void*)"abc";
-  kv.keyLen = 4;
+  kv.key = 123;
   kv.value = (void*)"bcd";
   kv.valueLen = 4;
-  taosHashPut(req.info, kv.key, kv.keyLen, kv.value, kv.valueLen);
+  taosHashPut(req.info, &kv.key, sizeof(kv.key), &kv, sizeof(kv));
   taosArrayPush(batchReq.reqs, &req);
 
   int32_t tlen = tSerializeSClientHbBatchReq(NULL, &batchReq);
diff --git a/source/dnode/vnode/src/meta/metaBDBImpl.c b/source/dnode/vnode/src/meta/metaBDBImpl.c
index dfdc144750..e5ccd02e48 100644
--- a/source/dnode/vnode/src/meta/metaBDBImpl.c
+++ b/source/dnode/vnode/src/meta/metaBDBImpl.c
@@ -20,6 +20,10 @@
 #include "tcoding.h"
 #include "thash.h"
 
+#define IMPL_WITH_LOCK 1
+// #if IMPL_WITH_LOCK
+// #endif
+
 typedef struct {
   tb_uid_t uid;
   int32_t  sver;
@@ -27,6 +31,9 @@ typedef struct {
 } SSchemaKey;
 
 struct SMetaDB {
+#if IMPL_WITH_LOCK
+  pthread_rwlock_t rwlock;
+#endif
   // DB
   DB *pTbDB;
   DB *pSchemaDB;
@@ -58,6 +65,9 @@ static void *   metaDecodeTbInfo(void *buf, STbCfg *pTbCfg);
 static void     metaClearTbCfg(STbCfg *pTbCfg);
 static int      metaEncodeSchema(void **buf, SSchemaWrapper *pSW);
 static void *   metaDecodeSchema(void *buf, SSchemaWrapper *pSW);
+static void     metaDBWLock(SMetaDB *pDB);
+static void     metaDBRLock(SMetaDB *pDB);
+static void     metaDBULock(SMetaDB *pDB);
 
 #define BDB_PERR(info, code) fprintf(stderr, info " reason: %s", db_strerror(code))
 
@@ -130,8 +140,10 @@ void metaCloseDB(SMeta *pMeta) {
 int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg) {
   tb_uid_t uid;
   char     buf[512];
+  char     buf1[512];
   void *   pBuf;
-  DBT      key, value;
+  DBT      key1, value1;
+  DBT      key2, value2;
   SSchema *pSchema = NULL;
 
   if (pTbCfg->type == META_SUPER_TABLE) {
@@ -143,19 +155,17 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg) {
   {
     // save table info
     pBuf = buf;
-    memset(&key, 0, sizeof(key));
-    memset(&value, 0, sizeof(key));
+    memset(&key1, 0, sizeof(key1));
+    memset(&value1, 0, sizeof(key1));
 
-    key.data = &uid;
-    key.size = sizeof(uid);
+    key1.data = &uid;
+    key1.size = sizeof(uid);
 
     metaEncodeTbInfo(&pBuf, pTbCfg);
 
-    value.data = buf;
-    value.size = POINTER_DISTANCE(pBuf, buf);
-    value.app_data = pTbCfg;
-
-    pMeta->pDB->pTbDB->put(pMeta->pDB->pTbDB, NULL, &key, &value, 0);
+    value1.data = buf;
+    value1.size = POINTER_DISTANCE(pBuf, buf);
+    value1.app_data = pTbCfg;
   }
 
   // save schema
@@ -169,23 +179,28 @@ int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg) {
   }
 
   if (pSchema) {
-    pBuf = buf;
-    memset(&key, 0, sizeof(key));
-    memset(&value, 0, sizeof(key));
+    pBuf = buf1;
+    memset(&key2, 0, sizeof(key2));
+    memset(&value2, 0, sizeof(key2));
     SSchemaKey schemaKey = {uid, 0 /*TODO*/, 0};
 
-    key.data = &schemaKey;
-    key.size = sizeof(schemaKey);
+    key2.data = &schemaKey;
+    key2.size = sizeof(schemaKey);
 
     SSchemaWrapper sw = {.nCols = ncols, .pSchema = pSchema};
     metaEncodeSchema(&pBuf, &sw);
 
-    value.data = buf;
-    value.size = POINTER_DISTANCE(pBuf, buf);
-
-    pMeta->pDB->pSchemaDB->put(pMeta->pDB->pSchemaDB, NULL, &key, &value, 0);
+    value2.data = buf1;
+    value2.size = POINTER_DISTANCE(pBuf, buf1);
   }
 
+  metaDBWLock(pMeta->pDB);
+  pMeta->pDB->pTbDB->put(pMeta->pDB->pTbDB, NULL, &key1, &value1, 0);
+  if (pSchema) {
+    pMeta->pDB->pSchemaDB->put(pMeta->pDB->pSchemaDB, NULL, &key2, &value2, 0);
+  }
+  metaDBULock(pMeta->pDB);
+
   return 0;
 }
 
@@ -234,11 +249,18 @@ static SMetaDB *metaNewDB() {
     return NULL;
   }
 
+#if IMPL_WITH_LOCK
+  pthread_rwlock_init(&pDB->rwlock, NULL);
+#endif
+
   return pDB;
 }
 
 static void metaFreeDB(SMetaDB *pDB) {
   if (pDB) {
+#if IMPL_WITH_LOCK
+    pthread_rwlock_destroy(&pDB->rwlock);
+#endif
     free(pDB);
   }
 }
@@ -467,7 +489,9 @@ STbCfg *metaGetTbInfoByUid(SMeta *pMeta, tb_uid_t uid) {
   key.size = sizeof(uid);
 
   // Query
+  metaDBRLock(pDB);
   ret = pDB->pTbDB->get(pDB->pTbDB, NULL, &key, &value, 0);
+  metaDBULock(pDB);
   if (ret != 0) {
     return NULL;
   }
@@ -496,7 +520,9 @@ STbCfg *metaGetTbInfoByName(SMeta *pMeta, char *tbname, tb_uid_t *uid) {
   key.size = strlen(tbname);
 
   // Query
+  metaDBRLock(pDB);
   ret = pDB->pNameIdx->pget(pDB->pNameIdx, NULL, &key, &pkey, &pvalue, 0);
+  metaDBULock(pDB);
   if (ret != 0) {
     return NULL;
   }
@@ -529,7 +555,9 @@ SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, boo
   key.size = sizeof(schemaKey);
 
   // Query
+  metaDBRLock(pDB);
   ret = pDB->pSchemaDB->get(pDB->pSchemaDB, NULL, &key, &value, 0);
+  metaDBULock(pDB);
   if (ret != 0) {
     printf("failed to query schema DB since %s================\n", db_strerror(ret));
     return NULL;
@@ -687,4 +715,22 @@ tb_uid_t metaCtbCursorNext(SMCtbCursor *pCtbCur) {
   } else {
     return 0;
   }
-}
\ No newline at end of file
+}
+
+static void metaDBWLock(SMetaDB *pDB) {
+#if IMPL_WITH_LOCK
+  pthread_rwlock_wrlock(&(pDB->rwlock));
+#endif
+}
+
+static void metaDBRLock(SMetaDB *pDB) {
+#if IMPL_WITH_LOCK
+  pthread_rwlock_rdlock(&(pDB->rwlock));
+#endif
+}
+
+static void metaDBULock(SMetaDB *pDB) {
+#if IMPL_WITH_LOCK
+  pthread_rwlock_unlock(&(pDB->rwlock));
+#endif
+}
diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h
index 9f1ea754c2..7128e143bf 100644
--- a/source/libs/catalog/inc/catalogInt.h
+++ b/source/libs/catalog/inc/catalogInt.h
@@ -31,7 +31,7 @@ extern "C" {
 #define CTG_DEFAULT_RENT_SECOND 10
 #define CTG_DEFAULT_RENT_SLOT_SIZE 10
 
-#define CTG_RENT_SLOT_SECOND 2
+#define CTG_RENT_SLOT_SECOND 1.5
 
 #define CTG_DEFAULT_INVALID_VERSION (-1)
 
@@ -115,7 +115,7 @@ typedef struct SCatalogMgmt {
 
 typedef uint32_t (*tableNameHashFp)(const char *, uint32_t);
 
-#define CTG_IS_META_NONE(type) ((type) == META_TYPE_NON_TABLE)
+#define CTG_IS_META_NULL(type) ((type) == META_TYPE_NULL_TABLE)
 #define CTG_IS_META_CTABLE(type) ((type) == META_TYPE_CTABLE)
 #define CTG_IS_META_TABLE(type) ((type) == META_TYPE_TABLE)
 #define CTG_IS_META_BOTH(type) ((type) == META_TYPE_BOTH_TABLE)
diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c
index 2197fdfd62..1b4d711aad 100644
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@@ -65,7 +65,6 @@ int32_t ctgGetDBVgroupFromCache(struct SCatalog* pCatalog, const char *dbName, S
 
 int32_t ctgGetDBVgroupFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, SBuildUseDBInput *input, SUseDbOutput *out) {
   char *msg = NULL;
-  SEpSet *pVnodeEpSet = NULL;
   int32_t msgLen = 0;
 
   ctgDebug("try to get db vgroup from mnode, db:%s", input->db);
@@ -216,17 +215,6 @@ int32_t ctgGetTableTypeFromCache(struct SCatalog* pCatalog, const SName* pTableN
   return TSDB_CODE_SUCCESS;
 }
 
-
-void ctgGenEpSet(SEpSet *epSet, SVgroupInfo *vgroupInfo) {
-  epSet->inUse = 0;
-  epSet->numOfEps = vgroupInfo->numOfEps;
-
-  for (int32_t i = 0; i < vgroupInfo->numOfEps; ++i) {
-    memcpy(&epSet->port[i], &vgroupInfo->epAddr[i].port, sizeof(epSet->port[i]));
-    memcpy(&epSet->fqdn[i], &vgroupInfo->epAddr[i].fqdn, sizeof(epSet->fqdn[i]));
-  }
-}
-
 int32_t ctgGetTableMetaFromMnodeImpl(struct SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, char* tbFullName, STableMetaOutput* output) {
   SBuildTableMetaInput bInput = {.vgId = 0, .dbName = NULL, .tableFullName = tbFullName};
   char *msg = NULL;
@@ -253,7 +241,7 @@ int32_t ctgGetTableMetaFromMnodeImpl(struct SCatalog* pCatalog, void *pTransport
   
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     if (CTG_TABLE_NOT_EXIST(rpcRsp.code)) {
-      SET_META_TYPE_NONE(output->metaType);
+      SET_META_TYPE_NULL(output->metaType);
       ctgDebug("stablemeta not exist in mnode, tbName:%s", tbFullName);
       return TSDB_CODE_SUCCESS;
     }
@@ -292,7 +280,6 @@ int32_t ctgGetTableMetaFromVnode(struct SCatalog* pCatalog, void *pTransporter,
 
   SBuildTableMetaInput bInput = {.vgId = vgroupInfo->vgId, .dbName = dbFullName, .tableFullName = (char *)tNameGetTableName(pTableName)};
   char *msg = NULL;
-  SEpSet *pVnodeEpSet = NULL;
   int32_t msgLen = 0;
 
   int32_t code = queryBuildMsg[TMSG_INDEX(TDMT_VND_TABLE_META)](&bInput, &msg, 0, &msgLen);
@@ -308,14 +295,11 @@ int32_t ctgGetTableMetaFromVnode(struct SCatalog* pCatalog, void *pTransporter,
   };
 
   SRpcMsg rpcRsp = {0};
-  SEpSet  epSet;
-  
-  ctgGenEpSet(&epSet, vgroupInfo);
-  rpcSendRecv(pTransporter, &epSet, &rpcMsg, &rpcRsp);
+  rpcSendRecv(pTransporter, &vgroupInfo->epset, &rpcMsg, &rpcRsp);
   
   if (TSDB_CODE_SUCCESS != rpcRsp.code) {
     if (CTG_TABLE_NOT_EXIST(rpcRsp.code)) {
-      SET_META_TYPE_NONE(output->metaType);
+      SET_META_TYPE_NULL(output->metaType);
       ctgDebug("tablemeta not exist in vnode, tbName:%s", tNameGetTableName(pTableName));
       return TSDB_CODE_SUCCESS;
     }
@@ -443,9 +427,9 @@ int32_t ctgSTableVersionCompare(const void* key1, const void* key2) {
 }
 
 int32_t ctgDbVgVersionCompare(const void* key1, const void* key2) {
-  if (((SDbVgVersion*)key1)->dbId < ((SDbVgVersion*)key2)->dbId) {
+  if (*(int64_t *)key1 < ((SDbVgVersion*)key2)->dbId) {
     return -1;
-  } else if (((SDbVgVersion*)key1)->dbId > ((SDbVgVersion*)key2)->dbId) {
+  } else if (*(int64_t *)key1 > ((SDbVgVersion*)key2)->dbId) {
     return 1;
   } else {
     return 0;
@@ -510,14 +494,14 @@ int32_t ctgMetaRentUpdate(SMetaRentMgmt *mgmt, void *meta, int64_t id, int32_t s
   
   CTG_LOCK(CTG_WRITE, &slot->lock);
   if (NULL == slot->meta) {
-    qError("meta in slot is empty, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
-    CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
+    qError("empty meta slot, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
 
   if (slot->needSort) {
     taosArraySort(slot->meta, compare);
     slot->needSort = false;
-    qDebug("slot meta sorted, slot idx:%d, type:%d", widx, mgmt->type);
+    qDebug("meta slot sorted, slot idx:%d, type:%d", widx, mgmt->type);
   }
 
   void *orig = taosArraySearch(slot->meta, &id, compare, TD_EQ);
@@ -542,6 +526,42 @@ _return:
   CTG_RET(code);
 }
 
+int32_t ctgMetaRentRemove(SMetaRentMgmt *mgmt, int64_t id, __compar_fn_t compare) {
+  int16_t widx = abs(id % mgmt->slotNum);
+
+  SRentSlotInfo *slot = &mgmt->slots[widx];
+  int32_t code = 0;
+  
+  CTG_LOCK(CTG_WRITE, &slot->lock);
+  if (NULL == slot->meta) {
+    qError("empty meta slot, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
+  }
+
+  if (slot->needSort) {
+    taosArraySort(slot->meta, compare);
+    slot->needSort = false;
+    qDebug("meta slot sorted, slot idx:%d, type:%d", widx, mgmt->type);
+  }
+
+  int32_t idx = taosArraySearchIdx(slot->meta, &id, compare, TD_EQ);
+  if (idx < 0) {
+    qError("meta not found in slot, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+    CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
+  }
+
+  taosArrayRemove(slot->meta, idx);
+
+  qDebug("meta in rent removed, id:%"PRIx64", slot idx:%d, type:%d", id, widx, mgmt->type);
+
+_return:
+
+  CTG_UNLOCK(CTG_WRITE, &slot->lock);
+
+  CTG_RET(code);
+}
+
+
 int32_t ctgMetaRentGetImpl(SMetaRentMgmt *mgmt, void **res, uint32_t *num, int32_t size) {
   int16_t ridx = atomic_add_fetch_16(&mgmt->slotRIdx, 1);
   if (ridx >= mgmt->slotNum) {
@@ -616,7 +636,7 @@ int32_t ctgMetaRentGet(SMetaRentMgmt *mgmt, void **res, uint32_t *num, int32_t s
 int32_t ctgUpdateTableMetaCache(struct SCatalog *pCatalog, STableMetaOutput *output) {
   int32_t code = 0;
 
-  if (NULL == output->tbMeta) {
+  if ((!CTG_IS_META_CTABLE(output->metaType)) && NULL == output->tbMeta) {
     ctgError("no valid table meta got from meta rsp, tbName:%s", output->tbFname);
     CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
   }
@@ -737,7 +757,7 @@ int32_t ctgGetDBVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgm
 }
 
 
-int32_t ctgValidateAndRemoveDb(struct SCatalog* pCatalog, const char* dbName, SDBVgroupInfo* dbInfo) {
+int32_t ctgValidateAndFreeDbInfo(struct SCatalog* pCatalog, const char* dbName, SDBVgroupInfo* dbInfo) {
   SDBVgroupInfo *oldInfo = (SDBVgroupInfo *)taosHashAcquire(pCatalog->dbCache.cache, dbName, strlen(dbName));
   if (oldInfo) {
     CTG_LOCK(CTG_WRITE, &oldInfo->lock);
@@ -763,6 +783,47 @@ int32_t ctgValidateAndRemoveDb(struct SCatalog* pCatalog, const char* dbName, SD
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t ctgValidateAndRemoveDbInfo(struct SCatalog* pCatalog, SDbVgVersion* target, bool *removed) {
+  *removed = false;
+
+  SDBVgroupInfo *info = (SDBVgroupInfo *)taosHashAcquire(pCatalog->dbCache.cache, target->dbName, strlen(target->dbName));
+  if (NULL == info) {
+    ctgInfo("db not exist in dbCache, may be removed, db:%s", target->dbName);
+    return TSDB_CODE_SUCCESS;
+  }
+  
+  CTG_LOCK(CTG_WRITE, &info->lock);
+  
+  if (info->dbId != target->dbId) {
+    ctgInfo("db id already updated, db:%s, dbId:%"PRIx64 ", targetId:%"PRIx64, target->dbName, info->dbId, target->dbId);
+    CTG_UNLOCK(CTG_WRITE, &info->lock);
+    taosHashRelease(pCatalog->dbCache.cache, info);
+    return TSDB_CODE_SUCCESS;
+  }
+    
+  if (info->vgInfo) {
+    ctgInfo("cleanup db vgInfo, db:%s", target->dbName);
+    taosHashCleanup(info->vgInfo);
+    info->vgInfo = NULL;
+  }
+
+  if (taosHashRemove(pCatalog->dbCache.cache, target->dbName, strlen(target->dbName))) {
+    ctgError("taosHashRemove from dbCache failed, db:%s", target->dbName);
+    CTG_UNLOCK(CTG_WRITE, &info->lock);      
+    taosHashRelease(pCatalog->dbCache.cache, info);
+    CTG_ERR_RET(TSDB_CODE_CTG_INTERNAL_ERROR);
+  }
+  
+  CTG_UNLOCK(CTG_WRITE, &info->lock);
+
+  taosHashRelease(pCatalog->dbCache.cache, info);
+
+  *removed = true;
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t ctgRenewTableMetaImpl(struct SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, int32_t isSTable) {
   if (NULL == pCatalog || NULL == pTransporter || NULL == pMgmtEps || NULL == pTableName) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
@@ -783,7 +844,7 @@ int32_t ctgRenewTableMetaImpl(struct SCatalog* pCatalog, void *pTransporter, con
     // if get from mnode failed, will not try vnode
     CTG_ERR_JRET(ctgGetTableMetaFromMnode(pCatalog, pTransporter, pMgmtEps, pTableName, &moutput));
 
-    if (CTG_IS_META_NONE(moutput.metaType)) {
+    if (CTG_IS_META_NULL(moutput.metaType)) {
       CTG_ERR_JRET(ctgGetTableMetaFromVnode(pCatalog, pTransporter, pMgmtEps, pTableName, &vgroupInfo, &voutput));
     } else {
       output = &moutput;
@@ -799,6 +860,8 @@ int32_t ctgRenewTableMetaImpl(struct SCatalog* pCatalog, void *pTransporter, con
       
       CTG_ERR_JRET(ctgGetTableMetaFromMnodeImpl(pCatalog, pTransporter, pMgmtEps, voutput.tbFname, &moutput));
 
+      voutput.metaType = moutput.metaType;
+      
       tfree(voutput.tbMeta);
       voutput.tbMeta = moutput.tbMeta;
       moutput.tbMeta = NULL;
@@ -808,20 +871,22 @@ int32_t ctgRenewTableMetaImpl(struct SCatalog* pCatalog, void *pTransporter, con
       if (0 == exist) {
         CTG_ERR_JRET(ctgGetTableMetaFromMnodeImpl(pCatalog, pTransporter, pMgmtEps, voutput.tbFname, &moutput));
 
-        if (CTG_IS_META_NONE(moutput.metaType)) {
-          SET_META_TYPE_NONE(voutput.metaType);
+        if (CTG_IS_META_NULL(moutput.metaType)) {
+          SET_META_TYPE_NULL(voutput.metaType);
         }
         
         tfree(voutput.tbMeta);
         voutput.tbMeta = moutput.tbMeta;
         moutput.tbMeta = NULL;
       } else {
+        tfree(voutput.tbMeta);
+        
         SET_META_TYPE_CTABLE(voutput.metaType); 
       }
     }
   }
 
-  if (CTG_IS_META_NONE(output->metaType)) {
+  if (CTG_IS_META_NULL(output->metaType)) {
     ctgError("no tablemeta got, tbNmae:%s", tNameGetTableName(pTableName));
     CTG_ERR_JRET(CTG_ERR_CODE_TABLE_NOT_EXIST);
   }
@@ -1134,19 +1199,6 @@ int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDB
     CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
   }
 
-  if (dbInfo->vgVersion < 0) {
-    ctgWarn("db vgVersion less than 0, dbName:%s, vgVersion:%d", dbName, dbInfo->vgVersion);
-
-    if (pCatalog->dbCache.cache) {
-      CTG_ERR_JRET(ctgValidateAndRemoveDb(pCatalog, dbName, dbInfo));
-      
-      CTG_ERR_JRET(taosHashRemove(pCatalog->dbCache.cache, dbName, strlen(dbName)));
-    }
-    
-    ctgWarn("db removed from cache, db:%s", dbName);
-    goto _return;
-  }
-
   if (NULL == pCatalog->dbCache.cache) {
     SHashObj *cache = taosHashInit(ctgMgmt.cfg.maxDBCacheNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
     if (NULL == cache) {
@@ -1158,10 +1210,12 @@ int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDB
       taosHashCleanup(cache);
     }
   } else {
-    CTG_ERR_JRET(ctgValidateAndRemoveDb(pCatalog, dbName, dbInfo));
+    CTG_ERR_JRET(ctgValidateAndFreeDbInfo(pCatalog, dbName, dbInfo));
   }
 
   bool newAdded = false;
+  
+  dbInfo->lock = 0;
   if (taosHashPutExt(pCatalog->dbCache.cache, dbName, strlen(dbName), dbInfo, sizeof(*dbInfo), &newAdded) != 0) {
     ctgError("taosHashPutExt db vgroup to cache failed, db:%s", dbName);
     CTG_ERR_JRET(TSDB_CODE_CTG_MEM_ERROR);
@@ -1170,6 +1224,8 @@ int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDB
   dbInfo->vgInfo = NULL;
 
   SDbVgVersion vgVersion = {.dbId = dbInfo->dbId, .vgVersion = dbInfo->vgVersion};
+  strncpy(vgVersion.dbName, dbName, sizeof(vgVersion.dbName));
+  
   if (newAdded) {
     CTG_ERR_JRET(ctgMetaRentAdd(&pCatalog->dbRent, &vgVersion, dbInfo->dbId, sizeof(SDbVgVersion)));
   } else {
@@ -1189,6 +1245,34 @@ _return:
   CTG_RET(code);
 }
 
+
+int32_t catalogRemoveDBVgroup(struct SCatalog* pCatalog, SDbVgVersion* dbInfo) {
+  int32_t code = 0;
+  bool removed = false;
+  
+  if (NULL == pCatalog || NULL == dbInfo) {
+    CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
+  }
+
+  if (NULL == pCatalog->dbCache.cache) {
+    return TSDB_CODE_SUCCESS;
+  }
+  
+  CTG_ERR_RET(ctgValidateAndRemoveDbInfo(pCatalog, dbInfo, &removed));
+  if (!removed) {
+    return TSDB_CODE_SUCCESS;
+  }
+  
+  ctgInfo("db removed from cache, db:%s", dbInfo->dbName);
+
+  CTG_ERR_RET(ctgMetaRentRemove(&pCatalog->dbRent, dbInfo->dbId, ctgDbVgVersionCompare));
+  
+  ctgDebug("db removed from rent, db:%s", dbInfo->dbName);
+  
+  CTG_RET(code);
+}
+
+
 int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta) {
   return ctgGetTableMeta(pCatalog, pTransporter, pMgmtEps, pTableName, false, pTableMeta, -1);
 }
@@ -1291,6 +1375,7 @@ int32_t catalogGetTableHashVgroup(struct SCatalog *pCatalog, void *pTransporter,
   CTG_ERR_JRET(ctgGetVgInfoFromHashValue(pCatalog, dbInfo, pTableName, pVgroup));
 
 _return:
+
   if (dbInfo) {
     CTG_UNLOCK(CTG_READ, &dbInfo->lock);  
     taosHashRelease(pCatalog->dbCache.cache, dbInfo);
diff --git a/source/libs/catalog/test/catalogTests.cpp b/source/libs/catalog/test/catalogTests.cpp
index a01c3bcf5d..c6e5e359bf 100644
--- a/source/libs/catalog/test/catalogTests.cpp
+++ b/source/libs/catalog/test/catalogTests.cpp
@@ -59,7 +59,7 @@ int32_t ctgTestTagNum = 1;
 int32_t ctgTestSVersion = 1;
 int32_t ctgTestTVersion = 1;
 int32_t ctgTestSuid = 2;
-int64_t ctgTestDbId = 33;
+uint64_t ctgTestDbId = 33;
 
 uint64_t ctgTestClusterId = 0x1;
 char    *ctgTestDbname = "1.db1";
@@ -195,10 +195,10 @@ void ctgTestBuildDBVgroup(SDBVgroupInfo *dbVgroup) {
     vgInfo.vgId = i + 1;
     vgInfo.hashBegin = i * hashUnit;
     vgInfo.hashEnd = hashUnit * (i + 1) - 1;
-    vgInfo.numOfEps = i % TSDB_MAX_REPLICA + 1;
-    vgInfo.inUse = i % vgInfo.numOfEps;
-    for (int32_t n = 0; n < vgInfo.numOfEps; ++n) {
-      SEpAddr *addr = &vgInfo.epAddr[n];
+    vgInfo.epset.numOfEps = i % TSDB_MAX_REPLICA + 1;
+    vgInfo.epset.inUse = i % vgInfo.epset.numOfEps;
+    for (int32_t n = 0; n < vgInfo.epset.numOfEps; ++n) {
+      SEp *addr = &vgInfo.epset.eps[n];
       strcpy(addr->fqdn, "a0");
       addr->port = htons(n + 22);
     }
@@ -229,10 +229,10 @@ void ctgTestPrepareDbVgroups(void *shandle, SEpSet *pEpSet, SRpcMsg *pMsg, SRpcM
     vg->vgId = htonl(i + 1);
     vg->hashBegin = htonl(i * hashUnit);
     vg->hashEnd = htonl(hashUnit * (i + 1) - 1);
-    vg->numOfEps = i % TSDB_MAX_REPLICA + 1;
-    vg->inUse = i % vg->numOfEps;
-    for (int32_t n = 0; n < vg->numOfEps; ++n) {
-      SEpAddr *addr = &vg->epAddr[n];
+    vg->epset.numOfEps = i % TSDB_MAX_REPLICA + 1;
+    vg->epset.inUse = i % vg->epset.numOfEps;
+    for (int32_t n = 0; n < vg->epset.numOfEps; ++n) {
+      SEp *addr = &vg->epset.eps[n];
       strcpy(addr->fqdn, "a0");
       addr->port = htons(n + 22);
     }
@@ -693,7 +693,7 @@ TEST(tableMeta, normalTable) {
   code = catalogGetTableHashVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgInfo);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(vgInfo.vgId, 8);
-  ASSERT_EQ(vgInfo.numOfEps, 3);
+  ASSERT_EQ(vgInfo.epset.numOfEps, 3);
 
   ctgTestSetPrepareTableMeta();
 
@@ -983,7 +983,7 @@ TEST(tableDistVgroup, normalTable) {
   ASSERT_EQ(taosArrayGetSize((const SArray *)vgList), 1);
   vgInfo = (SVgroupInfo *)taosArrayGet(vgList, 0);
   ASSERT_EQ(vgInfo->vgId, 8);
-  ASSERT_EQ(vgInfo->numOfEps, 3);
+  ASSERT_EQ(vgInfo->epset.numOfEps, 3);
 
   catalogDestroy();
 }
@@ -1015,7 +1015,7 @@ TEST(tableDistVgroup, childTableCase) {
   ASSERT_EQ(taosArrayGetSize((const SArray *)vgList), 1);
   vgInfo = (SVgroupInfo *)taosArrayGet(vgList, 0);
   ASSERT_EQ(vgInfo->vgId, 9);
-  ASSERT_EQ(vgInfo->numOfEps, 4);
+  ASSERT_EQ(vgInfo->epset.numOfEps, 4);
 
   catalogDestroy();
 }
@@ -1046,13 +1046,13 @@ TEST(tableDistVgroup, superTableCase) {
   ASSERT_EQ(taosArrayGetSize((const SArray *)vgList), 10);
   vgInfo = (SVgroupInfo *)taosArrayGet(vgList, 0);
   ASSERT_EQ(vgInfo->vgId, 1);
-  ASSERT_EQ(vgInfo->numOfEps, 1);
+  ASSERT_EQ(vgInfo->epset.numOfEps, 1);
   vgInfo = (SVgroupInfo *)taosArrayGet(vgList, 1);
   ASSERT_EQ(vgInfo->vgId, 2);
-  ASSERT_EQ(vgInfo->numOfEps, 2);
+  ASSERT_EQ(vgInfo->epset.numOfEps, 2);
   vgInfo = (SVgroupInfo *)taosArrayGet(vgList, 2);
   ASSERT_EQ(vgInfo->vgId, 3);
-  ASSERT_EQ(vgInfo->numOfEps, 3);
+  ASSERT_EQ(vgInfo->epset.numOfEps, 3);
 
   catalogDestroy();
 }
@@ -1088,14 +1088,14 @@ TEST(dbVgroup, getSetDbVgroupCase) {
   code = catalogGetTableHashVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgInfo);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(vgInfo.vgId, 8);
-  ASSERT_EQ(vgInfo.numOfEps, 3);
+  ASSERT_EQ(vgInfo.epset.numOfEps, 3);
 
   code = catalogGetTableDistVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgList);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(taosArrayGetSize((const SArray *)vgList), 1);
   pvgInfo = (SVgroupInfo *)taosArrayGet(vgList, 0);
   ASSERT_EQ(pvgInfo->vgId, 8);
-  ASSERT_EQ(pvgInfo->numOfEps, 3);
+  ASSERT_EQ(pvgInfo->epset.numOfEps, 3);
   taosArrayDestroy(vgList);
 
   ctgTestBuildDBVgroup(&dbVgroup);
@@ -1105,14 +1105,14 @@ TEST(dbVgroup, getSetDbVgroupCase) {
   code = catalogGetTableHashVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgInfo);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(vgInfo.vgId, 7);
-  ASSERT_EQ(vgInfo.numOfEps, 2);
+  ASSERT_EQ(vgInfo.epset.numOfEps, 2);
 
   code = catalogGetTableDistVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgList);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(taosArrayGetSize((const SArray *)vgList), 1);
   pvgInfo = (SVgroupInfo *)taosArrayGet(vgList, 0);
   ASSERT_EQ(pvgInfo->vgId, 8);
-  ASSERT_EQ(pvgInfo->numOfEps, 3);
+  ASSERT_EQ(pvgInfo->epset.numOfEps, 3);
   taosArrayDestroy(vgList);
 
   catalogDestroy();
diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c
index 97a0557748..3623f5947d 100644
--- a/source/libs/executor/src/dataDispatcher.c
+++ b/source/libs/executor/src/dataDispatcher.c
@@ -186,6 +186,7 @@ static void getDataLength(SDataSinkHandle* pHandle, int32_t* pLen, bool* pQueryE
   memcpy(&pDispatcher->nextOutput, pBuf, sizeof(SDataDispatchBuf));
   taosFreeQitem(pBuf);
   *pLen = ((SDataCacheEntry*)(pDispatcher->nextOutput.pData))->dataLen;
+  *pQueryEnd = pDispatcher->queryEnd;    
 }
 
 static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c
index 05da921526..6efd7ef87e 100644
--- a/source/libs/executor/src/executorimpl.c
+++ b/source/libs/executor/src/executorimpl.c
@@ -5164,14 +5164,9 @@ static SSDataBlock* doLoadRemoteData(void* param, bool* newgroup) {
 
     SDownstreamSource* pSource = taosArrayGet(pExchangeInfo->pSources, pExchangeInfo->current);
 
-    SEpSet epSet = {0};
-    epSet.numOfEps = pSource->addr.numOfEps;
-    epSet.port[0] = pSource->addr.epAddr[0].port;
-    tstrncpy(epSet.fqdn[0], pSource->addr.epAddr[0].fqdn, tListLen(epSet.fqdn[0]));
-
     int64_t startTs = taosGetTimestampUs();
     qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", %d/%" PRIzu,
-           GET_TASKID(pTaskInfo), pSource->addr.nodeId, epSet.fqdn[0], pSource->taskId, pExchangeInfo->current, totalSources);
+           GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epset.eps[0].fqdn, pSource->taskId, pExchangeInfo->current, totalSources);
 
     pMsg->header.vgId = htonl(pSource->addr.nodeId);
     pMsg->sId = htobe64(pSource->schedId);
@@ -5193,7 +5188,7 @@ static SSDataBlock* doLoadRemoteData(void* param, bool* newgroup) {
     pMsgSendInfo->fp = loadRemoteDataCallback;
 
     int64_t transporterId = 0;
-    int32_t code = asyncSendMsgToServer(pExchangeInfo->pTransporter, &epSet, &transporterId, pMsgSendInfo);
+    int32_t code = asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epset, &transporterId, pMsgSendInfo);
     tsem_wait(&pExchangeInfo->ready);
 
     SRetrieveTableRsp* pRsp = pExchangeInfo->pRsp;
@@ -5902,7 +5897,7 @@ static SSDataBlock* doAggregate(void* param, bool* newgroup) {
   finalizeQueryResult(pOperator, pInfo->pCtx, &pInfo->resultRowInfo, pInfo->rowCellInfoOffset);
   pInfo->pRes->info.rows = getNumOfResult(pInfo->pCtx, pOperator->numOfOutput);
 
-  return pInfo->pRes;
+  return (pInfo->pRes->info.rows != 0)? pInfo->pRes:NULL;
 }
 
 static SSDataBlock* doSTableAggregate(void* param, bool* newgroup) {
@@ -8831,14 +8826,14 @@ void* freeColumnInfo(SColumnInfo* pColumnInfo, int32_t numOfCols) {
 }
 
 void doDestroyTask(SExecTaskInfo *pTaskInfo) {
+  qDebug("%s execTask is freed", GET_TASKID(pTaskInfo));
+
   doDestroyTableQueryInfo(&pTaskInfo->tableqinfoGroupInfo);
 //  taosArrayDestroy(pTaskInfo->summary.queryProfEvents);
 //  taosHashCleanup(pTaskInfo->summary.operatorProfResults);
 
   tfree(pTaskInfo->sql);
   tfree(pTaskInfo->id.str);
-  qDebug("%s execTask is freed", GET_TASKID(pTaskInfo));
-
   tfree(pTaskInfo);
 }
 
diff --git a/source/libs/parser/CMakeLists.txt b/source/libs/parser/CMakeLists.txt
index 7f77876c4c..417c56aba1 100644
--- a/source/libs/parser/CMakeLists.txt
+++ b/source/libs/parser/CMakeLists.txt
@@ -8,7 +8,7 @@ target_include_directories(
 
 target_link_libraries(
         parser
-        PRIVATE os util catalog function transport qcom
+        PRIVATE os util nodes catalog function transport qcom
 )
 
 if(${BUILD_TEST})
diff --git a/source/libs/parser/inc/astCreateContext.h b/source/libs/parser/inc/astCreateContext.h
new file mode 100644
index 0000000000..dcdc6a045b
--- /dev/null
+++ b/source/libs/parser/inc/astCreateContext.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_AST_CREATER_H_
+#define _TD_AST_CREATER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "nodes.h"
+#include "parser.h"
+
+typedef struct SAstCreateContext {
+  SParseContext* pQueryCxt;
+  bool notSupport;
+  bool valid;
+  SNode* pRootNode;
+} SAstCreateContext;
+
+int32_t createAstCreateContext(const SParseContext* pQueryCxt, SAstCreateContext* pCxt);
+int32_t destroyAstCreateContext(SAstCreateContext* pCxt);
+
+void* acquireRaii(SAstCreateContext* pCxt, void* p);
+void* releaseRaii(SAstCreateContext* pCxt, void* p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_AST_CREATER_H_*/
diff --git a/source/libs/parser/inc/astCreateFuncs.h b/source/libs/parser/inc/astCreateFuncs.h
new file mode 100644
index 0000000000..c4c5dcba6c
--- /dev/null
+++ b/source/libs/parser/inc/astCreateFuncs.h
@@ -0,0 +1,47 @@
+/*
+ * 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 "nodes.h"
+#include "nodesShowStmts.h"
+#include "astCreateContext.h"
+#include "ttoken.h"
+
+#ifndef _TD_AST_CREATE_FUNCS_H_
+#define _TD_AST_CREATE_FUNCS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool checkTableName(const SToken* pTableName);
+SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode);
+SNode* addOrderByList(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pOrderByList);
+SNode* addSlimit(SAstCreateContext* pCxt, SNode* pStmt, SNode* pSlimit);
+SNode* addLimit(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit);
+SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const SToken* pColumnName);
+SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const SToken* pOffset);
+SNodeList* createNodeList(SAstCreateContext* pCxt, SNode* pNode);
+SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder);
+SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const SToken* pTableName);
+SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable);
+SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight);
+SNode* createShowStmt(SAstCreateContext* pCxt, EShowStmtType type);
+SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_AST_CREATE_FUNCS_H_*/
diff --git a/source/libs/parser/inc/new_sql.y b/source/libs/parser/inc/new_sql.y
new file mode 100644
index 0000000000..9237f63f35
--- /dev/null
+++ b/source/libs/parser/inc/new_sql.y
@@ -0,0 +1,199 @@
+//lemon parser file to generate sql parse by using finite-state-machine code used to parse sql
+//usage: lemon sql.y
+
+%name NewParse
+
+%token_prefix NEW_TK_
+%token_type { SToken }
+%default_type { SNode* }
+%default_destructor { nodesDestroyNode($$); }
+
+%extra_argument { SAstCreateContext* pCxt }
+
+%include {
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdbool.h>
+
+#include "nodes.h"
+#include "ttoken.h"
+#include "ttokendef.h"
+#include "astCreateFuncs.h"
+
+#define PARSER_TRACE printf("rule = %s\n", yyRuleName[yyruleno])
+}
+
+%syntax_error {  
+  if(TOKEN.z) {
+    char msg[] = "syntax error near \"%s\"";
+    int32_t sqlLen = strlen(&TOKEN.z[0]);
+
+    if (sqlLen + sizeof(msg)/sizeof(msg[0]) + 1 > pCxt->pQueryCxt->msgLen) {
+        char tmpstr[128] = {0};
+        memcpy(tmpstr, &TOKEN.z[0], sizeof(tmpstr)/sizeof(tmpstr[0]) - 1);
+        sprintf(pCxt->pQueryCxt->pMsg, msg, tmpstr);
+    } else {
+        sprintf(pCxt->pQueryCxt->pMsg, msg, &TOKEN.z[0]);
+    }
+  } else {
+    sprintf(pCxt->pQueryCxt->pMsg, "Incomplete SQL statement");
+  }
+  pCxt->valid = false;
+}
+
+%parse_accept       { printf("parsing complete!\n" );}
+
+//%left OR.
+//%left AND.
+//%right NOT.
+%left UNION ALL MINUS EXCEPT INTERSECT.
+//%left EQ NE ISNULL NOTNULL IS LIKE MATCH NMATCH GLOB BETWEEN IN.
+//%left GT GE LT LE.
+//%left BITAND BITOR LSHIFT RSHIFT.
+%left NK_PLUS NK_MINUS.
+//%left DIVIDE TIMES.
+%left NK_STAR NK_SLASH. //REM.
+//%left CONCAT.
+//%right UMINUS UPLUS BITNOT.
+
+cmd ::= SHOW DATABASES.  { PARSER_TRACE; createShowStmt(pCxt, SHOW_TYPE_DATABASE); }
+
+cmd ::= query_expression(A). { PARSER_TRACE; pCxt->pRootNode = A; }
+
+//////////////////////// value_function /////////////////////////////////
+value_function ::= NK_ID NK_LP value_expression NK_RP.
+value_function ::= NK_ID NK_LP value_expression NK_COMMA value_expression NK_RP.
+
+//////////////////////// value_expression_primary /////////////////////////////////
+value_expression_primary ::= NK_LP value_expression NK_RP.
+value_expression_primary ::= nonparenthesized_value_expression_primary.
+
+nonparenthesized_value_expression_primary ::= literal.
+// ?
+nonparenthesized_value_expression_primary ::= column_reference.
+
+literal ::= NK_LITERAL.
+
+column_reference(A) ::= NK_ID(B).                      { PARSER_TRACE; A = createColumnNode(pCxt, NULL, &B); }
+column_reference(A) ::= table_name(B) NK_DOT NK_ID(C). { PARSER_TRACE; A = createColumnNode(pCxt, &B, &C); }
+
+//////////////////////// value_expression /////////////////////////////////
+value_expression ::= common_value_expression.
+
+common_value_expression ::= numeric_value_expression.
+
+numeric_value_expression ::= numeric_primary.
+numeric_value_expression ::= NK_PLUS numeric_primary.
+numeric_value_expression ::= NK_MINUS numeric_primary.
+numeric_value_expression ::= numeric_value_expression NK_PLUS numeric_value_expression.
+numeric_value_expression ::= numeric_value_expression NK_MINUS numeric_value_expression.
+numeric_value_expression ::= numeric_value_expression NK_STAR numeric_value_expression.
+numeric_value_expression ::= numeric_value_expression NK_SLASH numeric_value_expression.
+
+numeric_primary ::= value_expression_primary.
+numeric_primary ::= value_function.
+
+//////////////////////// query_specification /////////////////////////////////
+query_specification(A) ::= SELECT set_quantifier_opt(B) select_list(C) from_clause(D). { PARSER_TRACE; A = createSelectStmt(pCxt, B, C, D); }
+
+%type set_quantifier_opt { bool }
+%destructor set_quantifier_opt {}
+set_quantifier_opt(A) ::= .         { PARSER_TRACE; A = false; }
+set_quantifier_opt(A) ::= DISTINCT. { PARSER_TRACE; A = true; }
+set_quantifier_opt(A) ::= ALL.      { PARSER_TRACE; A = false; }
+
+%type select_list { SNodeList* }
+%destructor select_list { nodesDestroyNodeList($$); }
+select_list(A) ::= NK_STAR.           { PARSER_TRACE; A = NULL; }
+select_list(A) ::= select_sublist(B). { PARSER_TRACE; A = B; }
+
+%type select_sublist { SNodeList* }
+%destructor select_sublist { nodesDestroyNodeList($$); }
+select_sublist(A) ::= select_item(B).                            { PARSER_TRACE; A = createNodeList(pCxt, B); }
+select_sublist(A) ::= select_sublist(B) NK_COMMA select_item(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); }
+
+select_item(A) ::= value_expression(B).                     { PARSER_TRACE; A = B; }
+select_item(A) ::= value_expression(B) AS NK_ID(C).         { PARSER_TRACE; A = setProjectionAlias(pCxt, B, &C); }
+select_item(A) ::= table_name(B) NK_DOT NK_STAR(C).                 { PARSER_TRACE; A = createColumnNode(pCxt, &B, &C); }
+
+from_clause(A) ::= FROM table_reference_list(B). { PARSER_TRACE; A = B; }
+
+//%type table_reference_list { SNodeList* }
+//%destructor table_reference_list { nodesDestroyNodeList($$); }
+table_reference_list(A) ::= table_reference(B).                               { PARSER_TRACE; A = B; }
+//table_reference_list(A) ::= table_reference_list(B) NK_COMMA table_reference(C). { PARSER_TRACE; A = createJoinTableNode(pCxt, B, C); }
+
+//table_reference(A) ::= NK_ID(B). { PARSER_TRACE; A = createRealTableNode(pCxt, ); }
+table_reference(A) ::= table_factor(B). { PARSER_TRACE; A = B; }
+//table_reference ::= joined_table.
+
+table_factor(A) ::= table_primary(B). { PARSER_TRACE; A = B; }
+
+table_primary(A) ::= table_name(B).                   { PARSER_TRACE; A = createRealTableNode(pCxt, NULL, &B); }
+table_primary(A) ::= db_name(B) NK_DOT table_name(C). { PARSER_TRACE; A = createRealTableNode(pCxt, &B, &C); }
+table_primary ::= derived_table.
+
+derived_table ::= table_subquery.
+
+%type db_name { SToken }
+db_name(A) ::= NK_ID(B).    { PARSER_TRACE; A = B; }
+%type table_name { SToken }
+table_name(A) ::= NK_ID(B). { PARSER_TRACE; A = B; }
+
+//////////////////////// subquery /////////////////////////////////
+subquery ::= NK_LR query_expression NK_RP.
+
+table_subquery ::= subquery.
+
+// query_expression
+query_expression(A) ::= with_clause_opt query_expression_body(B) order_by_clause_opt(C) slimit_clause_opt(D) limit_clause_opt(E). { 
+                                                                                                                                    PARSER_TRACE;
+                                                                                                                                    addOrderByList(pCxt, B, C);
+                                                                                                                                    addSlimit(pCxt, B, D);
+                                                                                                                                    addLimit(pCxt, B, E);
+                                                                                                                                    A = B;  
+                                                                                                                                  }
+
+// WITH AS 
+with_clause_opt ::= .                                                                                                             {}
+
+query_expression_body(A) ::= query_primary(B).                                                                                    { PARSER_TRACE; A = B; }
+query_expression_body(A) ::= query_expression_body(B) UNION ALL query_expression_body(D).                                         { PARSER_TRACE; A = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, B, D); }
+
+query_primary(A) ::= query_specification(B).                                                                                      { PARSER_TRACE; A = B; }
+query_primary(A) ::= NK_LP query_expression_body(B) order_by_clause_opt limit_clause_opt slimit_clause_opt NK_RP.                 { PARSER_TRACE; A = B;}
+
+%type order_by_clause_opt { SNodeList* }
+%destructor order_by_clause_opt { nodesDestroyNodeList($$); }
+order_by_clause_opt(A) ::= .                                                                                                      { PARSER_TRACE; A = NULL; }
+order_by_clause_opt(A) ::= ORDER BY sort_specification_list(B).                                                                   { PARSER_TRACE; A = B; }
+
+slimit_clause_opt(A) ::= .                                                                                                        { A = NULL; }
+slimit_clause_opt(A) ::= SLIMIT NK_INTEGER(B) SOFFSET NK_INTEGER(C).                                                              { A = createLimitNode(pCxt, &B, &C); }
+slimit_clause_opt(A) ::= SLIMIT NK_INTEGER(C) NK_COMMA NK_INTEGER(B).                                                             { A = createLimitNode(pCxt, &B, &C); }
+
+limit_clause_opt(A) ::= .                                                                                                         { A = NULL; }
+limit_clause_opt(A) ::= LIMIT NK_INTEGER(B) OFFSET NK_INTEGER(C).                                                                 { A = createLimitNode(pCxt, &B, &C); }
+limit_clause_opt(A) ::= LIMIT NK_INTEGER(C) NK_COMMA NK_INTEGER(B).                                                               { A = createLimitNode(pCxt, &B, &C); }
+
+//////////////////////// sort_specification_list /////////////////////////////////
+%type sort_specification_list { SNodeList* }
+%destructor sort_specification_list { nodesDestroyNodeList($$); }
+sort_specification_list(A) ::= sort_specification(B).                                     { PARSER_TRACE; A = createNodeList(pCxt, B); }
+sort_specification_list(A) ::= sort_specification_list(B) NK_COMMA sort_specification(C). { PARSER_TRACE; A = addNodeToList(pCxt, B, C); }
+
+sort_specification(A) ::= value_expression(B) ordering_specification_opt(C) null_ordering_opt(D). { PARSER_TRACE; A = createOrderByExprNode(pCxt, B, C, D); }
+
+%type ordering_specification_opt EOrder
+%destructor ordering_specification_opt {}
+ordering_specification_opt(A) ::= .     { PARSER_TRACE; A = ORDER_ASC; }
+ordering_specification_opt(A) ::= ASC.  { PARSER_TRACE; A = ORDER_ASC; }
+ordering_specification_opt(A) ::= DESC. { PARSER_TRACE; A = ORDER_DESC; }
+
+%type null_ordering_opt ENullOrder
+%destructor null_ordering_opt {}
+null_ordering_opt(A) ::= .            { PARSER_TRACE; A = NULL_ORDER_DEFAULT; }
+null_ordering_opt(A) ::= NULLS FIRST. { PARSER_TRACE; A = NULL_ORDER_FIRST; }
+null_ordering_opt(A) ::= NULLS LAST.  { PARSER_TRACE; A = NULL_ORDER_LAST; }
diff --git a/source/nodes/src/nodesCode.c b/source/libs/parser/inc/parserImpl.h
similarity index 68%
rename from source/nodes/src/nodesCode.c
rename to source/libs/parser/inc/parserImpl.h
index 7fe919ffe8..57012e2fd6 100644
--- a/source/nodes/src/nodesCode.c
+++ b/source/libs/parser/inc/parserImpl.h
@@ -14,11 +14,23 @@
  */
 
 #include "nodes.h"
+#include "parser.h"
 
-int32_t nodeToString(const SNode* pNode, char** pStr, int32_t* pLen) {
+#ifndef _TD_AST_CREATE_FUNCS_H_
+#define _TD_AST_CREATE_FUNCS_H_
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SQuery {
+  SNode* pRoot;
+} SQuery;
+
+int32_t doParse(SParseContext* pParseCxt, SQuery* pQuery);
+
+#ifdef __cplusplus
 }
+#endif
 
-int32_t stringToNode(const char* pStr, SNode** pNode) {
-
-}
+#endif /*_TD_AST_CREATE_FUNCS_H_*/
diff --git a/source/libs/parser/src/astCreateContext.c b/source/libs/parser/src/astCreateContext.c
new file mode 100644
index 0000000000..42c5257360
--- /dev/null
+++ b/source/libs/parser/src/astCreateContext.c
@@ -0,0 +1,40 @@
+/*
+ * 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 "ttoken.h"
+#include "astCreateContext.h"
+
+void* acquireRaii(SAstCreateContext* pCxt, void* p) {
+  if (NULL == p) {
+    return NULL;
+  }
+  return p;
+}
+
+void* releaseRaii(SAstCreateContext* pCxt, void* p) {
+  if (NULL == p) {
+    return NULL;
+  }
+  return p;
+}
+
+int32_t createAstCreater(const SParseContext* pQueryCxt, SAstCreateContext* pCxt) {
+
+}
+
+int32_t destroyAstCreater(SAstCreateContext* pCxt) {
+
+}
+
diff --git a/source/libs/parser/src/astCreateFuncs.c b/source/libs/parser/src/astCreateFuncs.c
new file mode 100644
index 0000000000..337ae78d75
--- /dev/null
+++ b/source/libs/parser/src/astCreateFuncs.c
@@ -0,0 +1,91 @@
+
+/*
+ * 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 "astCreateFuncs.h"
+
+#include "astCreateContext.h"
+
+bool checkTableName(const SToken* pTableName) {
+  printf("%p : %d, %d, %s\n", pTableName, pTableName->type, pTableName->n, pTableName->z);
+  return pTableName->n < TSDB_TABLE_NAME_LEN ? true : false;
+}
+
+SNodeList* addNodeToList(SAstCreateContext* pCxt, SNodeList* pList, SNode* pNode) {
+
+}
+
+SNode* addOrderByList(SAstCreateContext* pCxt, SNode* pStmt, SNodeList* pOrderByList) {
+
+}
+
+SNode* addSlimit(SAstCreateContext* pCxt, SNode* pStmt, SNode* pSlimit) {
+
+}
+
+SNode* addLimit(SAstCreateContext* pCxt, SNode* pStmt, SNode* pLimit) {
+
+}
+
+SNode* createColumnNode(SAstCreateContext* pCxt, const SToken* pTableName, const SToken* pColumnName) {
+
+}
+
+SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const SToken* pOffset) {
+
+}
+
+SNodeList* createNodeList(SAstCreateContext* pCxt, SNode* pNode) {
+
+}
+
+SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder) {
+
+}
+
+SNode* createRealTableNode(SAstCreateContext* pCxt, const SToken* pDbName, const SToken* pTableName) {
+  SRealTableNode* realTable = (SRealTableNode*)nodesMakeNode(QUERY_NODE_REAL_TABLE);
+  if (NULL != pDbName) {
+    printf("DbName %p : %d, %d, %s\n", pDbName, pDbName->type, pDbName->n, pDbName->z);
+    strncpy(realTable->dbName, pDbName->z, pDbName->n);
+  }
+  printf("TableName %p : %d, %d, %s\n", pTableName, pTableName->type, pTableName->n, pTableName->z);
+  strncpy(realTable->table.tableName, pTableName->z, pTableName->n);
+  return acquireRaii(pCxt, realTable);
+}
+
+SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable) {
+  SSelectStmt* select = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT);
+  select->isDistinct = isDistinct;
+  if (NULL == pProjectionList) {
+    select->isStar = true;
+  }
+  select->pProjectionList = releaseRaii(pCxt, pProjectionList);
+  printf("pTable = %p, name = %s\n", pTable, ((SRealTableNode*)pTable)->table.tableName);
+  select->pFromTable = releaseRaii(pCxt, pTable);
+  return acquireRaii(pCxt, select);
+}
+
+SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight) {
+
+}
+
+SNode* createShowStmt(SAstCreateContext* pCxt, EShowStmtType type) {
+
+}
+
+SNode* setProjectionAlias(SAstCreateContext* pCxt, SNode* pNode, const SToken* pAlias) {
+
+}
diff --git a/source/nodes/src/nodesUtil.c b/source/libs/parser/src/astTranslate.c
similarity index 84%
rename from source/nodes/src/nodesUtil.c
rename to source/libs/parser/src/astTranslate.c
index fe5883d809..ff68c4b22c 100644
--- a/source/nodes/src/nodesUtil.c
+++ b/source/libs/parser/src/astTranslate.c
@@ -13,12 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "nodes.h"
+// int32_t doTranslate() {
 
-bool isTimeorderQuery(const SNode* pQuery) {
-
-}
-
-bool isTimelineQuery(const SNode* pQuery) {
-
-}
+// }
diff --git a/source/libs/parser/src/astValidate.c b/source/libs/parser/src/astValidate.c
index 0a2f2b20f2..a56a6524fc 100644
--- a/source/libs/parser/src/astValidate.c
+++ b/source/libs/parser/src/astValidate.c
@@ -3644,6 +3644,7 @@ int32_t evaluateSqlNode(SSqlNode* pNode, int32_t tsPrecision, SMsgBuf* pMsgBuf)
   return TSDB_CODE_SUCCESS;
 }
 
+//TODO remove it
 int32_t setTableVgroupList(SParseContext *pCtx, SName* name, SVgroupsInfo **pVgList) {
   SArray* vgroupList = NULL;
   int32_t code = catalogGetTableDistVgroup(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, name, &vgroupList);
@@ -3651,21 +3652,17 @@ int32_t setTableVgroupList(SParseContext *pCtx, SName* name, SVgroupsInfo **pVgL
     return code;
   }
   
-  int32_t vgroupNum = taosArrayGetSize(vgroupList);
+  size_t vgroupNum = taosArrayGetSize(vgroupList);
 
-  SVgroupsInfo *vgList = calloc(1, sizeof(SVgroupsInfo) + sizeof(SVgroupMsg) * vgroupNum);
-  
+  SVgroupsInfo *vgList = calloc(1, sizeof(SVgroupsInfo) + sizeof(SVgroupInfo) * vgroupNum);
   vgList->numOfVgroups = vgroupNum;
   
   for (int32_t i = 0; i < vgroupNum; ++i) {
     SVgroupInfo *vg = taosArrayGet(vgroupList, i);
-    vgList->vgroups[i].vgId = vg->vgId;
-    vgList->vgroups[i].numOfEps = vg->numOfEps;
-    memcpy(vgList->vgroups[i].epAddr, vg->epAddr, sizeof(vgList->vgroups[i].epAddr));
+    vgList->vgroups[i] = *vg;
   }
 
   *pVgList = vgList;
-
   taosArrayDestroy(vgroupList);
 
   return TSDB_CODE_SUCCESS;
diff --git a/source/libs/parser/src/dCDAstProcess.c b/source/libs/parser/src/dCDAstProcess.c
index 06a9a3d16e..3ae89bca0a 100644
--- a/source/libs/parser/src/dCDAstProcess.c
+++ b/source/libs/parser/src/dCDAstProcess.c
@@ -58,13 +58,7 @@ static int32_t setShowInfo(SShowInfo* pShowInfo, SParseContext* pCtx, void** out
 
     SVgroupInfo* info = taosArrayGet(array, 0);
     pShowReq->head.vgId = htonl(info->vgId);
-    pEpSet->numOfEps = info->numOfEps;
-    pEpSet->inUse = info->inUse;
-
-    for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
-      strncpy(pEpSet->fqdn[i], info->epAddr[i].fqdn, tListLen(pEpSet->fqdn[i]));
-      pEpSet->port[i] = info->epAddr[i].port;
-    }
+    *pEpSet = info->epset;
 
     *outputLen  = sizeof(SVShowTablesReq);
     *output     = pShowReq;
diff --git a/source/libs/parser/src/new_sql.c b/source/libs/parser/src/new_sql.c
new file mode 100644
index 0000000000..7bf29c45f8
--- /dev/null
+++ b/source/libs/parser/src/new_sql.c
@@ -0,0 +1,1718 @@
+/*
+** 2000-05-29
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+** Driver template for the LEMON parser generator.
+**
+** The "lemon" program processes an LALR(1) input grammar file, then uses
+** this template to construct a parser.  The "lemon" program inserts text
+** at each "%%" line.  Also, any "P-a-r-s-e" identifer prefix (without the
+** interstitial "-" characters) contained in this template is changed into
+** the value of the %name directive from the grammar.  Otherwise, the content
+** of this template is copied straight through into the generate parser
+** source file.
+**
+** The following is the concatenation of all %include directives from the
+** input grammar file:
+*/
+#include <stdio.h>
+#include <assert.h>
+/************ Begin %include sections from the grammar ************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdbool.h>
+
+#include "nodes.h"
+#include "ttoken.h"
+#include "ttokendef.h"
+#include "astCreateFuncs.h"
+
+#define PARSER_TRACE printf("rule = %s\n", yyRuleName[yyruleno])
+/**************** End of %include directives **********************************/
+/* These constants specify the various numeric values for terminal symbols
+** in a format understandable to "makeheaders".  This section is blank unless
+** "lemon" is run with the "-m" command-line option.
+***************** Begin makeheaders token definitions *************************/
+/**************** End makeheaders token definitions ***************************/
+
+/* The next sections is a series of control #defines.
+** various aspects of the generated parser.
+**    YYCODETYPE         is the data type used to store the integer codes
+**                       that represent terminal and non-terminal symbols.
+**                       "unsigned char" is used if there are fewer than
+**                       256 symbols.  Larger types otherwise.
+**    YYNOCODE           is a number of type YYCODETYPE that is not used for
+**                       any terminal or nonterminal symbol.
+**    YYFALLBACK         If defined, this indicates that one or more tokens
+**                       (also known as: "terminal symbols") have fall-back
+**                       values which should be used if the original symbol
+**                       would not parse.  This permits keywords to sometimes
+**                       be used as identifiers, for example.
+**    YYACTIONTYPE       is the data type used for "action codes" - numbers
+**                       that indicate what to do in response to the next
+**                       token.
+**    NewParseTOKENTYPE     is the data type used for minor type for terminal
+**                       symbols.  Background: A "minor type" is a semantic
+**                       value associated with a terminal or non-terminal
+**                       symbols.  For example, for an "ID" terminal symbol,
+**                       the minor type might be the name of the identifier.
+**                       Each non-terminal can have a different minor type.
+**                       Terminal symbols all have the same minor type, though.
+**                       This macros defines the minor type for terminal 
+**                       symbols.
+**    YYMINORTYPE        is the data type used for all minor types.
+**                       This is typically a union of many types, one of
+**                       which is NewParseTOKENTYPE.  The entry in the union
+**                       for terminal symbols is called "yy0".
+**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
+**                       zero the stack is dynamically sized using realloc()
+**    NewParseARG_SDECL     A static variable declaration for the %extra_argument
+**    NewParseARG_PDECL     A parameter declaration for the %extra_argument
+**    NewParseARG_PARAM     Code to pass %extra_argument as a subroutine parameter
+**    NewParseARG_STORE     Code to store %extra_argument into yypParser
+**    NewParseARG_FETCH     Code to extract %extra_argument from yypParser
+**    NewParseCTX_*         As NewParseARG_ except for %extra_context
+**    YYERRORSYMBOL      is the code number of the error symbol.  If not
+**                       defined, then do no error processing.
+**    YYNSTATE           the combined number of states.
+**    YYNRULE            the number of rules in the grammar
+**    YYNTOKEN           Number of terminal symbols
+**    YY_MAX_SHIFT       Maximum value for shift actions
+**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
+**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
+**    YY_ERROR_ACTION    The yy_action[] code for syntax error
+**    YY_ACCEPT_ACTION   The yy_action[] code for accept
+**    YY_NO_ACTION       The yy_action[] code for no-op
+**    YY_MIN_REDUCE      Minimum value for reduce actions
+**    YY_MAX_REDUCE      Maximum value for reduce actions
+*/
+#ifndef INTERFACE
+# define INTERFACE 1
+#endif
+/************* Begin control #defines *****************************************/
+#define YYCODETYPE unsigned char
+#define YYNOCODE 71
+#define YYACTIONTYPE unsigned char
+#define NewParseTOKENTYPE  SToken 
+typedef union {
+  int yyinit;
+  NewParseTOKENTYPE yy0;
+  bool yy9;
+  SNodeList* yy30;
+  SToken yy67;
+  ENullOrder yy68;
+  EOrder yy108;
+  SNode* yy130;
+} YYMINORTYPE;
+#ifndef YYSTACKDEPTH
+#define YYSTACKDEPTH 100
+#endif
+#define NewParseARG_SDECL  SAstCreateContext* pCxt ;
+#define NewParseARG_PDECL , SAstCreateContext* pCxt 
+#define NewParseARG_PARAM ,pCxt 
+#define NewParseARG_FETCH  SAstCreateContext* pCxt =yypParser->pCxt ;
+#define NewParseARG_STORE yypParser->pCxt =pCxt ;
+#define NewParseCTX_SDECL
+#define NewParseCTX_PDECL
+#define NewParseCTX_PARAM
+#define NewParseCTX_FETCH
+#define NewParseCTX_STORE
+#define YYNSTATE             63
+#define YYNRULE              68
+#define YYNTOKEN             35
+#define YY_MAX_SHIFT         62
+#define YY_MIN_SHIFTREDUCE   114
+#define YY_MAX_SHIFTREDUCE   181
+#define YY_ERROR_ACTION      182
+#define YY_ACCEPT_ACTION     183
+#define YY_NO_ACTION         184
+#define YY_MIN_REDUCE        185
+#define YY_MAX_REDUCE        252
+/************* End control #defines *******************************************/
+#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage.  For production
+** code the yytestcase() macro should be turned off.  But it is useful
+** for testing.
+*/
+#ifndef yytestcase
+# define yytestcase(X)
+#endif
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token.  These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.  
+**
+** Suppose the action integer is N.  Then the action is determined as
+** follows
+**
+**   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead
+**                                      token onto the stack and goto state N.
+**
+**   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then
+**     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.
+**
+**   N == YY_ERROR_ACTION               A syntax error has occurred.
+**
+**   N == YY_ACCEPT_ACTION              The parser accepts its input.
+**
+**   N == YY_NO_ACTION                  No such action.  Denotes unused
+**                                      slots in the yy_action[] table.
+**
+**   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE
+**     and YY_MAX_REDUCE
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as either:
+**
+**    (A)   N = yy_action[ yy_shift_ofst[S] + X ]
+**    (B)   N = yy_default[S]
+**
+** The (A) formula is preferred.  The B formula is used instead if
+** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X.
+**
+** The formulas above are for computing the action when the lookahead is
+** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array.
+**
+** The following are the tables generated in this section:
+**
+**  yy_action[]        A single table containing all actions.
+**  yy_lookahead[]     A table containing the lookahead for each entry in
+**                     yy_action.  Used to detect hash collisions.
+**  yy_shift_ofst[]    For each state, the offset into yy_action for
+**                     shifting terminals.
+**  yy_reduce_ofst[]   For each state, the offset into yy_action for
+**                     shifting non-terminals after a reduce.
+**  yy_default[]       Default action for each state.
+**
+*********** Begin parsing tables **********************************************/
+#define YY_ACTTAB_COUNT (229)
+static const YYACTIONTYPE yy_action[] = {
+ /*     0 */    30,   50,   30,   30,   30,   30,   55,   50,   30,   30,
+ /*    10 */    10,    9,   29,   62,   51,  195,   30,   19,   30,   30,
+ /*    20 */    30,   30,   57,   19,   30,   30,   30,   19,   30,   30,
+ /*    30 */    30,   30,   57,   19,   30,   30,   30,   50,   30,   30,
+ /*    40 */    30,   30,   55,   50,   30,   30,   39,  222,  155,  156,
+ /*    50 */    23,  196,   12,   11,   10,    9,   25,  223,   30,   58,
+ /*    60 */    30,   30,   30,   30,   57,   58,   30,   30,   30,   59,
+ /*    70 */    30,   30,   30,   30,   57,   59,   30,   30,   30,   37,
+ /*    80 */    30,   30,   30,   30,   57,   37,   30,   30,  204,   38,
+ /*    90 */     5,  183,   60,  166,  158,  159,  121,   53,  200,  201,
+ /*   100 */   202,  203,   54,  203,  203,  203,  246,   18,  246,  246,
+ /*   110 */   246,  246,   57,  120,  246,  246,  245,   17,  245,  245,
+ /*   120 */   245,  245,   57,   46,  245,  245,   35,   27,   35,   35,
+ /*   130 */    35,   35,   57,   31,   35,   35,   36,   47,   36,   36,
+ /*   140 */    36,   36,   57,  128,   36,   36,  242,  117,  242,  242,
+ /*   150 */   242,  242,   57,   42,  241,  242,  241,  241,  241,  241,
+ /*   160 */    57,   52,  212,  241,   14,   13,  122,    1,  212,  212,
+ /*   170 */    38,    5,   14,   13,  166,   40,  224,   20,   38,    5,
+ /*   180 */    15,  210,  166,  211,   21,   22,   17,  210,  210,   43,
+ /*   190 */   160,    6,    7,   45,   41,   26,  207,   48,   24,  208,
+ /*   200 */   136,   44,  205,    8,  189,    3,  142,    2,   16,  127,
+ /*   210 */   147,  146,   32,  150,   49,  149,    4,   33,  180,  206,
+ /*   220 */    28,  117,   34,  186,   56,  162,  161,  185,   61,
+};
+static const YYCODETYPE yy_lookahead[] = {
+ /*     0 */    37,   38,   39,   40,   41,   42,   43,   44,   45,   46,
+ /*    10 */     8,    9,   49,   10,   51,   52,   37,   38,   39,   40,
+ /*    20 */    41,   42,   43,   44,   45,   46,   37,   38,   39,   40,
+ /*    30 */    41,   42,   43,   44,   45,   46,   37,   38,   39,   40,
+ /*    40 */    41,   42,   43,   44,   45,   46,   67,   68,   30,   31,
+ /*    50 */    69,   52,    6,    7,    8,    9,   63,   68,   37,   38,
+ /*    60 */    39,   40,   41,   42,   43,   44,   45,   46,   37,   38,
+ /*    70 */    39,   40,   41,   42,   43,   44,   45,   46,   37,   38,
+ /*    80 */    39,   40,   41,   42,   43,   44,   45,   46,   43,   12,
+ /*    90 */    13,   35,   36,   16,   33,   34,    2,   12,   53,   54,
+ /*   100 */    55,   56,   57,   58,   59,   60,   37,   22,   39,   40,
+ /*   110 */    41,   42,   43,   19,   45,   46,   37,   61,   39,   40,
+ /*   120 */    41,   42,   43,   15,   45,   46,   37,   63,   39,   40,
+ /*   130 */    41,   42,   43,   32,   45,   46,   37,   29,   39,   40,
+ /*   140 */    41,   42,   43,    8,   45,   46,   37,   12,   39,   40,
+ /*   150 */    41,   42,   43,    1,   37,   46,   39,   40,   41,   42,
+ /*   160 */    43,   36,   47,   46,    6,    7,    8,   48,   47,   47,
+ /*   170 */    12,   13,    6,    7,   16,   23,   70,   62,   12,   13,
+ /*   180 */    13,   66,   16,   62,   62,   18,   61,   66,   66,   15,
+ /*   190 */    14,   15,   13,   25,   64,   64,   17,   28,   65,   65,
+ /*   200 */    12,   27,   43,   21,   50,   15,   14,   24,    2,   12,
+ /*   210 */    26,   26,   26,   26,   20,   26,   15,   26,   14,   17,
+ /*   220 */    17,   12,   17,    0,   17,   14,   14,    0,   11,   71,
+ /*   230 */    71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
+ /*   240 */    71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
+ /*   250 */    71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
+ /*   260 */    71,   71,   71,   71,
+};
+#define YY_SHIFT_COUNT    (62)
+#define YY_SHIFT_MIN      (0)
+#define YY_SHIFT_MAX      (227)
+static const unsigned short int yy_shift_ofst[] = {
+ /*     0 */     3,  158,  166,  166,  166,  166,  166,  166,   85,  166,
+ /*    10 */   166,  166,  166,   77,   77,  167,  167,  167,  229,   18,
+ /*    20 */   152,  152,   94,  101,  168,  169,  169,  168,  188,  182,
+ /*    30 */    46,   61,  174,  108,  135,    2,    2,  176,  179,  190,
+ /*    40 */   183,  192,  206,  184,  185,  186,  187,  189,  191,  197,
+ /*    50 */   194,  201,  204,  202,  203,  205,  209,  207,  211,  212,
+ /*    60 */   223,  227,  217,
+};
+#define YY_REDUCE_COUNT (29)
+#define YY_REDUCE_MIN   (-37)
+#define YY_REDUCE_MAX   (159)
+static const short yy_reduce_ofst[] = {
+ /*     0 */    56,  -37,  -21,  -11,   -1,   21,   31,   41,   45,   69,
+ /*    10 */    79,   89,   99,  109,  117,  115,  121,  122,  125,  -19,
+ /*    20 */    -7,   64,  119,  106,  130,  133,  134,  131,  159,  154,
+};
+static const YYACTIONTYPE yy_default[] = {
+ /*     0 */   209,  182,  182,  182,  182,  182,  182,  182,  182,  182,
+ /*    10 */   182,  182,  182,  182,  182,  182,  182,  182,  209,  225,
+ /*    20 */   214,  214,  190,  228,  216,  219,  219,  216,  182,  182,
+ /*    30 */   239,  182,  182,  182,  182,  244,  243,  182,  187,  215,
+ /*    40 */   182,  182,  182,  182,  182,  182,  182,  182,  182,  182,
+ /*    50 */   197,  194,  182,  207,  182,  182,  182,  182,  182,  182,
+ /*    60 */   182,  182,  182,
+};
+/********** End of lemon-generated parsing tables *****************************/
+
+/* The next table maps tokens (terminal symbols) into fallback tokens.  
+** If a construct like the following:
+** 
+**      %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+**
+** This feature can be used, for example, to cause some keywords in a language
+** to revert to identifiers if they keyword does not apply in the context where
+** it appears.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack.  Information stored includes:
+**
+**   +  The state number for the parser at this level of the stack.
+**
+**   +  The value of the token stored at this level of the stack.
+**      (In other words, the "major" token.)
+**
+**   +  The semantic value stored at this level of the stack.  This is
+**      the information used by the action routines in the grammar.
+**      It is sometimes called the "minor" token.
+**
+** After the "shift" half of a SHIFTREDUCE action, the stateno field
+** actually contains the reduce action for the second half of the
+** SHIFTREDUCE.
+*/
+struct yyStackEntry {
+  YYACTIONTYPE stateno;  /* The state-number, or reduce action in SHIFTREDUCE */
+  YYCODETYPE major;      /* The major token value.  This is the code
+                         ** number for the token at this stack level */
+  YYMINORTYPE minor;     /* The user-supplied minor token value.  This
+                         ** is the value of the token  */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+  yyStackEntry *yytos;          /* Pointer to top element of the stack */
+#ifdef YYTRACKMAXSTACKDEPTH
+  int yyhwm;                    /* High-water mark of the stack */
+#endif
+#ifndef YYNOERRORRECOVERY
+  int yyerrcnt;                 /* Shifts left before out of the error */
+#endif
+  NewParseARG_SDECL                /* A place to hold %extra_argument */
+  NewParseCTX_SDECL                /* A place to hold %extra_context */
+#if YYSTACKDEPTH<=0
+  int yystksz;                  /* Current side of the stack */
+  yyStackEntry *yystack;        /* The parser's stack */
+  yyStackEntry yystk0;          /* First stack entry */
+#else
+  yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
+  yyStackEntry *yystackEnd;            /* Last entry in the stack */
+#endif
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+#include <stdio.h>
+static FILE *yyTraceFILE = 0;
+static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* 
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message.  Tracing is turned off
+** by making either argument NULL 
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+**      If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+**      line of trace output.  If NULL, then tracing is
+**      turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void NewParseTrace(FILE *TraceFILE, char *zTracePrompt){
+  yyTraceFILE = TraceFILE;
+  yyTracePrompt = zTracePrompt;
+  if( yyTraceFILE==0 ) yyTracePrompt = 0;
+  else if( yyTracePrompt==0 ) yyTraceFILE = 0;
+}
+#endif /* NDEBUG */
+
+#if defined(YYCOVERAGE) || !defined(NDEBUG)
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required.  The following table supplies these names */
+static const char *const yyTokenName[] = { 
+  /*    0 */ "$",
+  /*    1 */ "UNION",
+  /*    2 */ "ALL",
+  /*    3 */ "MINUS",
+  /*    4 */ "EXCEPT",
+  /*    5 */ "INTERSECT",
+  /*    6 */ "NK_PLUS",
+  /*    7 */ "NK_MINUS",
+  /*    8 */ "NK_STAR",
+  /*    9 */ "NK_SLASH",
+  /*   10 */ "SHOW",
+  /*   11 */ "DATABASES",
+  /*   12 */ "NK_ID",
+  /*   13 */ "NK_LP",
+  /*   14 */ "NK_RP",
+  /*   15 */ "NK_COMMA",
+  /*   16 */ "NK_LITERAL",
+  /*   17 */ "NK_DOT",
+  /*   18 */ "SELECT",
+  /*   19 */ "DISTINCT",
+  /*   20 */ "AS",
+  /*   21 */ "FROM",
+  /*   22 */ "NK_LR",
+  /*   23 */ "ORDER",
+  /*   24 */ "BY",
+  /*   25 */ "SLIMIT",
+  /*   26 */ "NK_INTEGER",
+  /*   27 */ "SOFFSET",
+  /*   28 */ "LIMIT",
+  /*   29 */ "OFFSET",
+  /*   30 */ "ASC",
+  /*   31 */ "DESC",
+  /*   32 */ "NULLS",
+  /*   33 */ "FIRST",
+  /*   34 */ "LAST",
+  /*   35 */ "cmd",
+  /*   36 */ "query_expression",
+  /*   37 */ "value_function",
+  /*   38 */ "value_expression",
+  /*   39 */ "value_expression_primary",
+  /*   40 */ "nonparenthesized_value_expression_primary",
+  /*   41 */ "literal",
+  /*   42 */ "column_reference",
+  /*   43 */ "table_name",
+  /*   44 */ "common_value_expression",
+  /*   45 */ "numeric_value_expression",
+  /*   46 */ "numeric_primary",
+  /*   47 */ "query_specification",
+  /*   48 */ "set_quantifier_opt",
+  /*   49 */ "select_list",
+  /*   50 */ "from_clause",
+  /*   51 */ "select_sublist",
+  /*   52 */ "select_item",
+  /*   53 */ "table_reference_list",
+  /*   54 */ "table_reference",
+  /*   55 */ "table_factor",
+  /*   56 */ "table_primary",
+  /*   57 */ "db_name",
+  /*   58 */ "derived_table",
+  /*   59 */ "table_subquery",
+  /*   60 */ "subquery",
+  /*   61 */ "with_clause_opt",
+  /*   62 */ "query_expression_body",
+  /*   63 */ "order_by_clause_opt",
+  /*   64 */ "slimit_clause_opt",
+  /*   65 */ "limit_clause_opt",
+  /*   66 */ "query_primary",
+  /*   67 */ "sort_specification_list",
+  /*   68 */ "sort_specification",
+  /*   69 */ "ordering_specification_opt",
+  /*   70 */ "null_ordering_opt",
+};
+#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+ /*   0 */ "cmd ::= SHOW DATABASES",
+ /*   1 */ "cmd ::= query_expression",
+ /*   2 */ "column_reference ::= NK_ID",
+ /*   3 */ "column_reference ::= table_name NK_DOT NK_ID",
+ /*   4 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause",
+ /*   5 */ "set_quantifier_opt ::=",
+ /*   6 */ "set_quantifier_opt ::= DISTINCT",
+ /*   7 */ "set_quantifier_opt ::= ALL",
+ /*   8 */ "select_list ::= NK_STAR",
+ /*   9 */ "select_list ::= select_sublist",
+ /*  10 */ "select_sublist ::= select_item",
+ /*  11 */ "select_sublist ::= select_sublist NK_COMMA select_item",
+ /*  12 */ "select_item ::= value_expression",
+ /*  13 */ "select_item ::= value_expression AS NK_ID",
+ /*  14 */ "select_item ::= table_name NK_DOT NK_STAR",
+ /*  15 */ "from_clause ::= FROM table_reference_list",
+ /*  16 */ "table_reference_list ::= table_reference",
+ /*  17 */ "table_reference ::= table_factor",
+ /*  18 */ "table_factor ::= table_primary",
+ /*  19 */ "table_primary ::= table_name",
+ /*  20 */ "table_primary ::= db_name NK_DOT table_name",
+ /*  21 */ "db_name ::= NK_ID",
+ /*  22 */ "table_name ::= NK_ID",
+ /*  23 */ "query_expression ::= with_clause_opt query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt",
+ /*  24 */ "with_clause_opt ::=",
+ /*  25 */ "query_expression_body ::= query_primary",
+ /*  26 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body",
+ /*  27 */ "query_primary ::= query_specification",
+ /*  28 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt limit_clause_opt slimit_clause_opt NK_RP",
+ /*  29 */ "order_by_clause_opt ::=",
+ /*  30 */ "order_by_clause_opt ::= ORDER BY sort_specification_list",
+ /*  31 */ "slimit_clause_opt ::=",
+ /*  32 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER",
+ /*  33 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /*  34 */ "limit_clause_opt ::=",
+ /*  35 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER",
+ /*  36 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER",
+ /*  37 */ "sort_specification_list ::= sort_specification",
+ /*  38 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification",
+ /*  39 */ "sort_specification ::= value_expression ordering_specification_opt null_ordering_opt",
+ /*  40 */ "ordering_specification_opt ::=",
+ /*  41 */ "ordering_specification_opt ::= ASC",
+ /*  42 */ "ordering_specification_opt ::= DESC",
+ /*  43 */ "null_ordering_opt ::=",
+ /*  44 */ "null_ordering_opt ::= NULLS FIRST",
+ /*  45 */ "null_ordering_opt ::= NULLS LAST",
+ /*  46 */ "value_function ::= NK_ID NK_LP value_expression NK_RP",
+ /*  47 */ "value_function ::= NK_ID NK_LP value_expression NK_COMMA value_expression NK_RP",
+ /*  48 */ "value_expression_primary ::= NK_LP value_expression NK_RP",
+ /*  49 */ "value_expression_primary ::= nonparenthesized_value_expression_primary",
+ /*  50 */ "nonparenthesized_value_expression_primary ::= literal",
+ /*  51 */ "nonparenthesized_value_expression_primary ::= column_reference",
+ /*  52 */ "literal ::= NK_LITERAL",
+ /*  53 */ "value_expression ::= common_value_expression",
+ /*  54 */ "common_value_expression ::= numeric_value_expression",
+ /*  55 */ "numeric_value_expression ::= numeric_primary",
+ /*  56 */ "numeric_value_expression ::= NK_PLUS numeric_primary",
+ /*  57 */ "numeric_value_expression ::= NK_MINUS numeric_primary",
+ /*  58 */ "numeric_value_expression ::= numeric_value_expression NK_PLUS numeric_value_expression",
+ /*  59 */ "numeric_value_expression ::= numeric_value_expression NK_MINUS numeric_value_expression",
+ /*  60 */ "numeric_value_expression ::= numeric_value_expression NK_STAR numeric_value_expression",
+ /*  61 */ "numeric_value_expression ::= numeric_value_expression NK_SLASH numeric_value_expression",
+ /*  62 */ "numeric_primary ::= value_expression_primary",
+ /*  63 */ "numeric_primary ::= value_function",
+ /*  64 */ "table_primary ::= derived_table",
+ /*  65 */ "derived_table ::= table_subquery",
+ /*  66 */ "subquery ::= NK_LR query_expression NK_RP",
+ /*  67 */ "table_subquery ::= subquery",
+};
+#endif /* NDEBUG */
+
+
+#if YYSTACKDEPTH<=0
+/*
+** Try to increase the size of the parser stack.  Return the number
+** of errors.  Return 0 on success.
+*/
+static int yyGrowStack(yyParser *p){
+  int newSize;
+  int idx;
+  yyStackEntry *pNew;
+
+  newSize = p->yystksz*2 + 100;
+  idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;
+  if( p->yystack==&p->yystk0 ){
+    pNew = malloc(newSize*sizeof(pNew[0]));
+    if( pNew ) pNew[0] = p->yystk0;
+  }else{
+    pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
+  }
+  if( pNew ){
+    p->yystack = pNew;
+    p->yytos = &p->yystack[idx];
+#ifndef NDEBUG
+    if( yyTraceFILE ){
+      fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",
+              yyTracePrompt, p->yystksz, newSize);
+    }
+#endif
+    p->yystksz = newSize;
+  }
+  return pNew==0; 
+}
+#endif
+
+/* Datatype of the argument to the memory allocated passed as the
+** second argument to NewParseAlloc() below.  This can be changed by
+** putting an appropriate #define in the %include section of the input
+** grammar.
+*/
+#ifndef YYMALLOCARGTYPE
+# define YYMALLOCARGTYPE size_t
+#endif
+
+/* Initialize a new parser that has already been allocated.
+*/
+void NewParseInit(void *yypRawParser NewParseCTX_PDECL){
+  yyParser *yypParser = (yyParser*)yypRawParser;
+  NewParseCTX_STORE
+#ifdef YYTRACKMAXSTACKDEPTH
+  yypParser->yyhwm = 0;
+#endif
+#if YYSTACKDEPTH<=0
+  yypParser->yytos = NULL;
+  yypParser->yystack = NULL;
+  yypParser->yystksz = 0;
+  if( yyGrowStack(yypParser) ){
+    yypParser->yystack = &yypParser->yystk0;
+    yypParser->yystksz = 1;
+  }
+#endif
+#ifndef YYNOERRORRECOVERY
+  yypParser->yyerrcnt = -1;
+#endif
+  yypParser->yytos = yypParser->yystack;
+  yypParser->yystack[0].stateno = 0;
+  yypParser->yystack[0].major = 0;
+#if YYSTACKDEPTH>0
+  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
+#endif
+}
+
+#ifndef NewParse_ENGINEALWAYSONSTACK
+/* 
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser.  This pointer is used in subsequent calls
+** to NewParse and NewParseFree.
+*/
+void *NewParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) NewParseCTX_PDECL){
+  yyParser *yypParser;
+  yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
+  if( yypParser ){
+    NewParseCTX_STORE
+    NewParseInit(yypParser NewParseCTX_PARAM);
+  }
+  return (void*)yypParser;
+}
+#endif /* NewParse_ENGINEALWAYSONSTACK */
+
+
+/* The following function deletes the "minor type" or semantic value
+** associated with a symbol.  The symbol can be either a terminal
+** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
+** a pointer to the value to be deleted.  The code used to do the 
+** deletions is derived from the %destructor and/or %token_destructor
+** directives of the input grammar.
+*/
+static void yy_destructor(
+  yyParser *yypParser,    /* The parser */
+  YYCODETYPE yymajor,     /* Type code for object to destroy */
+  YYMINORTYPE *yypminor   /* The object to be destroyed */
+){
+  NewParseARG_FETCH
+  NewParseCTX_FETCH
+  switch( yymajor ){
+    /* Here is inserted the actions which take place when a
+    ** terminal or non-terminal is destroyed.  This can happen
+    ** when the symbol is popped from the stack during a
+    ** reduce or during error processing or when a parser is 
+    ** being destroyed before it is finished parsing.
+    **
+    ** Note: during a reduce, the only symbols destroyed are those
+    ** which appear on the RHS of the rule, but which are *not* used
+    ** inside the C code.
+    */
+/********* Begin destructor definitions ***************************************/
+      /* Default NON-TERMINAL Destructor */
+    case 35: /* cmd */
+    case 36: /* query_expression */
+    case 37: /* value_function */
+    case 38: /* value_expression */
+    case 39: /* value_expression_primary */
+    case 40: /* nonparenthesized_value_expression_primary */
+    case 41: /* literal */
+    case 42: /* column_reference */
+    case 43: /* table_name */
+    case 44: /* common_value_expression */
+    case 45: /* numeric_value_expression */
+    case 46: /* numeric_primary */
+    case 47: /* query_specification */
+    case 50: /* from_clause */
+    case 52: /* select_item */
+    case 53: /* table_reference_list */
+    case 54: /* table_reference */
+    case 55: /* table_factor */
+    case 56: /* table_primary */
+    case 57: /* db_name */
+    case 58: /* derived_table */
+    case 59: /* table_subquery */
+    case 60: /* subquery */
+    case 61: /* with_clause_opt */
+    case 62: /* query_expression_body */
+    case 64: /* slimit_clause_opt */
+    case 65: /* limit_clause_opt */
+    case 66: /* query_primary */
+    case 68: /* sort_specification */
+{
+ nodesDestroyNode((yypminor->yy130)); 
+}
+      break;
+    case 48: /* set_quantifier_opt */
+{
+
+}
+      break;
+    case 49: /* select_list */
+    case 51: /* select_sublist */
+    case 63: /* order_by_clause_opt */
+    case 67: /* sort_specification_list */
+{
+ nodesDestroyNodeList((yypminor->yy30)); 
+}
+      break;
+    case 69: /* ordering_specification_opt */
+{
+
+}
+      break;
+    case 70: /* null_ordering_opt */
+{
+
+}
+      break;
+/********* End destructor definitions *****************************************/
+    default:  break;   /* If no destructor action specified: do nothing */
+  }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+*/
+static void yy_pop_parser_stack(yyParser *pParser){
+  yyStackEntry *yytos;
+  assert( pParser->yytos!=0 );
+  assert( pParser->yytos > pParser->yystack );
+  yytos = pParser->yytos--;
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sPopping %s\n",
+      yyTracePrompt,
+      yyTokenName[yytos->major]);
+  }
+#endif
+  yy_destructor(pParser, yytos->major, &yytos->minor);
+}
+
+/*
+** Clear all secondary memory allocations from the parser
+*/
+void NewParseFinalize(void *p){
+  yyParser *pParser = (yyParser*)p;
+  while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser);
+#if YYSTACKDEPTH<=0
+  if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack);
+#endif
+}
+
+#ifndef NewParse_ENGINEALWAYSONSTACK
+/* 
+** Deallocate and destroy a parser.  Destructors are called for
+** all stack elements before shutting the parser down.
+**
+** If the YYPARSEFREENEVERNULL macro exists (for example because it
+** is defined in a %include section of the input grammar) then it is
+** assumed that the input pointer is never NULL.
+*/
+void NewParseFree(
+  void *p,                    /* The parser to be deleted */
+  void (*freeProc)(void*)     /* Function used to reclaim memory */
+){
+#ifndef YYPARSEFREENEVERNULL
+  if( p==0 ) return;
+#endif
+  NewParseFinalize(p);
+  (*freeProc)(p);
+}
+#endif /* NewParse_ENGINEALWAYSONSTACK */
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+#ifdef YYTRACKMAXSTACKDEPTH
+int NewParseStackPeak(void *p){
+  yyParser *pParser = (yyParser*)p;
+  return pParser->yyhwm;
+}
+#endif
+
+/* This array of booleans keeps track of the parser statement
+** coverage.  The element yycoverage[X][Y] is set when the parser
+** is in state X and has a lookahead token Y.  In a well-tested
+** systems, every element of this matrix should end up being set.
+*/
+#if defined(YYCOVERAGE)
+static unsigned char yycoverage[YYNSTATE][YYNTOKEN];
+#endif
+
+/*
+** Write into out a description of every state/lookahead combination that
+**
+**   (1)  has not been used by the parser, and
+**   (2)  is not a syntax error.
+**
+** Return the number of missed state/lookahead combinations.
+*/
+#if defined(YYCOVERAGE)
+int NewParseCoverage(FILE *out){
+  int stateno, iLookAhead, i;
+  int nMissed = 0;
+  for(stateno=0; stateno<YYNSTATE; stateno++){
+    i = yy_shift_ofst[stateno];
+    for(iLookAhead=0; iLookAhead<YYNTOKEN; iLookAhead++){
+      if( yy_lookahead[i+iLookAhead]!=iLookAhead ) continue;
+      if( yycoverage[stateno][iLookAhead]==0 ) nMissed++;
+      if( out ){
+        fprintf(out,"State %d lookahead %s %s\n", stateno,
+                yyTokenName[iLookAhead],
+                yycoverage[stateno][iLookAhead] ? "ok" : "missed");
+      }
+    }
+  }
+  return nMissed;
+}
+#endif
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+*/
+static YYACTIONTYPE yy_find_shift_action(
+  YYCODETYPE iLookAhead,    /* The look-ahead token */
+  YYACTIONTYPE stateno      /* Current state number */
+){
+  int i;
+
+  if( stateno>YY_MAX_SHIFT ) return stateno;
+  assert( stateno <= YY_SHIFT_COUNT );
+#if defined(YYCOVERAGE)
+  yycoverage[stateno][iLookAhead] = 1;
+#endif
+  do{
+    i = yy_shift_ofst[stateno];
+    assert( i>=0 );
+    /* assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); */
+    assert( iLookAhead!=YYNOCODE );
+    assert( iLookAhead < YYNTOKEN );
+    i += iLookAhead;
+    if( i>=YY_NLOOKAHEAD || yy_lookahead[i]!=iLookAhead ){
+#ifdef YYFALLBACK
+      YYCODETYPE iFallback;            /* Fallback token */
+      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+             && (iFallback = yyFallback[iLookAhead])!=0 ){
+#ifndef NDEBUG
+        if( yyTraceFILE ){
+          fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+             yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+        }
+#endif
+        assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
+        iLookAhead = iFallback;
+        continue;
+      }
+#endif
+#ifdef YYWILDCARD
+      {
+        int j = i - iLookAhead + YYWILDCARD;
+        if( 
+#if YY_SHIFT_MIN+YYWILDCARD<0
+          j>=0 &&
+#endif
+#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+          j<YY_ACTTAB_COUNT &&
+#endif
+          j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) &&
+          yy_lookahead[j]==YYWILDCARD && iLookAhead>0
+        ){
+#ifndef NDEBUG
+          if( yyTraceFILE ){
+            fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
+               yyTracePrompt, yyTokenName[iLookAhead],
+               yyTokenName[YYWILDCARD]);
+          }
+#endif /* NDEBUG */
+          return yy_action[j];
+        }
+      }
+#endif /* YYWILDCARD */
+      return yy_default[stateno];
+    }else{
+      return yy_action[i];
+    }
+  }while(1);
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+*/
+static YYACTIONTYPE yy_find_reduce_action(
+  YYACTIONTYPE stateno,     /* Current state number */
+  YYCODETYPE iLookAhead     /* The look-ahead token */
+){
+  int i;
+#ifdef YYERRORSYMBOL
+  if( stateno>YY_REDUCE_COUNT ){
+    return yy_default[stateno];
+  }
+#else
+  assert( stateno<=YY_REDUCE_COUNT );
+#endif
+  i = yy_reduce_ofst[stateno];
+  assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+#ifdef YYERRORSYMBOL
+  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
+    return yy_default[stateno];
+  }
+#else
+  assert( i>=0 && i<YY_ACTTAB_COUNT );
+  assert( yy_lookahead[i]==iLookAhead );
+#endif
+  return yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+static void yyStackOverflow(yyParser *yypParser){
+   NewParseARG_FETCH
+   NewParseCTX_FETCH
+#ifndef NDEBUG
+   if( yyTraceFILE ){
+     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
+   }
+#endif
+   while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
+   /* Here code is inserted which will execute if the parser
+   ** stack every overflows */
+/******** Begin %stack_overflow code ******************************************/
+/******** End %stack_overflow code ********************************************/
+   NewParseARG_STORE /* Suppress warning about unused %extra_argument var */
+   NewParseCTX_STORE
+}
+
+/*
+** Print tracing information for a SHIFT action
+*/
+#ifndef NDEBUG
+static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){
+  if( yyTraceFILE ){
+    if( yyNewState<YYNSTATE ){
+      fprintf(yyTraceFILE,"%s%s '%s', go to state %d\n",
+         yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],
+         yyNewState);
+    }else{
+      fprintf(yyTraceFILE,"%s%s '%s', pending reduce %d\n",
+         yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],
+         yyNewState - YY_MIN_REDUCE);
+    }
+  }
+}
+#else
+# define yyTraceShift(X,Y,Z)
+#endif
+
+/*
+** Perform a shift action.
+*/
+static void yy_shift(
+  yyParser *yypParser,          /* The parser to be shifted */
+  YYACTIONTYPE yyNewState,      /* The new state to shift in */
+  YYCODETYPE yyMajor,           /* The major token to shift in */
+  NewParseTOKENTYPE yyMinor        /* The minor token to shift in */
+){
+  yyStackEntry *yytos;
+  yypParser->yytos++;
+#ifdef YYTRACKMAXSTACKDEPTH
+  if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
+    yypParser->yyhwm++;
+    assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
+  }
+#endif
+#if YYSTACKDEPTH>0 
+  if( yypParser->yytos>yypParser->yystackEnd ){
+    yypParser->yytos--;
+    yyStackOverflow(yypParser);
+    return;
+  }
+#else
+  if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){
+    if( yyGrowStack(yypParser) ){
+      yypParser->yytos--;
+      yyStackOverflow(yypParser);
+      return;
+    }
+  }
+#endif
+  if( yyNewState > YY_MAX_SHIFT ){
+    yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
+  }
+  yytos = yypParser->yytos;
+  yytos->stateno = yyNewState;
+  yytos->major = yyMajor;
+  yytos->minor.yy0 = yyMinor;
+  yyTraceShift(yypParser, yyNewState, "Shift");
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+  YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
+  signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
+} yyRuleInfo[] = {
+  {   35,   -2 }, /* (0) cmd ::= SHOW DATABASES */
+  {   35,   -1 }, /* (1) cmd ::= query_expression */
+  {   42,   -1 }, /* (2) column_reference ::= NK_ID */
+  {   42,   -3 }, /* (3) column_reference ::= table_name NK_DOT NK_ID */
+  {   47,   -4 }, /* (4) query_specification ::= SELECT set_quantifier_opt select_list from_clause */
+  {   48,    0 }, /* (5) set_quantifier_opt ::= */
+  {   48,   -1 }, /* (6) set_quantifier_opt ::= DISTINCT */
+  {   48,   -1 }, /* (7) set_quantifier_opt ::= ALL */
+  {   49,   -1 }, /* (8) select_list ::= NK_STAR */
+  {   49,   -1 }, /* (9) select_list ::= select_sublist */
+  {   51,   -1 }, /* (10) select_sublist ::= select_item */
+  {   51,   -3 }, /* (11) select_sublist ::= select_sublist NK_COMMA select_item */
+  {   52,   -1 }, /* (12) select_item ::= value_expression */
+  {   52,   -3 }, /* (13) select_item ::= value_expression AS NK_ID */
+  {   52,   -3 }, /* (14) select_item ::= table_name NK_DOT NK_STAR */
+  {   50,   -2 }, /* (15) from_clause ::= FROM table_reference_list */
+  {   53,   -1 }, /* (16) table_reference_list ::= table_reference */
+  {   54,   -1 }, /* (17) table_reference ::= table_factor */
+  {   55,   -1 }, /* (18) table_factor ::= table_primary */
+  {   56,   -1 }, /* (19) table_primary ::= table_name */
+  {   56,   -3 }, /* (20) table_primary ::= db_name NK_DOT table_name */
+  {   57,   -1 }, /* (21) db_name ::= NK_ID */
+  {   43,   -1 }, /* (22) table_name ::= NK_ID */
+  {   36,   -5 }, /* (23) query_expression ::= with_clause_opt query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+  {   61,    0 }, /* (24) with_clause_opt ::= */
+  {   62,   -1 }, /* (25) query_expression_body ::= query_primary */
+  {   62,   -4 }, /* (26) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+  {   66,   -1 }, /* (27) query_primary ::= query_specification */
+  {   66,   -6 }, /* (28) query_primary ::= NK_LP query_expression_body order_by_clause_opt limit_clause_opt slimit_clause_opt NK_RP */
+  {   63,    0 }, /* (29) order_by_clause_opt ::= */
+  {   63,   -3 }, /* (30) order_by_clause_opt ::= ORDER BY sort_specification_list */
+  {   64,    0 }, /* (31) slimit_clause_opt ::= */
+  {   64,   -4 }, /* (32) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+  {   64,   -4 }, /* (33) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+  {   65,    0 }, /* (34) limit_clause_opt ::= */
+  {   65,   -4 }, /* (35) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+  {   65,   -4 }, /* (36) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+  {   67,   -1 }, /* (37) sort_specification_list ::= sort_specification */
+  {   67,   -3 }, /* (38) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+  {   68,   -3 }, /* (39) sort_specification ::= value_expression ordering_specification_opt null_ordering_opt */
+  {   69,    0 }, /* (40) ordering_specification_opt ::= */
+  {   69,   -1 }, /* (41) ordering_specification_opt ::= ASC */
+  {   69,   -1 }, /* (42) ordering_specification_opt ::= DESC */
+  {   70,    0 }, /* (43) null_ordering_opt ::= */
+  {   70,   -2 }, /* (44) null_ordering_opt ::= NULLS FIRST */
+  {   70,   -2 }, /* (45) null_ordering_opt ::= NULLS LAST */
+  {   37,   -4 }, /* (46) value_function ::= NK_ID NK_LP value_expression NK_RP */
+  {   37,   -6 }, /* (47) value_function ::= NK_ID NK_LP value_expression NK_COMMA value_expression NK_RP */
+  {   39,   -3 }, /* (48) value_expression_primary ::= NK_LP value_expression NK_RP */
+  {   39,   -1 }, /* (49) value_expression_primary ::= nonparenthesized_value_expression_primary */
+  {   40,   -1 }, /* (50) nonparenthesized_value_expression_primary ::= literal */
+  {   40,   -1 }, /* (51) nonparenthesized_value_expression_primary ::= column_reference */
+  {   41,   -1 }, /* (52) literal ::= NK_LITERAL */
+  {   38,   -1 }, /* (53) value_expression ::= common_value_expression */
+  {   44,   -1 }, /* (54) common_value_expression ::= numeric_value_expression */
+  {   45,   -1 }, /* (55) numeric_value_expression ::= numeric_primary */
+  {   45,   -2 }, /* (56) numeric_value_expression ::= NK_PLUS numeric_primary */
+  {   45,   -2 }, /* (57) numeric_value_expression ::= NK_MINUS numeric_primary */
+  {   45,   -3 }, /* (58) numeric_value_expression ::= numeric_value_expression NK_PLUS numeric_value_expression */
+  {   45,   -3 }, /* (59) numeric_value_expression ::= numeric_value_expression NK_MINUS numeric_value_expression */
+  {   45,   -3 }, /* (60) numeric_value_expression ::= numeric_value_expression NK_STAR numeric_value_expression */
+  {   45,   -3 }, /* (61) numeric_value_expression ::= numeric_value_expression NK_SLASH numeric_value_expression */
+  {   46,   -1 }, /* (62) numeric_primary ::= value_expression_primary */
+  {   46,   -1 }, /* (63) numeric_primary ::= value_function */
+  {   56,   -1 }, /* (64) table_primary ::= derived_table */
+  {   58,   -1 }, /* (65) derived_table ::= table_subquery */
+  {   60,   -3 }, /* (66) subquery ::= NK_LR query_expression NK_RP */
+  {   59,   -1 }, /* (67) table_subquery ::= subquery */
+};
+
+static void yy_accept(yyParser*);  /* Forward Declaration */
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+**
+** The yyLookahead and yyLookaheadToken parameters provide reduce actions
+** access to the lookahead token (if any).  The yyLookahead will be YYNOCODE
+** if the lookahead token has already been consumed.  As this procedure is
+** only called from one place, optimizing compilers will in-line it, which
+** means that the extra parameters have no performance impact.
+*/
+static YYACTIONTYPE yy_reduce(
+  yyParser *yypParser,         /* The parser */
+  unsigned int yyruleno,       /* Number of the rule by which to reduce */
+  int yyLookahead,             /* Lookahead token, or YYNOCODE if none */
+  NewParseTOKENTYPE yyLookaheadToken  /* Value of the lookahead token */
+  NewParseCTX_PDECL                   /* %extra_context */
+){
+  int yygoto;                     /* The next state */
+  YYACTIONTYPE yyact;             /* The next action */
+  yyStackEntry *yymsp;            /* The top of the parser's stack */
+  int yysize;                     /* Amount to pop the stack */
+  NewParseARG_FETCH
+  (void)yyLookahead;
+  (void)yyLookaheadToken;
+  yymsp = yypParser->yytos;
+#ifndef NDEBUG
+  if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
+    yysize = yyRuleInfo[yyruleno].nrhs;
+    if( yysize ){
+      fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n",
+        yyTracePrompt,
+        yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno);
+    }else{
+      fprintf(yyTraceFILE, "%sReduce %d [%s].\n",
+        yyTracePrompt, yyruleno, yyRuleName[yyruleno]);
+    }
+  }
+#endif /* NDEBUG */
+
+  /* Check that the stack is large enough to grow by a single entry
+  ** if the RHS of the rule is empty.  This ensures that there is room
+  ** enough on the stack to push the LHS value */
+  if( yyRuleInfo[yyruleno].nrhs==0 ){
+#ifdef YYTRACKMAXSTACKDEPTH
+    if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
+      yypParser->yyhwm++;
+      assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
+    }
+#endif
+#if YYSTACKDEPTH>0 
+    if( yypParser->yytos>=yypParser->yystackEnd ){
+      yyStackOverflow(yypParser);
+      /* The call to yyStackOverflow() above pops the stack until it is
+      ** empty, causing the main parser loop to exit.  So the return value
+      ** is never used and does not matter. */
+      return 0;
+    }
+#else
+    if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
+      if( yyGrowStack(yypParser) ){
+        yyStackOverflow(yypParser);
+        /* The call to yyStackOverflow() above pops the stack until it is
+        ** empty, causing the main parser loop to exit.  So the return value
+        ** is never used and does not matter. */
+        return 0;
+      }
+      yymsp = yypParser->yytos;
+    }
+#endif
+  }
+
+  switch( yyruleno ){
+  /* Beginning here are the reduction cases.  A typical example
+  ** follows:
+  **   case 0:
+  **  #line <lineno> <grammarfile>
+  **     { ... }           // User supplied code
+  **  #line <lineno> <thisfile>
+  **     break;
+  */
+/********** Begin reduce actions **********************************************/
+        YYMINORTYPE yylhsminor;
+      case 0: /* cmd ::= SHOW DATABASES */
+{ PARSER_TRACE; createShowStmt(pCxt, SHOW_TYPE_DATABASE); }
+        break;
+      case 1: /* cmd ::= query_expression */
+{ PARSER_TRACE; pCxt->pRootNode = yymsp[0].minor.yy130; }
+        break;
+      case 2: /* column_reference ::= NK_ID */
+{ PARSER_TRACE; yylhsminor.yy130 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy130 = yylhsminor.yy130;
+        break;
+      case 3: /* column_reference ::= table_name NK_DOT NK_ID */
+      case 14: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==14);
+{ PARSER_TRACE; yylhsminor.yy130 = createColumnNode(pCxt, &yymsp[-2].minor.yy67, &yymsp[0].minor.yy0); }
+  yymsp[-2].minor.yy130 = yylhsminor.yy130;
+        break;
+      case 4: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause */
+{ PARSER_TRACE; yymsp[-3].minor.yy130 = createSelectStmt(pCxt, yymsp[-2].minor.yy9, yymsp[-1].minor.yy30, yymsp[0].minor.yy130); }
+        break;
+      case 5: /* set_quantifier_opt ::= */
+{ PARSER_TRACE; yymsp[1].minor.yy9 = false; }
+        break;
+      case 6: /* set_quantifier_opt ::= DISTINCT */
+{ PARSER_TRACE; yymsp[0].minor.yy9 = true; }
+        break;
+      case 7: /* set_quantifier_opt ::= ALL */
+{ PARSER_TRACE; yymsp[0].minor.yy9 = false; }
+        break;
+      case 8: /* select_list ::= NK_STAR */
+{ PARSER_TRACE; yymsp[0].minor.yy30 = NULL; }
+        break;
+      case 9: /* select_list ::= select_sublist */
+{ PARSER_TRACE; yylhsminor.yy30 = yymsp[0].minor.yy30; }
+  yymsp[0].minor.yy30 = yylhsminor.yy30;
+        break;
+      case 10: /* select_sublist ::= select_item */
+      case 37: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==37);
+{ PARSER_TRACE; yylhsminor.yy30 = createNodeList(pCxt, yymsp[0].minor.yy130); }
+  yymsp[0].minor.yy30 = yylhsminor.yy30;
+        break;
+      case 11: /* select_sublist ::= select_sublist NK_COMMA select_item */
+      case 38: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==38);
+{ PARSER_TRACE; yylhsminor.yy30 = addNodeToList(pCxt, yymsp[-2].minor.yy30, yymsp[0].minor.yy130); }
+  yymsp[-2].minor.yy30 = yylhsminor.yy30;
+        break;
+      case 12: /* select_item ::= value_expression */
+      case 16: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==16);
+      case 17: /* table_reference ::= table_factor */ yytestcase(yyruleno==17);
+      case 18: /* table_factor ::= table_primary */ yytestcase(yyruleno==18);
+      case 25: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==25);
+      case 27: /* query_primary ::= query_specification */ yytestcase(yyruleno==27);
+{ PARSER_TRACE; yylhsminor.yy130 = yymsp[0].minor.yy130; }
+  yymsp[0].minor.yy130 = yylhsminor.yy130;
+        break;
+      case 13: /* select_item ::= value_expression AS NK_ID */
+{ PARSER_TRACE; yylhsminor.yy130 = setProjectionAlias(pCxt, yymsp[-2].minor.yy130, &yymsp[0].minor.yy0); }
+  yymsp[-2].minor.yy130 = yylhsminor.yy130;
+        break;
+      case 15: /* from_clause ::= FROM table_reference_list */
+{ PARSER_TRACE; yymsp[-1].minor.yy130 = yymsp[0].minor.yy130; }
+        break;
+      case 19: /* table_primary ::= table_name */
+{ PARSER_TRACE; yylhsminor.yy130 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy67); }
+  yymsp[0].minor.yy130 = yylhsminor.yy130;
+        break;
+      case 20: /* table_primary ::= db_name NK_DOT table_name */
+{ PARSER_TRACE; yylhsminor.yy130 = createRealTableNode(pCxt, &yymsp[-2].minor.yy67, &yymsp[0].minor.yy67); }
+  yymsp[-2].minor.yy130 = yylhsminor.yy130;
+        break;
+      case 21: /* db_name ::= NK_ID */
+      case 22: /* table_name ::= NK_ID */ yytestcase(yyruleno==22);
+{ PARSER_TRACE; yylhsminor.yy67 = yymsp[0].minor.yy0; }
+  yymsp[0].minor.yy67 = yylhsminor.yy67;
+        break;
+      case 23: /* query_expression ::= with_clause_opt query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+{  yy_destructor(yypParser,61,&yymsp[-4].minor);
+{ 
+                                                                                                                                    PARSER_TRACE;
+                                                                                                                                    addOrderByList(pCxt, yymsp[-3].minor.yy130, yymsp[-2].minor.yy30);
+                                                                                                                                    addSlimit(pCxt, yymsp[-3].minor.yy130, yymsp[-1].minor.yy130);
+                                                                                                                                    addLimit(pCxt, yymsp[-3].minor.yy130, yymsp[0].minor.yy130);
+                                                                                                                                    yymsp[-4].minor.yy130 = yymsp[-3].minor.yy130;  
+                                                                                                                                  }
+}
+        break;
+      case 24: /* with_clause_opt ::= */
+{}
+        break;
+      case 26: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+{ PARSER_TRACE; yylhsminor.yy130 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy130, yymsp[0].minor.yy130); }
+  yymsp[-3].minor.yy130 = yylhsminor.yy130;
+        break;
+      case 28: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt limit_clause_opt slimit_clause_opt NK_RP */
+{ PARSER_TRACE; yymsp[-5].minor.yy130 = yymsp[-4].minor.yy130;}
+  yy_destructor(yypParser,63,&yymsp[-3].minor);
+  yy_destructor(yypParser,65,&yymsp[-2].minor);
+  yy_destructor(yypParser,64,&yymsp[-1].minor);
+        break;
+      case 29: /* order_by_clause_opt ::= */
+{ PARSER_TRACE; yymsp[1].minor.yy30 = NULL; }
+        break;
+      case 30: /* order_by_clause_opt ::= ORDER BY sort_specification_list */
+{ PARSER_TRACE; yymsp[-2].minor.yy30 = yymsp[0].minor.yy30; }
+        break;
+      case 31: /* slimit_clause_opt ::= */
+      case 34: /* limit_clause_opt ::= */ yytestcase(yyruleno==34);
+{ yymsp[1].minor.yy130 = NULL; }
+        break;
+      case 32: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+      case 35: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==35);
+{ yymsp[-3].minor.yy130 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); }
+        break;
+      case 33: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+      case 36: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==36);
+{ yymsp[-3].minor.yy130 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); }
+        break;
+      case 39: /* sort_specification ::= value_expression ordering_specification_opt null_ordering_opt */
+{ PARSER_TRACE; yylhsminor.yy130 = createOrderByExprNode(pCxt, yymsp[-2].minor.yy130, yymsp[-1].minor.yy108, yymsp[0].minor.yy68); }
+  yymsp[-2].minor.yy130 = yylhsminor.yy130;
+        break;
+      case 40: /* ordering_specification_opt ::= */
+{ PARSER_TRACE; yymsp[1].minor.yy108 = ORDER_ASC; }
+        break;
+      case 41: /* ordering_specification_opt ::= ASC */
+{ PARSER_TRACE; yymsp[0].minor.yy108 = ORDER_ASC; }
+        break;
+      case 42: /* ordering_specification_opt ::= DESC */
+{ PARSER_TRACE; yymsp[0].minor.yy108 = ORDER_DESC; }
+        break;
+      case 43: /* null_ordering_opt ::= */
+{ PARSER_TRACE; yymsp[1].minor.yy68 = NULL_ORDER_DEFAULT; }
+        break;
+      case 44: /* null_ordering_opt ::= NULLS FIRST */
+{ PARSER_TRACE; yymsp[-1].minor.yy68 = NULL_ORDER_FIRST; }
+        break;
+      case 45: /* null_ordering_opt ::= NULLS LAST */
+{ PARSER_TRACE; yymsp[-1].minor.yy68 = NULL_ORDER_LAST; }
+        break;
+      case 46: /* value_function ::= NK_ID NK_LP value_expression NK_RP */
+      case 48: /* value_expression_primary ::= NK_LP value_expression NK_RP */ yytestcase(yyruleno==48);
+{
+}
+  yy_destructor(yypParser,38,&yymsp[-1].minor);
+        break;
+      case 47: /* value_function ::= NK_ID NK_LP value_expression NK_COMMA value_expression NK_RP */
+{
+}
+  yy_destructor(yypParser,38,&yymsp[-3].minor);
+  yy_destructor(yypParser,38,&yymsp[-1].minor);
+        break;
+      case 49: /* value_expression_primary ::= nonparenthesized_value_expression_primary */
+{  yy_destructor(yypParser,40,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 50: /* nonparenthesized_value_expression_primary ::= literal */
+{  yy_destructor(yypParser,41,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 51: /* nonparenthesized_value_expression_primary ::= column_reference */
+{  yy_destructor(yypParser,42,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 53: /* value_expression ::= common_value_expression */
+{  yy_destructor(yypParser,44,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 54: /* common_value_expression ::= numeric_value_expression */
+{  yy_destructor(yypParser,45,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 55: /* numeric_value_expression ::= numeric_primary */
+{  yy_destructor(yypParser,46,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 56: /* numeric_value_expression ::= NK_PLUS numeric_primary */
+      case 57: /* numeric_value_expression ::= NK_MINUS numeric_primary */ yytestcase(yyruleno==57);
+{
+}
+  yy_destructor(yypParser,46,&yymsp[0].minor);
+        break;
+      case 58: /* numeric_value_expression ::= numeric_value_expression NK_PLUS numeric_value_expression */
+      case 59: /* numeric_value_expression ::= numeric_value_expression NK_MINUS numeric_value_expression */ yytestcase(yyruleno==59);
+      case 60: /* numeric_value_expression ::= numeric_value_expression NK_STAR numeric_value_expression */ yytestcase(yyruleno==60);
+      case 61: /* numeric_value_expression ::= numeric_value_expression NK_SLASH numeric_value_expression */ yytestcase(yyruleno==61);
+{  yy_destructor(yypParser,45,&yymsp[-2].minor);
+{
+}
+  yy_destructor(yypParser,45,&yymsp[0].minor);
+}
+        break;
+      case 62: /* numeric_primary ::= value_expression_primary */
+{  yy_destructor(yypParser,39,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 63: /* numeric_primary ::= value_function */
+{  yy_destructor(yypParser,37,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 64: /* table_primary ::= derived_table */
+{  yy_destructor(yypParser,58,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 65: /* derived_table ::= table_subquery */
+{  yy_destructor(yypParser,59,&yymsp[0].minor);
+{
+}
+}
+        break;
+      case 66: /* subquery ::= NK_LR query_expression NK_RP */
+{
+}
+  yy_destructor(yypParser,36,&yymsp[-1].minor);
+        break;
+      case 67: /* table_subquery ::= subquery */
+{  yy_destructor(yypParser,60,&yymsp[0].minor);
+{
+}
+}
+        break;
+      default:
+      /* (52) literal ::= NK_LITERAL */ yytestcase(yyruleno==52);
+        break;
+/********** End reduce actions ************************************************/
+  };
+  assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
+  yygoto = yyRuleInfo[yyruleno].lhs;
+  yysize = yyRuleInfo[yyruleno].nrhs;
+  yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
+
+  /* There are no SHIFTREDUCE actions on nonterminals because the table
+  ** generator has simplified them to pure REDUCE actions. */
+  assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) );
+
+  /* It is not possible for a REDUCE to be followed by an error */
+  assert( yyact!=YY_ERROR_ACTION );
+
+  yymsp += yysize+1;
+  yypParser->yytos = yymsp;
+  yymsp->stateno = (YYACTIONTYPE)yyact;
+  yymsp->major = (YYCODETYPE)yygoto;
+  yyTraceShift(yypParser, yyact, "... then shift");
+  return yyact;
+}
+
+/*
+** The following code executes when the parse fails
+*/
+#ifndef YYNOERRORRECOVERY
+static void yy_parse_failed(
+  yyParser *yypParser           /* The parser */
+){
+  NewParseARG_FETCH
+  NewParseCTX_FETCH
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
+  }
+#endif
+  while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
+  /* Here code is inserted which will be executed whenever the
+  ** parser fails */
+/************ Begin %parse_failure code ***************************************/
+/************ End %parse_failure code *****************************************/
+  NewParseARG_STORE /* Suppress warning about unused %extra_argument variable */
+  NewParseCTX_STORE
+}
+#endif /* YYNOERRORRECOVERY */
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+static void yy_syntax_error(
+  yyParser *yypParser,           /* The parser */
+  int yymajor,                   /* The major type of the error token */
+  NewParseTOKENTYPE yyminor         /* The minor type of the error token */
+){
+  NewParseARG_FETCH
+  NewParseCTX_FETCH
+#define TOKEN yyminor
+/************ Begin %syntax_error code ****************************************/
+  
+  if(TOKEN.z) {
+    char msg[] = "syntax error near \"%s\"";
+    int32_t sqlLen = strlen(&TOKEN.z[0]);
+
+    if (sqlLen + sizeof(msg)/sizeof(msg[0]) + 1 > pCxt->pQueryCxt->msgLen) {
+        char tmpstr[128] = {0};
+        memcpy(tmpstr, &TOKEN.z[0], sizeof(tmpstr)/sizeof(tmpstr[0]) - 1);
+        sprintf(pCxt->pQueryCxt->pMsg, msg, tmpstr);
+    } else {
+        sprintf(pCxt->pQueryCxt->pMsg, msg, &TOKEN.z[0]);
+    }
+  } else {
+    sprintf(pCxt->pQueryCxt->pMsg, "Incomplete SQL statement");
+  }
+  pCxt->valid = false;
+/************ End %syntax_error code ******************************************/
+  NewParseARG_STORE /* Suppress warning about unused %extra_argument variable */
+  NewParseCTX_STORE
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+static void yy_accept(
+  yyParser *yypParser           /* The parser */
+){
+  NewParseARG_FETCH
+  NewParseCTX_FETCH
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
+  }
+#endif
+#ifndef YYNOERRORRECOVERY
+  yypParser->yyerrcnt = -1;
+#endif
+  assert( yypParser->yytos==yypParser->yystack );
+  /* Here code is inserted which will be executed whenever the
+  ** parser accepts */
+/*********** Begin %parse_accept code *****************************************/
+ printf("parsing complete!\n" );
+/*********** End %parse_accept code *******************************************/
+  NewParseARG_STORE /* Suppress warning about unused %extra_argument variable */
+  NewParseCTX_STORE
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "NewParseAlloc" which describes the current state of the parser.
+** The second argument is the major token number.  The third is
+** the minor token.  The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void NewParse(
+  void *yyp,                   /* The parser */
+  int yymajor,                 /* The major token code number */
+  NewParseTOKENTYPE yyminor       /* The value for the token */
+  NewParseARG_PDECL               /* Optional %extra_argument parameter */
+){
+  YYMINORTYPE yyminorunion;
+  YYACTIONTYPE yyact;   /* The parser action. */
+#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
+  int yyendofinput;     /* True if we are at the end of input */
+#endif
+#ifdef YYERRORSYMBOL
+  int yyerrorhit = 0;   /* True if yymajor has invoked an error */
+#endif
+  yyParser *yypParser = (yyParser*)yyp;  /* The parser */
+  NewParseCTX_FETCH
+  NewParseARG_STORE
+
+  assert( yypParser->yytos!=0 );
+#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
+  yyendofinput = (yymajor==0);
+#endif
+
+  yyact = yypParser->yytos->stateno;
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    if( yyact < YY_MIN_REDUCE ){
+      fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
+              yyTracePrompt,yyTokenName[yymajor],yyact);
+    }else{
+      fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
+              yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
+    }
+  }
+#endif
+
+  do{
+    assert( yyact==yypParser->yytos->stateno );
+    yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
+    if( yyact >= YY_MIN_REDUCE ){
+      yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
+                        yyminor NewParseCTX_PARAM);
+    }else if( yyact <= YY_MAX_SHIFTREDUCE ){
+      yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
+#ifndef YYNOERRORRECOVERY
+      yypParser->yyerrcnt--;
+#endif
+      break;
+    }else if( yyact==YY_ACCEPT_ACTION ){
+      yypParser->yytos--;
+      yy_accept(yypParser);
+      return;
+    }else{
+      assert( yyact == YY_ERROR_ACTION );
+      yyminorunion.yy0 = yyminor;
+#ifdef YYERRORSYMBOL
+      int yymx;
+#endif
+#ifndef NDEBUG
+      if( yyTraceFILE ){
+        fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
+      }
+#endif
+#ifdef YYERRORSYMBOL
+      /* A syntax error has occurred.
+      ** The response to an error depends upon whether or not the
+      ** grammar defines an error token "ERROR".  
+      **
+      ** This is what we do if the grammar does define ERROR:
+      **
+      **  * Call the %syntax_error function.
+      **
+      **  * Begin popping the stack until we enter a state where
+      **    it is legal to shift the error symbol, then shift
+      **    the error symbol.
+      **
+      **  * Set the error count to three.
+      **
+      **  * Begin accepting and shifting new tokens.  No new error
+      **    processing will occur until three tokens have been
+      **    shifted successfully.
+      **
+      */
+      if( yypParser->yyerrcnt<0 ){
+        yy_syntax_error(yypParser,yymajor,yyminor);
+      }
+      yymx = yypParser->yytos->major;
+      if( yymx==YYERRORSYMBOL || yyerrorhit ){
+#ifndef NDEBUG
+        if( yyTraceFILE ){
+          fprintf(yyTraceFILE,"%sDiscard input token %s\n",
+             yyTracePrompt,yyTokenName[yymajor]);
+        }
+#endif
+        yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
+        yymajor = YYNOCODE;
+      }else{
+        while( yypParser->yytos >= yypParser->yystack
+            && (yyact = yy_find_reduce_action(
+                        yypParser->yytos->stateno,
+                        YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
+        ){
+          yy_pop_parser_stack(yypParser);
+        }
+        if( yypParser->yytos < yypParser->yystack || yymajor==0 ){
+          yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+          yy_parse_failed(yypParser);
+#ifndef YYNOERRORRECOVERY
+          yypParser->yyerrcnt = -1;
+#endif
+          yymajor = YYNOCODE;
+        }else if( yymx!=YYERRORSYMBOL ){
+          yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor);
+        }
+      }
+      yypParser->yyerrcnt = 3;
+      yyerrorhit = 1;
+      if( yymajor==YYNOCODE ) break;
+      yyact = yypParser->yytos->stateno;
+#elif defined(YYNOERRORRECOVERY)
+      /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+      ** do any kind of error recovery.  Instead, simply invoke the syntax
+      ** error routine and continue going as if nothing had happened.
+      **
+      ** Applications can set this macro (for example inside %include) if
+      ** they intend to abandon the parse upon the first syntax error seen.
+      */
+      yy_syntax_error(yypParser,yymajor, yyminor);
+      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+      break;
+#else  /* YYERRORSYMBOL is not defined */
+      /* This is what we do if the grammar does not define ERROR:
+      **
+      **  * Report an error message, and throw away the input token.
+      **
+      **  * If the input token is $, then fail the parse.
+      **
+      ** As before, subsequent error messages are suppressed until
+      ** three input tokens have been successfully shifted.
+      */
+      if( yypParser->yyerrcnt<=0 ){
+        yy_syntax_error(yypParser,yymajor, yyminor);
+      }
+      yypParser->yyerrcnt = 3;
+      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
+      if( yyendofinput ){
+        yy_parse_failed(yypParser);
+#ifndef YYNOERRORRECOVERY
+        yypParser->yyerrcnt = -1;
+#endif
+      }
+      break;
+#endif
+    }
+  }while( yypParser->yytos>yypParser->yystack );
+#ifndef NDEBUG
+  if( yyTraceFILE ){
+    yyStackEntry *i;
+    char cDiv = '[';
+    fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
+    for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){
+      fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]);
+      cDiv = ' ';
+    }
+    fprintf(yyTraceFILE,"]\n");
+  }
+#endif
+  return;
+}
+
+/*
+** Return the fallback token corresponding to canonical token iToken, or
+** 0 if iToken has no fallback.
+*/
+int NewParseFallback(int iToken){
+#ifdef YYFALLBACK
+  if( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ){
+    return yyFallback[iToken];
+  }
+#else
+  (void)iToken;
+#endif
+  return 0;
+}
diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c
index c98f787f0b..3b79a2de92 100644
--- a/source/libs/parser/src/parser.c
+++ b/source/libs/parser/src/parser.c
@@ -249,7 +249,7 @@ void qDestroyQuery(SQueryNode* pQueryNode) {
     return;
   }
 
-  int32_t type = nodeType(pQueryNode);
+  int32_t type = queryNodeType(pQueryNode);
   if (type == TSDB_SQL_INSERT || type == TSDB_SQL_CREATE_TABLE) {
     SVnodeModifOpStmtInfo* pModifInfo = (SVnodeModifOpStmtInfo*)pQueryNode;
     taosArrayDestroy(pModifInfo->pDataBlocks);
diff --git a/source/libs/parser/src/parserImpl.c b/source/libs/parser/src/parserImpl.c
new file mode 100644
index 0000000000..8902da9274
--- /dev/null
+++ b/source/libs/parser/src/parserImpl.c
@@ -0,0 +1,136 @@
+/*
+ * 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 "parserImpl.h"
+
+#include "ttoken.h"
+#include "astCreateContext.h"
+
+typedef void* (*FMalloc)(size_t);
+typedef void (*FFree)(void*);
+
+extern void* NewParseAlloc(FMalloc);
+extern void NewParse(void*, int, SToken, void*);
+extern void NewParseFree(void*, FFree);
+
+uint32_t toNewTokenId(uint32_t tokenId) {
+  switch (tokenId) {
+    case TK_UNION:
+      return NEW_TK_UNION;
+    case TK_ALL:
+      return NEW_TK_ALL;
+    case TK_MINUS:
+      return NEW_TK_NK_MINUS;
+    case TK_PLUS:
+      return NEW_TK_NK_PLUS;
+    case TK_STAR:
+      return NEW_TK_NK_STAR;
+    case TK_SLASH:
+      return NEW_TK_NK_SLASH;
+    case TK_SHOW:
+      return NEW_TK_SHOW;
+    case TK_DATABASES:
+      return NEW_TK_DATABASES;
+    case TK_ID:
+      return NEW_TK_NK_ID;
+    case TK_LP:
+      return NEW_TK_NK_LP;
+    case TK_RP:
+      return NEW_TK_NK_RP;
+    case TK_COMMA:
+      return NEW_TK_NK_COMMA;
+    case TK_DOT:
+      return NEW_TK_NK_DOT;
+    case TK_SELECT:
+      return NEW_TK_SELECT;
+    case TK_DISTINCT:
+      return NEW_TK_DISTINCT;
+    case TK_AS:
+      return NEW_TK_AS;
+    case TK_FROM:
+      return NEW_TK_FROM;
+    case TK_ORDER:
+      return NEW_TK_ORDER;
+    case TK_BY:
+      return NEW_TK_BY;
+    case TK_ASC:
+      return NEW_TK_ASC;
+    case TK_DESC:
+      return NEW_TK_DESC;
+  }
+  return tokenId;
+}
+
+uint32_t getToken(const char* z, uint32_t* tokenId) {
+  uint32_t n = tGetToken(z, tokenId);
+  *tokenId = toNewTokenId(*tokenId);
+  return n;
+}
+
+int32_t doParse(SParseContext* pParseCxt, SQuery* pQuery) {
+  SAstCreateContext cxt = { .pQueryCxt = pParseCxt, .valid = true, .pRootNode = NULL };
+  void *pParser = NewParseAlloc(malloc);
+  int32_t i = 0;
+  while (1) {
+    SToken t0 = {0};
+    printf("===========================\n");
+    if (cxt.pQueryCxt->pSql[i] == 0) {
+      NewParse(pParser, 0, t0, &cxt);
+      goto abort_parse;
+    }
+    printf("input: [%s]\n", cxt.pQueryCxt->pSql + i);
+    t0.n = getToken((char *)&cxt.pQueryCxt->pSql[i], &t0.type);
+    t0.z = (char *)(cxt.pQueryCxt->pSql + i);
+    printf("token %p : %d %d [%s]\n", &t0, t0.type, t0.n, t0.z);
+    i += t0.n;
+
+    switch (t0.type) {
+      case TK_SPACE:
+      case TK_COMMENT: {
+        break;
+      }
+      case TK_SEMI: {
+        NewParse(pParser, 0, t0, &cxt);
+        goto abort_parse;
+      }
+
+      case TK_QUESTION:
+      case TK_ILLEGAL: {
+        snprintf(cxt.pQueryCxt->pMsg, cxt.pQueryCxt->msgLen, "unrecognized token: \"%s\"", t0.z);
+        cxt.valid = false;
+        goto abort_parse;
+      }
+
+      case TK_HEX:
+      case TK_OCT:
+      case TK_BIN: {
+        snprintf(cxt.pQueryCxt->pMsg, cxt.pQueryCxt->msgLen, "unsupported token: \"%s\"", t0.z);
+        cxt.valid = false;
+        goto abort_parse;
+      }
+
+      default:
+        NewParse(pParser, t0.type, t0, &cxt);
+        if (!cxt.valid) {
+          goto abort_parse;
+        }
+    }
+  }
+
+abort_parse:
+  NewParseFree(pParser, free);
+  pQuery->pRoot = cxt.pRootNode;
+  return cxt.valid ? TSDB_CODE_SUCCESS : TSDB_CODE_FAILED;
+}
diff --git a/source/libs/parser/src/parserUtil.c b/source/libs/parser/src/parserUtil.c
index a87e138ed0..71ee53dfea 100644
--- a/source/libs/parser/src/parserUtil.c
+++ b/source/libs/parser/src/parserUtil.c
@@ -1426,35 +1426,6 @@ bool isQueryWithLimit(SQueryStmtInfo* pQueryInfo) {
   return false;
 }
 
-SVgroupsInfo* vgroupInfoClone(SVgroupsInfo *vgroupList) {
-  if (vgroupList == NULL) {
-    return NULL;
-  }
-
-  size_t size = sizeof(SVgroupsInfo) + sizeof(SVgroupMsg) * vgroupList->numOfVgroups;
-  SVgroupsInfo* pNew = malloc(size);
-  if (pNew == NULL) {
-    return NULL;
-  }
-
-  pNew->numOfVgroups = vgroupList->numOfVgroups;
-
-  for(int32_t i = 0; i < vgroupList->numOfVgroups; ++i) {
-    SVgroupMsg* pNewVInfo = &pNew->vgroups[i];
-
-    SVgroupMsg* pvInfo = &vgroupList->vgroups[i];
-    pNewVInfo->vgId = pvInfo->vgId;
-    pNewVInfo->numOfEps = pvInfo->numOfEps;
-
-    for(int32_t j = 0; j < pvInfo->numOfEps; ++j) {
-      pNewVInfo->epAddr[j].port = pvInfo->epAddr[j].port;
-      tstrncpy(pNewVInfo->epAddr[j].fqdn, pvInfo->epAddr[j].fqdn, TSDB_FQDN_LEN);
-    }
-  }
-
-  return pNew;
-}
-
 void* vgroupInfoClear(SVgroupsInfo *vgroupList) {
   if (vgroupList == NULL) {
     return NULL;
@@ -1505,19 +1476,6 @@ STableMeta* tableMetaDup(const STableMeta* pTableMeta) {
   return p;
 }
 
-SVgroupsInfo* vgroupsInfoDup(SVgroupsInfo* pVgroupsInfo) {
-  assert(pVgroupsInfo != NULL);
-
-  size_t size = sizeof(SVgroupMsg) * pVgroupsInfo->numOfVgroups + sizeof(SVgroupsInfo);
-  SVgroupsInfo* pInfo = calloc(1, size);
-  pInfo->numOfVgroups = pVgroupsInfo->numOfVgroups;
-  for (int32_t m = 0; m < pVgroupsInfo->numOfVgroups; ++m) {
-    memcpy(&pInfo->vgroups[m], &pVgroupsInfo->vgroups[m], sizeof(SVgroupMsg));
-  }
-
-  return pInfo;
-}
-
 int32_t getNumOfOutput(SFieldInfo* pFieldInfo) {
   return pFieldInfo->numOfOutput;
 }
diff --git a/source/libs/parser/test/CMakeLists.txt b/source/libs/parser/test/CMakeLists.txt
index e722b873b6..84164c8c76 100644
--- a/source/libs/parser/test/CMakeLists.txt
+++ b/source/libs/parser/test/CMakeLists.txt
@@ -15,5 +15,5 @@ TARGET_INCLUDE_DIRECTORIES(
 
 TARGET_LINK_LIBRARIES(
         parserTest
-        PUBLIC os util common parser catalog transport gtest function planner qcom
+        PUBLIC os util common nodes parser catalog transport gtest function planner qcom
 )
diff --git a/source/libs/parser/test/mockCatalogService.cpp b/source/libs/parser/test/mockCatalogService.cpp
index e2b8766700..00d64bd12a 100644
--- a/source/libs/parser/test/mockCatalogService.cpp
+++ b/source/libs/parser/test/mockCatalogService.cpp
@@ -15,6 +15,7 @@
 
 #include "mockCatalogService.h"
 
+#include "tep.h"
 #include <iomanip>
 #include <iostream>
 #include <map>
@@ -39,7 +40,16 @@ public:
 
   virtual TableBuilder& setVgid(int16_t vgid) {
     schema()->vgId = vgid;
-    meta_->vgs.emplace_back(SVgroupInfo{.vgId = vgid, .hashBegin = 0, .hashEnd = 0, .inUse = 0, .numOfEps = 3, .epAddr = {{"dnode_1", 6030}, {"dnode_2", 6030}, {"dnode_3", 6030}}});
+
+    SVgroupInfo vgroup = {.vgId = vgid, .hashBegin = 0, .hashEnd = 0, };
+
+    vgroup.epset.eps[0] = (SEp){"dnode_1", 6030};
+    vgroup.epset.eps[1] = (SEp){"dnode_2", 6030};
+    vgroup.epset.eps[2] = (SEp){"dnode_3", 6030};
+    vgroup.epset.inUse = 0;
+    vgroup.epset.numOfEps = 3;
+
+    meta_->vgs.emplace_back(vgroup);
     return *this;
   }
 
@@ -112,9 +122,7 @@ public:
   int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const {
     // todo
     vgInfo->vgId = 1;
-    vgInfo->numOfEps = 1;
-    vgInfo->epAddr[0].port = 6030;
-    strcpy(vgInfo->epAddr[0].fqdn, "node1");
+    addEpIntoEpSet(&vgInfo->epset, "node1", 6030);
     return 0;
   }
 
@@ -133,9 +141,16 @@ public:
     meta_[db][tbname].reset(new MockTableMeta());
     meta_[db][tbname]->schema.reset(table.release());
     meta_[db][tbname]->schema->uid = id_++;
-    meta_[db][tbname]->vgs.emplace_back((SVgroupInfo){.vgId = vgid, .hashBegin = 0, .hashEnd = 0, .inUse = 0, .numOfEps = 3, .epAddr = {{"dnode_1", 6030}, {"dnode_2", 6030}, {"dnode_3", 6030}}});
+
+    SVgroupInfo vgroup = {.vgId = vgid, .hashBegin = 0, .hashEnd = 0,};
+    addEpIntoEpSet(&vgroup.epset, "dnode_1", 6030);
+    addEpIntoEpSet(&vgroup.epset, "dnode_2", 6030);
+    addEpIntoEpSet(&vgroup.epset, "dnode_3", 6030);
+    vgroup.epset.inUse = 0;
+
+    meta_[db][tbname]->vgs.emplace_back(vgroup);
     // super table
-    meta_[db][stbname]->vgs.emplace_back((SVgroupInfo){.vgId = vgid, .hashBegin = 0, .hashEnd = 0, .inUse = 0, .numOfEps = 3, .epAddr = {{"dnode_1", 6030}, {"dnode_2", 6030}, {"dnode_3", 6030}}});
+    meta_[db][stbname]->vgs.emplace_back(vgroup);
   }
 
   void showTables() const {
diff --git a/source/libs/parser/test/newParserTest.cpp b/source/libs/parser/test/newParserTest.cpp
new file mode 100644
index 0000000000..5223c9f02a
--- /dev/null
+++ b/source/libs/parser/test/newParserTest.cpp
@@ -0,0 +1,143 @@
+/*
+ * 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 "parserImpl.h"
+
+using namespace std;
+using namespace testing;
+
+class NewParserTest : public Test {
+protected:
+  void setDatabase(const string& acctId, const string& db) {
+    acctId_ = acctId;
+    db_ = db;
+  }
+
+  void bind(const char* sql) {
+    reset();
+    cxt_.acctId = atoi(acctId_.c_str());
+    cxt_.db = (char*) db_.c_str();
+    strcpy(sqlBuf_, sql);
+    cxt_.sqlLen = strlen(sql);
+    sqlBuf_[cxt_.sqlLen] = '\0';
+    cxt_.pSql = sqlBuf_;
+
+  }
+
+  int32_t run() {
+    int32_t code = doParse(&cxt_, &query_);
+    if (code != TSDB_CODE_SUCCESS) {
+      cout << "code:" << tstrerror(code) << ", msg:" << errMagBuf_ << endl;
+      return code;
+    }
+    cout << nodeType(query_.pRoot) << endl;
+    if (NULL != query_.pRoot && QUERY_NODE_SELECT_STMT == nodeType(query_.pRoot)) {
+  // SNode* pWhereCond;
+  // SNodeList* pPartitionByList; // SNode
+  // SNode* pWindowClause;
+  // SNodeList* pGroupByList; // SGroupingSetNode
+  // SNodeList* pOrderByList; // SOrderByExprNode
+  // SLimitNode limit;
+  // SLimitNode slimit;
+
+      SSelectStmt* select = (SSelectStmt*)query_.pRoot;
+      string sql("SELECT ");
+      if (select->isDistinct) {
+        sql.append("DISTINCT ");
+      }
+      if (nullptr == select->pProjectionList) {
+        sql.append("* ");
+      } else {
+        nodeListToSql(select->pProjectionList, sql);
+      }
+      sql.append("FROM ");
+      tableToSql(select->pFromTable, sql);
+      cout << sql << endl;
+    }
+    // char* pStr = NULL;
+    // int32_t len = 0;
+    // code = nodesNodeToString(query_.pRoot, &pStr, &len);
+    // if (code != TSDB_CODE_SUCCESS) {
+    //   cout << "code:" << tstrerror(code) << ", msg:" << errMagBuf_ << endl;
+    //   return code;
+    // }
+    // cout << "node tree:\n" << pStr << endl;
+    return TSDB_CODE_SUCCESS;
+  }
+
+private:
+  static const int max_err_len = 1024;
+  static const int max_sql_len = 1024 * 1024;
+
+  void tableToSql(const SNode* node, string& sql) {
+    const STableNode* table = (const STableNode*)node;
+    cout << "node : " << nodeType(node) << endl;
+    switch (nodeType(node)) {
+      case QUERY_NODE_REAL_TABLE: {
+        SRealTableNode* realTable = (SRealTableNode*)table;
+        if ('\0' != realTable->dbName[0]) {
+          sql.append(realTable->dbName);
+          sql.append(".");
+        }
+        sql.append(realTable->table.tableName);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  void nodeListToSql(const SNodeList* nodelist, string& sql, const string& seq = ",") {
+    SNode* node = nullptr;
+    bool firstNode = true;
+    FOREACH(node, nodelist) {
+      if (!firstNode) {
+        sql.append(", ");
+      }
+      switch (nodeType(node)) {
+        case QUERY_NODE_COLUMN:
+          sql.append(((SColumnNode*)node)->colName);
+          break;
+      }
+    }
+  }
+
+  void reset() {
+    memset(&cxt_, 0, sizeof(cxt_));
+    memset(errMagBuf_, 0, max_err_len);
+    cxt_.pMsg = errMagBuf_;
+    cxt_.msgLen = max_err_len;
+  }
+
+  string acctId_;
+  string db_;
+  char errMagBuf_[max_err_len];
+  char sqlBuf_[max_sql_len];
+  SParseContext cxt_;
+  SQuery query_;
+};
+
+// SELECT * FROM t1
+TEST_F(NewParserTest, selectStar) {
+  setDatabase("root", "test");
+
+  bind("SELECT * FROM t1");
+  ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
+
+  bind("SELECT * FROM test.t1");
+  ASSERT_EQ(run(), TSDB_CODE_SUCCESS);
+}
diff --git a/source/libs/planner/src/logicPlan.c b/source/libs/planner/src/logicPlan.c
index de62f4a2ef..a5b1fd6f6b 100644
--- a/source/libs/planner/src/logicPlan.c
+++ b/source/libs/planner/src/logicPlan.c
@@ -74,7 +74,7 @@ int32_t createSelectPlan(const SQueryStmtInfo* pSelect, SQueryPlanNode** pQueryP
 }
 
 int32_t createQueryPlan(const SQueryNode* pNode, SQueryPlanNode** pQueryPlan) {
-  switch (nodeType(pNode)) {
+  switch (queryNodeType(pNode)) {
     case TSDB_SQL_SELECT: {
       return createSelectPlan((const SQueryStmtInfo*)pNode, pQueryPlan);
     }
@@ -395,7 +395,7 @@ SArray* createQueryPlanImpl(const SQueryStmtInfo* pQueryInfo) {
 }
 
 static void doDestroyQueryNode(SQueryPlanNode* pQueryNode) {
-  int32_t type = nodeType(pQueryNode);
+  int32_t type = queryNodeType(pQueryNode);
   if (type == QNODE_MODIFY) {
     SDataPayloadInfo* pInfo = pQueryNode->pExtInfo;
 
diff --git a/source/libs/planner/src/physicalPlan.c b/source/libs/planner/src/physicalPlan.c
index 12c0d0780b..0be97f1ce0 100644
--- a/source/libs/planner/src/physicalPlan.c
+++ b/source/libs/planner/src/physicalPlan.c
@@ -251,24 +251,9 @@ static SSubplan* initSubplan(SPlanContext* pCxt, int32_t type) {
   return subplan;
 }
 
-static void vgroupInfoToEpSet(const SVgroupInfo* vg, SQueryNodeAddr* execNode) {
-  execNode->nodeId = vg->vgId;
-  execNode->inUse = vg->inUse;
-  execNode->numOfEps = vg->numOfEps;
-  for (int8_t i = 0; i < vg->numOfEps; ++i) {
-    execNode->epAddr[i] = vg->epAddr[i];
-  }
-  return;
-}
-
-static void vgroupMsgToEpSet(const SVgroupMsg* vg, SQueryNodeAddr* execNode) {
-  execNode->nodeId = vg->vgId;
-  execNode->inUse = 0; // todo
-  execNode->numOfEps = vg->numOfEps;
-  for (int8_t i = 0; i < vg->numOfEps; ++i) {
-    execNode->epAddr[i] = vg->epAddr[i];
-  }
-  return;
+static void vgroupInfoToNodeAddr(const SVgroupInfo* vg, SQueryNodeAddr* pNodeAddr) {
+  pNodeAddr->nodeId = vg->vgId;
+  pNodeAddr->epset  = vg->epset;
 }
 
 static uint64_t splitSubplanByTable(SPlanContext* pCxt, SQueryPlanNode* pPlanNode, SQueryTableInfo* pTableInfo) {
@@ -277,7 +262,8 @@ static uint64_t splitSubplanByTable(SPlanContext* pCxt, SQueryPlanNode* pPlanNod
     STORE_CURRENT_SUBPLAN(pCxt);
     SSubplan* subplan = initSubplan(pCxt, QUERY_TYPE_SCAN);
     subplan->msgType   = TDMT_VND_QUERY;
-    vgroupMsgToEpSet(&(pTableInfo->pMeta->vgroupList->vgroups[i]), &subplan->execNode);
+
+    vgroupInfoToNodeAddr(&(pTableInfo->pMeta->vgroupList->vgroups[i]), &subplan->execNode);
     subplan->pNode = createMultiTableScanNode(pPlanNode, pTableInfo);
     subplan->pDataSink = createDataDispatcher(pCxt, pPlanNode, subplan->pNode);
     RECOVERY_CURRENT_SUBPLAN(pCxt);
@@ -297,11 +283,12 @@ static bool needMultiNodeScan(SQueryTableInfo* pTable) {
   return (TSDB_SUPER_TABLE == pTable->pMeta->pTableMeta->tableType);
 }
 
-static SPhyNode* createSingleTableScanNode(SQueryPlanNode* pPlanNode, SQueryTableInfo* pTable, SSubplan* subplan) {
-  vgroupMsgToEpSet(&(pTable->pMeta->vgroupList->vgroups[0]), &subplan->execNode);
-
+// TODO: the SVgroupInfo index
+static SPhyNode* createSingleTableScanNode(SQueryPlanNode* pPlanNode, SQueryTableInfo* pTableInfo, SSubplan* subplan) {
+  SVgroupsInfo* pVgroupsInfo = pTableInfo->pMeta->vgroupList;
+  vgroupInfoToNodeAddr(&(pVgroupsInfo->vgroups[0]), &subplan->execNode);
   int32_t type = (pPlanNode->info.type == QNODE_TABLESCAN)? OP_TableScan:OP_StreamScan;
-  return createUserTableScanNode(pPlanNode, pTable, type);
+  return createUserTableScanNode(pPlanNode, pTableInfo, type);
 }
 
 static SPhyNode* createTableScanNode(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
@@ -374,7 +361,7 @@ static void splitModificationOpSubPlan(SPlanContext* pCxt, SQueryPlanNode* pPlan
     SSubplan* subplan = initSubplan(pCxt, QUERY_TYPE_MODIFY);
     SVgDataBlocks* blocks = (SVgDataBlocks*)taosArrayGetP(pPayload->payload, i);
 
-    vgroupInfoToEpSet(&blocks->vg, &subplan->execNode);
+    subplan->execNode.epset = blocks->vg.epset;
     subplan->pDataSink  = createDataInserter(pCxt, blocks, NULL);
     subplan->pNode      = NULL;
     subplan->type       = QUERY_TYPE_MODIFY;
@@ -461,7 +448,7 @@ static void destroyDataSinkNode(SDataSink* pSinkNode) {
     return;
   }
 
-  if (nodeType(pSinkNode) == DSINK_Dispatch) {
+  if (queryNodeType(pSinkNode) == DSINK_Dispatch) {
     SDataDispatcher* pDdSink = (SDataDispatcher*)pSinkNode;
     tfree(pDdSink->sink.schema.pSchema);
   }
diff --git a/source/libs/planner/src/physicalPlanJson.c b/source/libs/planner/src/physicalPlanJson.c
index 4fbec534f6..5d96ab47c3 100644
--- a/source/libs/planner/src/physicalPlanJson.c
+++ b/source/libs/planner/src/physicalPlanJson.c
@@ -736,7 +736,7 @@ static const char* jkEpAddrFqdn = "Fqdn";
 static const char* jkEpAddrPort = "Port";
 
 static bool epAddrToJson(const void* obj, cJSON* json) {
-  const SEpAddr* ep = (const SEpAddr*)obj;
+  const SEp* ep = (const SEp*)obj;
   bool res = cJSON_AddStringToObject(json, jkEpAddrFqdn, ep->fqdn);
   if (res) {
     res = cJSON_AddNumberToObject(json, jkEpAddrPort, ep->port);
@@ -745,7 +745,7 @@ static bool epAddrToJson(const void* obj, cJSON* json) {
 }
 
 static bool epAddrFromJson(const cJSON* json, void* obj) {
-  SEpAddr* ep = (SEpAddr*)obj;
+  SEp* ep = (SEp*)obj;
   copyString(json, jkEpAddrFqdn, ep->fqdn);
   ep->port = getNumber(json, jkEpAddrPort);
   return true;
@@ -763,11 +763,11 @@ static bool queryNodeAddrToJson(const void* obj, cJSON* json) {
   bool res = cJSON_AddNumberToObject(json, jkNodeAddrId, pAddr->nodeId);
 
   if (res) {
-    res = cJSON_AddNumberToObject(json, jkNodeAddrInUse, pAddr->inUse);
+    res = cJSON_AddNumberToObject(json, jkNodeAddrInUse, pAddr->epset.inUse);
   }
 
   if (res) {
-    res = addRawArray(json, jkNodeAddrEpAddrs, epAddrToJson, pAddr->epAddr, sizeof(SEpAddr), pAddr->numOfEps);
+    res = addRawArray(json, jkNodeAddrEpAddrs, epAddrToJson, pAddr->epset.eps, sizeof(SEp), pAddr->epset.numOfEps);
   }
   return res;
 }
@@ -776,11 +776,11 @@ static bool queryNodeAddrFromJson(const cJSON* json, void* obj) {
   SQueryNodeAddr* pAddr = (SQueryNodeAddr*) obj;
 
   pAddr->nodeId = getNumber(json, jkNodeAddrId);
-  pAddr->inUse = getNumber(json, jkNodeAddrInUse);
+  pAddr->epset.inUse = getNumber(json, jkNodeAddrInUse);
 
   int32_t numOfEps = 0;
-  bool res = fromRawArray(json, jkNodeAddrEpAddrs, epAddrFromJson, pAddr->epAddr, sizeof(SEpAddr), &numOfEps);
-  pAddr->numOfEps = numOfEps;
+  bool res = fromRawArray(json, jkNodeAddrEpAddrs, epAddrFromJson, pAddr->epset.eps, sizeof(SEp), &numOfEps);
+  pAddr->epset.numOfEps = numOfEps;
   return res;
 }
 
@@ -1125,8 +1125,6 @@ int32_t subPlanToString(const SSubplan* subplan, char** str, int32_t* len) {
   *str = cJSON_Print(json);
   cJSON_Delete(json);
 
-//  printf("====Physical plan:====\n");
-//  printf("%s\n", *str);
   *len = strlen(*str) + 1;
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/libs/planner/src/planner.c b/source/libs/planner/src/planner.c
index d546925c5f..e6b7eaca7f 100644
--- a/source/libs/planner/src/planner.c
+++ b/source/libs/planner/src/planner.c
@@ -40,7 +40,8 @@ void qDestroyQueryDag(struct SQueryDag* pDag) {
   tfree(pDag);
 }
 
-int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SQueryDag** pDag, SSchema** pResSchema, int32_t* numOfCols, SArray* pNodeList, uint64_t requestId) {
+int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SQueryDag** pDag, SSchema** pResSchema, int32_t* numOfCols, SArray* pNodeList,
+    uint64_t requestId) {
   SQueryPlanNode* pLogicPlan;
   int32_t code = createQueryPlan(pNode, &pLogicPlan);
   if (TSDB_CODE_SUCCESS != code) {
@@ -49,9 +50,10 @@ int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SQueryDag** pDag,
   }
 
   if (pLogicPlan->info.type != QNODE_MODIFY) {
-//   char* str = NULL;
-//   queryPlanToString(pLogicPlan, &str);
-//   printf("%s\n", str);
+    char* str = NULL;
+    queryPlanToString(pLogicPlan, &str);
+    qDebug("reqId:0x%"PRIx64": %s", requestId, str);
+    tfree(str);
   }
 
   code = optimizeQueryPlan(pLogicPlan);
diff --git a/source/libs/planner/test/phyPlanTests.cpp b/source/libs/planner/test/phyPlanTests.cpp
index edf5fa5a81..f4bdf57572 100644
--- a/source/libs/planner/test/phyPlanTests.cpp
+++ b/source/libs/planner/test/phyPlanTests.cpp
@@ -124,12 +124,10 @@ private:
   }
 
   void copyStorageMeta(SVgroupsInfo** dst, const std::vector<SVgroupInfo>& src) {
-    *dst = (SVgroupsInfo*)myCalloc(1, sizeof(SVgroupsInfo) + sizeof(SVgroupMsg) * src.size());
+    *dst = (SVgroupsInfo*)myCalloc(1, sizeof(SVgroupsInfo) + sizeof(SVgroupInfo) * src.size());
     (*dst)->numOfVgroups = src.size();
     for (int32_t i = 0; i < src.size(); ++i) {
-      (*dst)->vgroups[i].vgId = src[i].vgId;
-      (*dst)->vgroups[i].numOfEps = src[i].numOfEps;
-      memcpy((*dst)->vgroups[i].epAddr, src[i].epAddr, src[i].numOfEps);
+      (*dst)->vgroups[i] = src[i];
     }
   }
 
diff --git a/source/libs/qcom/src/queryUtil.c b/source/libs/qcom/src/queryUtil.c
index cfe2ed96ad..9f678b4528 100644
--- a/source/libs/qcom/src/queryUtil.c
+++ b/source/libs/qcom/src/queryUtil.c
@@ -128,7 +128,7 @@ int32_t asyncSendMsgToServer(void *pTransporter, SEpSet* epSet, int64_t* pTransp
   if (NULL == pMsg) {
     qError("0x%"PRIx64" msg:%s malloc failed", pInfo->requestId, TMSG_INFO(pInfo->msgType));
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return -1;
+    return terrno;
   }
 
   memcpy(pMsg, pInfo->msgInfo.pData, pInfo->msgInfo.len);
diff --git a/source/libs/qcom/src/querymsg.c b/source/libs/qcom/src/querymsg.c
index 52e632ffbb..38ce005094 100644
--- a/source/libs/qcom/src/querymsg.c
+++ b/source/libs/qcom/src/querymsg.c
@@ -127,8 +127,8 @@ int32_t queryProcessUseDBRsp(void* output, char *msg, int32_t msgSize) {
     pRsp->vgroupInfo[i].hashBegin = ntohl(pRsp->vgroupInfo[i].hashBegin);
     pRsp->vgroupInfo[i].hashEnd = ntohl(pRsp->vgroupInfo[i].hashEnd);
 
-    for (int32_t n = 0; n < pRsp->vgroupInfo[i].numOfEps; ++n) {
-      pRsp->vgroupInfo[i].epAddr[n].port = ntohs(pRsp->vgroupInfo[i].epAddr[n].port);
+    for (int32_t n = 0; n < pRsp->vgroupInfo[i].epset.numOfEps; ++n) {
+      pRsp->vgroupInfo[i].epset.eps[n].port = ntohs(pRsp->vgroupInfo[i].epset.eps[n].port);
     }
 
     if (0 != taosHashPut(pOut->dbVgroup.vgInfo, &pRsp->vgroupInfo[i].vgId, sizeof(pRsp->vgroupInfo[i].vgId), &pRsp->vgroupInfo[i], sizeof(pRsp->vgroupInfo[i]))) {
diff --git a/source/libs/qworker/inc/qworkerInt.h b/source/libs/qworker/inc/qworkerInt.h
index a19a02069b..de2940846c 100644
--- a/source/libs/qworker/inc/qworkerInt.h
+++ b/source/libs/qworker/inc/qworkerInt.h
@@ -182,9 +182,9 @@ typedef struct SQWorkerMgmt {
 #define QW_TASK_WLOG_E(param) qWarn("QW:%p QID:0x%"PRIx64",TID:0x%"PRIx64" " param, mgmt, qId, tId)
 #define QW_TASK_DLOG_E(param) qDebug("QW:%p QID:0x%"PRIx64",TID:0x%"PRIx64" " param, mgmt, qId, tId)
 
-#define QW_SCH_TASK_ELOG(param, ...) qError("QW:%p SID:%"PRIx64",QID:0x%"PRIx64",TID:0x%"PRIx64" " param, mgmt, sId, qId, tId, __VA_ARGS__)
-#define QW_SCH_TASK_WLOG(param, ...) qWarn("QW:%p SID:%"PRIx64",QID:0x%"PRIx64",TID:%"PRIx64" " param, mgmt, sId, qId, tId, __VA_ARGS__)
-#define QW_SCH_TASK_DLOG(param, ...) qDebug("QW:%p SID:%"PRIx64",QID:0x%"PRIx64",TID:0x%"PRIx64" " param, mgmt, sId, qId, tId, __VA_ARGS__)
+#define QW_SCH_TASK_ELOG(param, ...) qError("QW:%p SID:0x%"PRIx64",QID:0x%"PRIx64",TID:0x%"PRIx64" " param, mgmt, sId, qId, tId, __VA_ARGS__)
+#define QW_SCH_TASK_WLOG(param, ...) qWarn("QW:%p SID:0x%"PRIx64",QID:0x%"PRIx64",TID:0x%"PRIx64" " param, mgmt, sId, qId, tId, __VA_ARGS__)
+#define QW_SCH_TASK_DLOG(param, ...) qDebug("QW:%p SID:0x%"PRIx64",QID:0x%"PRIx64",TID:0x%"PRIx64" " param, mgmt, sId, qId, tId, __VA_ARGS__)
 
 #define QW_LOCK_DEBUG(...) do { if (gQWDebug.lockDebug) { qDebug(__VA_ARGS__); } } while (0)
 
diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 8fc8a783c4..8705bc23b9 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -479,7 +479,6 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryEnd) {
 
     if (NULL == pRes) {
       QW_TASK_DLOG("task query done, useconds:%"PRIu64, useconds);
-      
       dsEndPut(sinkHandle, useconds);
       
       if (TASK_TYPE_TEMP == ctx->taskType) {
@@ -493,6 +492,8 @@ int32_t qwExecTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *queryEnd) {
       break;
     }
 
+    ASSERT(pRes->info.rows > 0);
+
     SInputData inputData = {.pData = pRes, .pTableRetrieveTsMap = NULL};
     code = dsPutDataBlock(sinkHandle, &inputData, &qcontinue);
     if (code) {
@@ -1100,8 +1101,6 @@ int32_t qwProcessCQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
     atomic_store_8(&ctx->queryInQueue, 0);
     atomic_store_8(&ctx->queryContinue, 0);
 
-    DataSinkHandle  sinkHandle = ctx->sinkHandle;
-
     QW_ERR_JRET(qwExecTask(QW_FPARAMS(), ctx, &queryEnd));
 
     if (QW_IS_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
diff --git a/source/libs/qworker/src/qworkerMsg.c b/source/libs/qworker/src/qworkerMsg.c
index 11783335b3..368a590918 100644
--- a/source/libs/qworker/src/qworkerMsg.c
+++ b/source/libs/qworker/src/qworkerMsg.c
@@ -282,18 +282,21 @@ int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) {
     QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
 
-  msg->sId = be64toh(msg->sId);
+  msg->sId     = be64toh(msg->sId);
   msg->queryId = be64toh(msg->queryId);
-  msg->taskId = be64toh(msg->taskId);
-  msg->contentLen = ntohl(msg->contentLen);
-  
+  msg->taskId  = be64toh(msg->taskId);
+  msg->phyLen  = ntohl(msg->phyLen);
+  msg->sqlLen  = ntohl(msg->sqlLen);
+
   uint64_t sId = msg->sId;
   uint64_t qId = msg->queryId;
   uint64_t tId = msg->taskId;
 
-  SQWMsg qwMsg = {.node = node, .msg = msg->msg, .msgLen = msg->contentLen, .connection = pMsg};
+  SQWMsg qwMsg = {.node = node, .msg = msg->msg + msg->sqlLen, .msgLen = msg->phyLen, .connection = pMsg};
 
-  QW_SCH_TASK_DLOG("processQuery start, node:%p", node);
+  char* sql = strndup(msg->msg, msg->sqlLen);
+  QW_SCH_TASK_DLOG("processQuery start, node:%p, sql:%s", node, sql);
+  tfree(sql);
 
   QW_RET(qwProcessQuery(QW_FPARAMS(), &qwMsg, msg->taskType));
 
diff --git a/source/libs/qworker/test/qworkerTests.cpp b/source/libs/qworker/test/qworkerTests.cpp
index 4c81123bf2..38890150ee 100644
--- a/source/libs/qworker/test/qworkerTests.cpp
+++ b/source/libs/qworker/test/qworkerTests.cpp
@@ -113,7 +113,8 @@ void qwtBuildQueryReqMsg(SRpcMsg *queryRpc) {
   qwtqueryMsg.queryId = htobe64(atomic_add_fetch_64(&qwtTestQueryId, 1));
   qwtqueryMsg.sId = htobe64(1);
   qwtqueryMsg.taskId = htobe64(1);
-  qwtqueryMsg.contentLen = htonl(100);
+  qwtqueryMsg.phyLen = htonl(100);
+  qwtqueryMsg.sqlLen = 0;
   queryRpc->msgType = TDMT_VND_QUERY;
   queryRpc->pCont = &qwtqueryMsg;
   queryRpc->contLen = sizeof(SSubQueryMsg) + 100;
diff --git a/source/libs/scheduler/inc/schedulerInt.h b/source/libs/scheduler/inc/schedulerInt.h
index 2ace1c66f5..f5e3ef9963 100644
--- a/source/libs/scheduler/inc/schedulerInt.h
+++ b/source/libs/scheduler/inc/schedulerInt.h
@@ -128,6 +128,7 @@ typedef struct SSchJob {
   int32_t          errCode;
   void            *res;         //TODO free it or not
   int32_t          resNumOfRows;
+  const char      *sql;
   SQueryProfileSummary summary;
 } SSchJob;
 
@@ -150,11 +151,11 @@ typedef struct SSchJob {
 #define SCH_JOB_DLOG(param, ...) qDebug("QID:0x%" PRIx64 " " param, pJob->queryId, __VA_ARGS__)
 
 #define SCH_TASK_ELOG(param, ...) \
-  qError("QID:0x%" PRIx64 ",TID:%" PRId64 " " param, pJob->queryId, pTask->taskId, __VA_ARGS__)
+  qError("QID:0x%" PRIx64 ",TID:0x%" PRIx64 " " param, pJob->queryId, pTask->taskId, __VA_ARGS__)
 #define SCH_TASK_DLOG(param, ...) \
-  qDebug("QID:0x%" PRIx64 ",TID:%" PRId64 " " param, pJob->queryId, pTask->taskId, __VA_ARGS__)
+  qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 " " param, pJob->queryId, pTask->taskId, __VA_ARGS__)
 #define SCH_TASK_WLOG(param, ...) \
-  qWarn("QID:0x%" PRIx64 ",TID:%" PRId64 " " param, pJob->queryId, pTask->taskId, __VA_ARGS__)
+  qWarn("QID:0x%" PRIx64 ",TID:0x%" PRIx64 " " param, pJob->queryId, pTask->taskId, __VA_ARGS__)
 
 #define SCH_ERR_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; return _code; } } while (0)
 #define SCH_RET(c) do { int32_t _code = c; if (_code != TSDB_CODE_SUCCESS) { terrno = _code; } return _code; } while (0)
diff --git a/source/libs/scheduler/src/scheduler.c b/source/libs/scheduler/src/scheduler.c
index 934b222f64..25137beed9 100644
--- a/source/libs/scheduler/src/scheduler.c
+++ b/source/libs/scheduler/src/scheduler.c
@@ -345,7 +345,6 @@ int32_t schValidateAndBuildJob(SQueryDag *pDag, SSchJob *pJob) {
     }
 
     pLevel = taosArrayGet(pJob->levels, i);
-  
     pLevel->level = i;
     
     plans = taosArrayGetP(pDag->pSubplans, i);
@@ -375,7 +374,7 @@ int32_t schValidateAndBuildJob(SQueryDag *pDag, SSchJob *pJob) {
 
       SSchTask  task = {0};
       SSchTask *pTask = &task;
-      
+
       SCH_ERR_JRET(schInitTask(pJob, &task, plan, pLevel));
       
       void *p = taosArrayPush(pLevel->subTasks, &task);
@@ -388,8 +387,6 @@ int32_t schValidateAndBuildJob(SQueryDag *pDag, SSchJob *pJob) {
         SCH_TASK_ELOG("taosHashPut to planToTaks failed, taskIdx:%d", n);
         SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
       }
-
-      SCH_TASK_DLOG("task initialized, level:%d", pLevel->level);
     }
 
     SCH_JOB_DLOG("level initialized, taskNum:%d", taskNum);
@@ -417,13 +414,13 @@ int32_t schSetTaskCandidateAddrs(SSchJob *pJob, SSchTask *pTask) {
     SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
-  if (pTask->plan->execNode.numOfEps > 0) {
+  if (pTask->plan->execNode.epset.numOfEps > 0) {
     if (NULL == taosArrayPush(pTask->candidateAddrs, &pTask->plan->execNode)) {
       SCH_TASK_ELOG("taosArrayPush execNode to candidate addrs failed, errno:%d", errno);
       SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
     }
 
-    SCH_TASK_DLOG("use execNode from plan as candidate addr, numOfEps:%d", pTask->plan->execNode.numOfEps);
+    SCH_TASK_DLOG("use execNode from plan as candidate addr, numOfEps:%d", pTask->plan->execNode.epset.numOfEps);
 
     return TSDB_CODE_SUCCESS;
   }
@@ -446,7 +443,7 @@ int32_t schSetTaskCandidateAddrs(SSchJob *pJob, SSchTask *pTask) {
   }
 
   if (addNum <= 0) {
-    SCH_TASK_ELOG("no available execNode as candidate addr, nodeNum:%d", nodeNum);
+    SCH_TASK_ELOG("no available execNode as candidates, nodeNum:%d", nodeNum);
     return TSDB_CODE_QRY_INVALID_INPUT;
   }
 
@@ -716,8 +713,6 @@ int32_t schProcessOnTaskSuccess(SSchJob *pJob, SSchTask *pTask) {
   int32_t code = 0;
   SSchTask *pErrTask = pTask;
 
-  SCH_TASK_DLOG("taskOnSuccess, status:%d", SCH_GET_TASK_STATUS(pTask));
-  
   code = schMoveTaskToSuccList(pJob, pTask, &moved);
   if (code && moved) {
     SCH_ERR_RET(code);
@@ -739,7 +734,6 @@ int32_t schProcessOnTaskSuccess(SSchJob *pJob, SSchTask *pTask) {
       
       if (taskDone < pTask->level->taskNum) {
         SCH_TASK_DLOG("wait all tasks, done:%d, all:%d", taskDone, pTask->level->taskNum);
-        
         return TSDB_CODE_SUCCESS;
       } else if (taskDone > pTask->level->taskNum) {
         SCH_TASK_ELOG("taskDone number invalid, done:%d, total:%d", taskDone, pTask->level->taskNum);
@@ -1031,50 +1025,33 @@ int32_t schAsyncSendMsg(void *transport, SEpSet* epSet, uint64_t qId, uint64_t t
   pMsgSendInfo->fp = fp;
   
   int64_t  transporterId = 0;
-  
   code = asyncSendMsgToServer(transport, epSet, &transporterId, pMsgSendInfo);
   if (code) {
-    qError("QID:%"PRIx64 ",TID:%"PRIx64 " asyncSendMsgToServer failed, code:%x", qId, tId, code);
     SCH_ERR_JRET(code);
   }
 
-  qDebug("QID:%"PRIx64 ",TID:%"PRIx64 " req msg sent, type:%d, %s", qId, tId, msgType, TMSG_INFO(msgType));
-
+  qDebug("QID:0x%"PRIx64 ",TID:0x%"PRIx64 " req msg sent, type:%d, %s", qId, tId, msgType, TMSG_INFO(msgType));
   return TSDB_CODE_SUCCESS;
 
 _return:
   
   tfree(param);
   tfree(pMsgSendInfo);
-
   SCH_RET(code);
 }
 
-void schConvertAddrToEpSet(SQueryNodeAddr *addr, SEpSet *epSet) {
-  epSet->inUse = addr->inUse;
-  epSet->numOfEps = addr->numOfEps;
-  
-  for (int8_t i = 0; i < epSet->numOfEps; ++i) {
-    strncpy(epSet->fqdn[i], addr->epAddr[i].fqdn, sizeof(addr->epAddr[i].fqdn));
-    epSet->port[i] = addr->epAddr[i].port;
-  }
-}
-
 int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr, int32_t msgType) {
   uint32_t msgSize = 0;
   void *msg = NULL;
   int32_t code = 0;
   bool isCandidateAddr = false;
-  SEpSet epSet;
-
   if (NULL == addr) {
     addr = taosArrayGet(pTask->candidateAddrs, atomic_load_8(&pTask->candidateIdx));
-    
     isCandidateAddr = true;
   }
 
-  schConvertAddrToEpSet(addr, &epSet);
-  
+  SEpSet epSet = addr->epset;
+
   switch (msgType) {
     case TDMT_VND_CREATE_TABLE:
     case TDMT_VND_SUBMIT: {
@@ -1090,7 +1067,9 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
     }
 
     case TDMT_VND_QUERY: {
-      msgSize = sizeof(SSubQueryMsg) + pTask->msgLen;
+      uint32_t len = strlen(pJob->sql);
+
+      msgSize = sizeof(SSubQueryMsg) + pTask->msgLen + len;
       msg = calloc(1, msgSize);
       if (NULL == msg) {
         SCH_TASK_ELOG("calloc %d failed", msgSize);
@@ -1098,15 +1077,16 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
       }
 
       SSubQueryMsg *pMsg = msg;
-
       pMsg->header.vgId = htonl(addr->nodeId);
-      
-      pMsg->sId = htobe64(schMgmt.sId);
-      pMsg->queryId = htobe64(pJob->queryId);
-      pMsg->taskId = htobe64(pTask->taskId);
-      pMsg->taskType = TASK_TYPE_TEMP;      
-      pMsg->contentLen = htonl(pTask->msgLen);
-      memcpy(pMsg->msg, pTask->msg, pTask->msgLen);
+      pMsg->sId        = htobe64(schMgmt.sId);
+      pMsg->queryId    = htobe64(pJob->queryId);
+      pMsg->taskId     = htobe64(pTask->taskId);
+      pMsg->taskType   = TASK_TYPE_TEMP;
+      pMsg->phyLen     = htonl(pTask->msgLen);
+      pMsg->sqlLen     = htonl(len);
+
+      memcpy(pMsg->msg, pJob->sql, len);
+      memcpy(pMsg->msg + len, pTask->msg, pTask->msgLen);
       break;
     }
 
@@ -1206,20 +1186,19 @@ int32_t schLaunchTask(SSchJob *pJob, SSchTask *pTask) {
     
     code = atomic_load_32(&pJob->errCode);
     SCH_ERR_RET(code);
-    
     SCH_RET(TSDB_CODE_SCH_STATUS_ERROR);
   }
   
   SSubplan *plan = pTask->plan;
 
-  if (NULL == pTask->msg) {
+  if (NULL == pTask->msg) { // TODO add more detailed reason for failure
     code = qSubPlanToString(plan, &pTask->msg, &pTask->msgLen);
     if (TSDB_CODE_SUCCESS != code || NULL == pTask->msg || pTask->msgLen <= 0) {
-      SCH_TASK_ELOG("subplanToString error, code:%x, msg:%p, len:%d", code, pTask->msg, pTask->msgLen);
+      SCH_TASK_ELOG("failed to create physical plan, code:%s, msg:%p, len:%d", tstrerror(code), pTask->msg, pTask->msgLen);
       SCH_ERR_JRET(code);
+    } else {
+      SCH_TASK_DLOG("physical plan len:%d, %s", pTask->msgLen, pTask->msg);
     }
-
-//    printf("physical plan:%s\n", pTask->msg);
   }
   
   SCH_ERR_JRET(schSetTaskCandidateAddrs(pJob, pTask));
@@ -1227,18 +1206,14 @@ int32_t schLaunchTask(SSchJob *pJob, SSchTask *pTask) {
   // NOTE: race condition: the task should be put into the hash table before send msg to server
   if (SCH_GET_TASK_STATUS(pTask) != JOB_TASK_STATUS_EXECUTING) {
     SCH_ERR_JRET(schPushTaskToExecList(pJob, pTask));
-
     SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_EXECUTING);
   }
 
   SCH_ERR_JRET(schBuildAndSendMsg(pJob, pTask, NULL, plan->msgType));
-  
   return TSDB_CODE_SUCCESS;
 
 _return:
-
   SCH_ERR_RET(schProcessOnTaskFailure(pJob, pTask, code));
-  
   SCH_RET(code);
 }
 
@@ -1297,10 +1272,10 @@ void schDropJobAllTasks(SSchJob *pJob) {
   schDropTaskInHashList(pJob, pJob->failTasks);
 }
 
-int32_t schExecJobImpl(void *transport, SArray *pNodeList, SQueryDag* pDag, struct SSchJob** job, bool syncSchedule) {
+static int32_t schExecJobImpl(void *transport, SArray *pNodeList, SQueryDag* pDag, struct SSchJob** job, const char* sql, bool syncSchedule) {
   qDebug("QID:0x%"PRIx64" job started", pDag->queryId);
 
-  if (pNodeList && taosArrayGetSize(pNodeList) <= 0) {
+  if (pNodeList == NULL || (pNodeList && taosArrayGetSize(pNodeList) <= 0)) {
     qDebug("QID:0x%"PRIx64" input exec nodeList is empty", pDag->queryId);
   }
 
@@ -1313,6 +1288,7 @@ int32_t schExecJobImpl(void *transport, SArray *pNodeList, SQueryDag* pDag, stru
 
   pJob->attr.syncSchedule = syncSchedule;
   pJob->transport = transport;
+  pJob->sql       = sql;
 
   if (pNodeList != NULL) {
     pJob->nodeList = taosArrayDup(pNodeList);
@@ -1352,7 +1328,6 @@ int32_t schExecJobImpl(void *transport, SArray *pNodeList, SQueryDag* pDag, stru
   }
 
   pJob->status = JOB_TASK_STATUS_NOT_START;
-  
   SCH_ERR_JRET(schLaunchJob(pJob));
 
   *(SSchJob **)job = pJob;
@@ -1363,15 +1338,12 @@ int32_t schExecJobImpl(void *transport, SArray *pNodeList, SQueryDag* pDag, stru
   }
 
   SCH_JOB_DLOG("job exec done, job status:%d", SCH_GET_JOB_STATUS(pJob));
-
   return TSDB_CODE_SUCCESS;
 
 _return:
 
   *(SSchJob **)job = NULL;
-  
   schedulerFreeJob(pJob);
-  
   SCH_RET(code);
 }
 
@@ -1415,29 +1387,24 @@ int32_t schedulerInit(SSchedulerCfg *cfg) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t schedulerExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, struct SSchJob** pJob, SQueryResult *pRes) {
+int32_t schedulerExecJob(void *transport, SArray *nodeList, SQueryDag* pDag, struct SSchJob** pJob, const char* sql, SQueryResult *pRes) {
   if (NULL == transport || NULL == pDag || NULL == pDag->pSubplans || NULL == pJob || NULL == pRes) {
     SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
 
-  SSchJob *job = NULL;
-
-  SCH_ERR_RET(schExecJobImpl(transport, nodeList, pDag, pJob, true));
-
-  job = *pJob;
-
-  pRes->code = atomic_load_32(&job->errCode);
-  pRes->numOfRows = job->resNumOfRows;
+  SCH_ERR_RET(schExecJobImpl(transport, nodeList, pDag, pJob, sql, true));
+  pRes->code = atomic_load_32(&(*pJob)->errCode);
+  pRes->numOfRows = (*pJob)->resNumOfRows;
   
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t schedulerAsyncExecJob(void *transport, SArray *pNodeList, SQueryDag* pDag, struct SSchJob** pJob) {
+int32_t schedulerAsyncExecJob(void *transport, SArray *pNodeList, SQueryDag* pDag, const char* sql, struct SSchJob** pJob) {
   if (NULL == transport || NULL == pDag || NULL == pDag->pSubplans || NULL == pJob) {
     SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
 
-  SCH_ERR_RET(schExecJobImpl(transport, pNodeList, pDag, pJob, false));
+  SCH_ERR_RET(schExecJobImpl(transport, pNodeList, pDag, pJob, sql, false));
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1472,7 +1439,6 @@ int32_t schedulerConvertDagToTaskList(SQueryDag* pDag, SArray **pTasks) {
   
   for (int32_t i = 0; i < taskNum; ++i) {
     SSubplan *plan = taosArrayGetP(plans, i);
-
     tInfo.addr = plan->execNode;
 
     code = qSubPlanToString(plan, &msg, &msgLen);
@@ -1488,16 +1454,16 @@ int32_t schedulerConvertDagToTaskList(SQueryDag* pDag, SArray **pTasks) {
     }
     
     SSubQueryMsg* pMsg = calloc(1, msgSize);
-    /*SSubQueryMsg *pMsg = (SSubQueryMsg*) msg;*/
     memcpy(pMsg->msg, msg, msgLen);
     
     pMsg->header.vgId = tInfo.addr.nodeId;
     
-    pMsg->sId = schMgmt.sId;
-    pMsg->queryId = plan->id.queryId;
-    pMsg->taskId = schGenUUID();
+    pMsg->sId      = schMgmt.sId;
+    pMsg->queryId  = plan->id.queryId;
+    pMsg->taskId   = schGenUUID();
     pMsg->taskType = TASK_TYPE_PERSISTENT;
-    pMsg->contentLen = msgLen;
+    pMsg->phyLen   = msgLen;
+    pMsg->sqlLen   = 0;
     /*memcpy(pMsg->msg, ((SSubQueryMsg*)msg)->msg, msgLen);*/
 
     tInfo.msg = pMsg;
@@ -1530,7 +1496,7 @@ int32_t schedulerCopyTask(STaskInfo *src, SArray **dst, int32_t copyNum) {
     SCH_ERR_RET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
-  int32_t msgSize = src->msg->contentLen + sizeof(*src->msg);
+  int32_t msgSize = src->msg->phyLen + sizeof(*src->msg);
   STaskInfo info = {0};
 
   info.addr = src->addr;
diff --git a/source/libs/scheduler/test/schedulerTests.cpp b/source/libs/scheduler/test/schedulerTests.cpp
index 58714c51cc..2c75683ecb 100644
--- a/source/libs/scheduler/test/schedulerTests.cpp
+++ b/source/libs/scheduler/test/schedulerTests.cpp
@@ -29,7 +29,6 @@
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wwrite-strings"
-#pragma GCC diagnostic ignored "-Wliteral-suffix"
 #pragma GCC diagnostic ignored "-Wunused-function"
 #pragma GCC diagnostic ignored "-Wunused-variable"
 #pragma GCC diagnostic ignored "-Wsign-compare"
@@ -92,11 +91,11 @@ void schtBuildQueryDag(SQueryDag *dag) {
   scanPlan->id.templateId = 0x0000000000000002;
   scanPlan->id.subplanId = 0x0000000000000003;
   scanPlan->type = QUERY_TYPE_SCAN;
-  scanPlan->execNode.numOfEps = 1;
+
   scanPlan->execNode.nodeId = 1;
-  scanPlan->execNode.inUse = 0;
-  scanPlan->execNode.epAddr[0].port = 6030;
-  strcpy(scanPlan->execNode.epAddr[0].fqdn, "ep0");
+  scanPlan->execNode.epset.inUse = 0;
+  addEpIntoEpSet(&scanPlan->execNode.epset, "ep0", 6030);
+
   scanPlan->pChildren = NULL;
   scanPlan->level = 1;
   scanPlan->pParents = taosArrayInit(1, POINTER_BYTES);
@@ -108,7 +107,8 @@ void schtBuildQueryDag(SQueryDag *dag) {
   mergePlan->id.subplanId = 0x5555555555;
   mergePlan->type = QUERY_TYPE_MERGE;
   mergePlan->level = 0;
-  mergePlan->execNode.numOfEps = 0;
+  mergePlan->execNode.epset.numOfEps = 0;
+
   mergePlan->pChildren = taosArrayInit(1, POINTER_BYTES);
   mergePlan->pParents = NULL;
   mergePlan->pNode = (SPhyNode*)calloc(1, sizeof(SPhyNode));
@@ -144,11 +144,11 @@ void schtBuildInsertDag(SQueryDag *dag) {
   insertPlan[0].id.subplanId = 0x0000000000000004;
   insertPlan[0].type = QUERY_TYPE_MODIFY;
   insertPlan[0].level = 0;
-  insertPlan[0].execNode.numOfEps = 1;
+
   insertPlan[0].execNode.nodeId = 1;
-  insertPlan[0].execNode.inUse = 0;
-  insertPlan[0].execNode.epAddr[0].port = 6030;
-  strcpy(insertPlan[0].execNode.epAddr[0].fqdn, "ep0");
+  insertPlan[0].execNode.epset.inUse = 0;
+  addEpIntoEpSet(&insertPlan[0].execNode.epset, "ep0", 6030);
+
   insertPlan[0].pChildren = NULL;
   insertPlan[0].pParents = NULL;
   insertPlan[0].pNode = NULL;
@@ -160,11 +160,11 @@ void schtBuildInsertDag(SQueryDag *dag) {
   insertPlan[1].id.subplanId = 0x0000000000000005;
   insertPlan[1].type = QUERY_TYPE_MODIFY;
   insertPlan[1].level = 0;
-  insertPlan[1].execNode.numOfEps = 1;
+
   insertPlan[1].execNode.nodeId = 1;
-  insertPlan[1].execNode.inUse = 1;
-  insertPlan[1].execNode.epAddr[0].port = 6030;
-  strcpy(insertPlan[1].execNode.epAddr[0].fqdn, "ep1");
+  insertPlan[1].execNode.epset.inUse = 0;
+  addEpIntoEpSet(&insertPlan[1].execNode.epset, "ep0", 6030);
+
   insertPlan[1].pChildren = NULL;
   insertPlan[1].pParents = NULL;
   insertPlan[1].pNode = NULL;
@@ -371,14 +371,14 @@ void* schtRunJobThread(void *aa) {
   while (!schtTestStop) {
     schtBuildQueryDag(&dag);
 
-    SArray *qnodeList = taosArrayInit(1, sizeof(SEpAddr));
+    SArray *qnodeList = taosArrayInit(1, sizeof(SEp));
 
-    SEpAddr qnodeAddr = {0};
+    SEp qnodeAddr = {0};
     strcpy(qnodeAddr.fqdn, "qnode0.ep");
     qnodeAddr.port = 6031;
     taosArrayPush(qnodeList, &qnodeAddr);
 
-    code = schedulerAsyncExecJob(mockPointer, qnodeList, &dag, &job);
+    code = schedulerAsyncExecJob(mockPointer, qnodeList, &dag, "select * from tb", &job);
     assert(code == 0);
 
     execTasks = taosHashInit(5, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_ENTRY_LOCK);
@@ -523,9 +523,9 @@ TEST(queryTest, normalCase) {
 
   schtInitLogFile();
 
-  SArray *qnodeList = taosArrayInit(1, sizeof(SEpAddr));
+  SArray *qnodeList = taosArrayInit(1, sizeof(SEp));
 
-  SEpAddr qnodeAddr = {0};
+  SEp qnodeAddr = {0};
   strcpy(qnodeAddr.fqdn, "qnode0.ep");
   qnodeAddr.port = 6031;
   taosArrayPush(qnodeList, &qnodeAddr);
@@ -539,7 +539,7 @@ TEST(queryTest, normalCase) {
   schtSetExecNode();
   schtSetAsyncSendMsgToServer();
   
-  code = schedulerAsyncExecJob(mockPointer, qnodeList, &dag, &pJob);
+  code = schedulerAsyncExecJob(mockPointer, qnodeList, &dag, "select * from tb", &pJob);
   ASSERT_EQ(code, 0);
 
   SSchJob *job = (SSchJob *)pJob;
@@ -627,9 +627,9 @@ TEST(insertTest, normalCase) {
 
   schtInitLogFile();
 
-  SArray *qnodeList = taosArrayInit(1, sizeof(SEpAddr));
+  SArray *qnodeList = taosArrayInit(1, sizeof(SEp));
 
-  SEpAddr qnodeAddr = {0};
+  SEp qnodeAddr = {0};
   strcpy(qnodeAddr.fqdn, "qnode0.ep");
   qnodeAddr.port = 6031;
   taosArrayPush(qnodeList, &qnodeAddr);
@@ -649,7 +649,7 @@ TEST(insertTest, normalCase) {
   pthread_create(&(thread1), &thattr, schtSendRsp, &pInsertJob);
 
   SQueryResult res = {0};
-  code = schedulerExecJob(mockPointer, qnodeList, &dag, &pInsertJob, &res);
+  code = schedulerExecJob(mockPointer, qnodeList, &dag, &pInsertJob, "insert into tb values(now,1)", &res);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(res.numOfRows, 20);
 
diff --git a/source/libs/transport/CMakeLists.txt b/source/libs/transport/CMakeLists.txt
index 61d781210c..5c214b75a1 100644
--- a/source/libs/transport/CMakeLists.txt
+++ b/source/libs/transport/CMakeLists.txt
@@ -13,7 +13,7 @@ target_link_libraries(
     PUBLIC util
     PUBLIC common
 )
-if (${BUILD_WITH_UV}) 
+if (${BUILD_WITH_UV_TRANS}) 
   target_include_directories(
     transport    
     PUBLIC "${CMAKE_SOURCE_DIR}/contrib/libuv/include"
@@ -25,7 +25,7 @@ if (${BUILD_WITH_UV})
     PUBLIC uv_a
   )
   add_definitions(-DUSE_UV) 
-endif(${BUILD_WITH_UV})  
+endif(${BUILD_WITH_UV_TRANS})  
 
 if (${BUILD_TEST})
   add_subdirectory(test)
diff --git a/source/libs/transport/src/rpcMain.c b/source/libs/transport/src/rpcMain.c
index b0927e9ecf..a286482fc1 100644
--- a/source/libs/transport/src/rpcMain.c
+++ b/source/libs/transport/src/rpcMain.c
@@ -814,9 +814,9 @@ static SRpcConn *rpcSetupConnToServer(SRpcReqContext *pContext) {
   SEpSet *  pEpSet = &pContext->epSet;
 
   pConn =
-      rpcGetConnFromCache(pRpc->pCache, pEpSet->fqdn[pEpSet->inUse], pEpSet->port[pEpSet->inUse], pContext->connType);
+      rpcGetConnFromCache(pRpc->pCache, pEpSet->eps[pEpSet->inUse].fqdn, pEpSet->eps[pEpSet->inUse].port, pContext->connType);
   if (pConn == NULL || pConn->user[0] == 0) {
-    pConn = rpcOpenConn(pRpc, pEpSet->fqdn[pEpSet->inUse], pEpSet->port[pEpSet->inUse], pContext->connType);
+    pConn = rpcOpenConn(pRpc, pEpSet->eps[pEpSet->inUse].fqdn, pEpSet->eps[pEpSet->inUse].port, pContext->connType);
   }
 
   if (pConn) {
@@ -1188,7 +1188,7 @@ static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead, SRpcReqConte
 
     // for UDP, port may be changed by server, the port in epSet shall be used for cache
     if (pHead->code != TSDB_CODE_RPC_TOO_SLOW) {
-      rpcAddConnIntoCache(pRpc->pCache, pConn, pConn->peerFqdn, pContext->epSet.port[pContext->epSet.inUse],
+      rpcAddConnIntoCache(pRpc->pCache, pConn, pConn->peerFqdn, pContext->epSet.eps[pContext->epSet.inUse].port,
                           pConn->connType);
     } else {
       rpcCloseConn(pConn);
@@ -1202,9 +1202,9 @@ static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead, SRpcReqConte
         tDebug("%s, redirect is received, numOfEps:%d inUse:%d", pConn->info, pContext->epSet.numOfEps,
                pContext->epSet.inUse);
         for (int i = 0; i < pContext->epSet.numOfEps; ++i) {
-          pContext->epSet.port[i] = htons(pContext->epSet.port[i]);
-          tDebug("%s, redirect is received, index:%d ep:%s:%u", pConn->info, i, pContext->epSet.fqdn[i],
-                 pContext->epSet.port[i]);
+          pContext->epSet.eps[i].port = htons(pContext->epSet.eps[i].port);
+          tDebug("%s, redirect is received, index:%d ep:%s:%u", pConn->info, i, pContext->epSet.eps[i].fqdn,
+                 pContext->epSet.eps[i].port);
         }
       }
       rpcSendReqToServer(pRpc, pContext);
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index 4ffaad3f84..069ebaeb8a 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -45,13 +45,13 @@ typedef struct SCliThrdObj {
   pthread_t       thread;
   uv_loop_t*      loop;
   uv_async_t*     cliAsync;  //
-  uv_timer_t*     pTimer;
+  uv_timer_t*     timer;
   void*           pool;  // conn pool
   queue           msg;
   pthread_mutex_t msgMtx;
   uint64_t        nextTimeout;  // next timeout
   void*           pTransInst;   //
-
+  bool            quit;
 } SCliThrdObj;
 
 typedef struct SClientObj {
@@ -94,9 +94,13 @@ static void clientHandleResp(SCliConn* conn);
 static void clientHandleExcept(SCliConn* conn);
 // handle req from app
 static void clientHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd);
+static void clientHandleQuit(SCliMsg* pMsg, SCliThrdObj* pThrd);
+static void clientSendQuit(SCliThrdObj* thrd);
 
-static void clientMsgDestroy(SCliMsg* pMsg);
-static void destroyTransConnCtx(STransConnCtx* ctx);
+static void destroyUserdata(SRpcMsg* userdata);
+
+static void destroyCmsg(SCliMsg* cmsg);
+static void transDestroyConnCtx(STransConnCtx* ctx);
 // thread obj
 static SCliThrdObj* createThrdObj();
 static void         destroyThrdObj(SCliThrdObj* pThrd);
@@ -104,7 +108,8 @@ static void         destroyThrdObj(SCliThrdObj* pThrd);
 static void* clientThread(void* arg);
 
 static void clientHandleResp(SCliConn* conn) {
-  STransConnCtx* pCtx = ((SCliMsg*)conn->data)->ctx;
+  SCliMsg*       pMsg = conn->data;
+  STransConnCtx* pCtx = pMsg->ctx;
   SRpcInfo*      pRpc = pCtx->pTransInst;
 
   STransMsgHead* pHead = (STransMsgHead*)(conn->readBuf.buf);
@@ -122,41 +127,44 @@ static void clientHandleResp(SCliConn* conn) {
   (pRpc->cfp)(NULL, &rpcMsg, NULL);
   conn->notifyCount += 1;
 
-  SCliThrdObj* pThrd = conn->hostThrd;
-  tfree(conn->data);
-  // buf alread translated to rpcMsg.pCont
+  // buf's mem alread translated to rpcMsg.pCont
   transClearBuffer(&conn->readBuf);
 
   uv_read_start((uv_stream_t*)conn->stream, clientAllocBufferCb, clientReadCb);
+
+  SCliThrdObj* pThrd = conn->hostThrd;
   addConnToPool(pThrd->pool, pCtx->ip, pCtx->port, conn);
 
+  destroyCmsg(pMsg);
+  conn->data = NULL;
   // start thread's timer of conn pool if not active
-  if (!uv_is_active((uv_handle_t*)pThrd->pTimer) && pRpc->idleTime > 0) {
-    uv_timer_start((uv_timer_t*)pThrd->pTimer, clientTimeoutCb, CONN_PERSIST_TIME(pRpc->idleTime) / 2, 0);
+  if (!uv_is_active((uv_handle_t*)pThrd->timer) && pRpc->idleTime > 0) {
+    uv_timer_start((uv_timer_t*)pThrd->timer, clientTimeoutCb, CONN_PERSIST_TIME(pRpc->idleTime) / 2, 0);
   }
-  destroyTransConnCtx(pCtx);
 }
 static void clientHandleExcept(SCliConn* pConn) {
   if (pConn->data == NULL) {
+    // handle conn except in conn pool
     clientConnDestroy(pConn, true);
     return;
   }
-  tDebug("conn %p destroy", pConn);
+  tDebug("conn %p start to destroy", pConn);
   SCliMsg* pMsg = pConn->data;
-  transFreeMsg((pMsg->msg.pCont));
-  pMsg->msg.pCont = NULL;
+
+  destroyUserdata(&pMsg->msg);
 
   STransConnCtx* pCtx = pMsg->ctx;
-  SRpcInfo*      pRpc = pCtx->pTransInst;
 
   SRpcMsg rpcMsg = {0};
   rpcMsg.ahandle = pCtx->ahandle;
-  rpcMsg.code = -1;
+  rpcMsg.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
   // SRpcInfo* pRpc = pMsg->ctx->pRpc;
-  (pRpc->cfp)(NULL, &rpcMsg, NULL);
-  tfree(pConn->data);
+  (pCtx->pTransInst->cfp)(NULL, &rpcMsg, NULL);
   pConn->notifyCount += 1;
-  destroyTransConnCtx(pCtx);
+
+  destroyCmsg(pMsg);
+  pConn->data = NULL;
+  // transDestroyConnCtx(pCtx);
   clientConnDestroy(pConn, true);
 }
 
@@ -236,6 +244,7 @@ static void addConnToPool(void* pool, char* ip, uint32_t port, SCliConn* conn) {
   tDebug("conn %p added to conn pool, read buf cap: %d", conn, conn->readBuf.cap);
 
   SRpcInfo* pRpc = ((SCliThrdObj*)conn->hostThrd)->pTransInst;
+
   conn->expireTime = taosGetTimestampMs() + CONN_PERSIST_TIME(pRpc->idleTime);
   SConnList* plist = taosHashGet((SHashObj*)pool, key, strlen(key));
   conn->notifyCount = 0;
@@ -282,6 +291,9 @@ static void clientReadCb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf
   }
   assert(nread <= 0);
   if (nread == 0) {
+    // ref http://docs.libuv.org/en/v1.x/stream.html?highlight=uv_read_start#c.uv_read_cb
+    // nread might be 0, which does not indicate an error or EOF. This is equivalent to EAGAIN or EWOULDBLOCK under
+    // read(2).
     return;
   }
   if (nread < 0 || nread == UV_EOF) {
@@ -321,11 +333,11 @@ static void clientWriteCb(uv_write_t* req, int status) {
   if (status == 0) {
     tDebug("conn %p data already was written out", pConn);
     SCliMsg* pMsg = pConn->data;
-    if (pMsg != NULL) {
-      transFreeMsg((pMsg->msg.pCont));
-      pMsg->msg.pCont = NULL;
+    if (pMsg == NULL) {
+      // handle
+      return;
     }
-
+    destroyUserdata(&pMsg->msg);
   } else {
     tError("conn %p failed to write: %s", pConn, uv_err_name(status));
     clientHandleExcept(pConn);
@@ -364,6 +376,15 @@ static void clientConnCb(uv_connect_t* req, int status) {
   clientWrite(pConn);
 }
 
+static void clientHandleQuit(SCliMsg* pMsg, SCliThrdObj* pThrd) {
+  tDebug("thread %p start to quit", pThrd);
+  destroyCmsg(pMsg);
+  uv_close((uv_handle_t*)pThrd->cliAsync, NULL);
+  uv_timer_stop(pThrd->timer);
+  pThrd->quit = true;
+  // uv__async_stop(pThrd->cliAsync);
+  uv_stop(pThrd->loop);
+}
 static void clientHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd) {
   uint64_t et = taosGetTimestampUs();
   uint64_t el = et - pMsg->st;
@@ -378,7 +399,13 @@ static void clientHandleReq(SCliMsg* pMsg, SCliThrdObj* pThrd) {
     conn->data = pMsg;
     conn->writeReq->data = conn;
     transDestroyBuffer(&conn->readBuf);
+
+    if (pThrd->quit) {
+      clientHandleExcept(conn);
+      return;
+    }
     clientWrite(conn);
+
   } else {
     SCliConn* conn = calloc(1, sizeof(SCliConn));
     conn->ref++;
@@ -419,7 +446,12 @@ static void clientAsyncCb(uv_async_t* handle) {
     QUEUE_REMOVE(h);
 
     SCliMsg* pMsg = QUEUE_DATA(h, SCliMsg, q);
-    clientHandleReq(pMsg, pThrd);
+    if (pMsg->ctx == NULL) {
+      clientHandleQuit(pMsg, pThrd);
+    } else {
+      clientHandleReq(pMsg, pThrd);
+    }
+    // clientHandleReq(pMsg, pThrd);
     count++;
   }
   if (count >= 2) {
@@ -447,14 +479,26 @@ void* taosInitClient(uint32_t ip, uint32_t port, char* label, int numOfThreads,
 
     int err = pthread_create(&pThrd->thread, NULL, clientThread, (void*)(pThrd));
     if (err == 0) {
-      tDebug("sucess to create tranport-client thread %d", i);
+      tDebug("success to create tranport-client thread %d", i);
     }
     cli->pThreadObj[i] = pThrd;
   }
   return cli;
 }
-static void clientMsgDestroy(SCliMsg* pMsg) {
-  // impl later
+
+static void destroyUserdata(SRpcMsg* userdata) {
+  if (userdata->pCont == NULL) {
+    return;
+  }
+  transFreeMsg(userdata->pCont);
+  userdata->pCont = NULL;
+}
+static void destroyCmsg(SCliMsg* pMsg) {
+  if (pMsg == NULL) {
+    return;
+  }
+  transDestroyConnCtx(pMsg->ctx);
+  destroyUserdata(&pMsg->msg);
   free(pMsg);
 }
 static SCliThrdObj* createThrdObj() {
@@ -469,35 +513,51 @@ static SCliThrdObj* createThrdObj() {
   uv_async_init(pThrd->loop, pThrd->cliAsync, clientAsyncCb);
   pThrd->cliAsync->data = pThrd;
 
-  pThrd->pTimer = malloc(sizeof(uv_timer_t));
-  uv_timer_init(pThrd->loop, pThrd->pTimer);
-  pThrd->pTimer->data = pThrd;
+  pThrd->timer = malloc(sizeof(uv_timer_t));
+  uv_timer_init(pThrd->loop, pThrd->timer);
+  pThrd->timer->data = pThrd;
 
   pThrd->pool = creatConnPool(1);
+
+  pThrd->quit = false;
   return pThrd;
 }
 static void destroyThrdObj(SCliThrdObj* pThrd) {
   if (pThrd == NULL) {
     return;
   }
+  uv_stop(pThrd->loop);
   pthread_join(pThrd->thread, NULL);
   pthread_mutex_destroy(&pThrd->msgMtx);
   free(pThrd->cliAsync);
+  free(pThrd->timer);
   free(pThrd->loop);
   free(pThrd);
 }
 
-static void destroyTransConnCtx(STransConnCtx* ctx) {
+static void transDestroyConnCtx(STransConnCtx* ctx) {
   if (ctx != NULL) {
     free(ctx->ip);
   }
   free(ctx);
 }
 //
+static void clientSendQuit(SCliThrdObj* thrd) {
+  // cli can stop gracefully
+  SCliMsg* msg = calloc(1, sizeof(SCliMsg));
+  msg->ctx = NULL;  //
+
+  pthread_mutex_lock(&thrd->msgMtx);
+  QUEUE_PUSH(&thrd->msg, &msg->q);
+  pthread_mutex_unlock(&thrd->msgMtx);
+
+  uv_async_send(thrd->cliAsync);
+}
 void taosCloseClient(void* arg) {
   // impl later
   SClientObj* cli = arg;
   for (int i = 0; i < cli->numOfThreads; i++) {
+    clientSendQuit(cli->pThreadObj[i]);
     destroyThrdObj(cli->pThreadObj[i]);
   }
   free(cli->pThreadObj);
diff --git a/source/libs/transport/src/transSrv.c b/source/libs/transport/src/transSrv.c
index 485ed904e8..475ef32b46 100644
--- a/source/libs/transport/src/transSrv.c
+++ b/source/libs/transport/src/transSrv.c
@@ -70,6 +70,7 @@ typedef struct SServerObj {
   uv_pipe_t**    pipe;
   uint32_t       ip;
   uint32_t       port;
+  uv_async_t*    pAcceptAsync;  // just to quit from from accept thread
 } SServerObj;
 
 static const char* notify = "a";
@@ -88,10 +89,12 @@ static void uvOnPipeWriteCb(uv_write_t* req, int status);
 static void uvOnAcceptCb(uv_stream_t* stream, int status);
 static void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf);
 static void uvWorkerAsyncCb(uv_async_t* handle);
+static void uvAcceptAsyncCb(uv_async_t* handle);
 
 static void uvPrepareSendData(SSrvMsg* msg, uv_buf_t* wb);
 static void uvStartSendResp(SSrvMsg* msg);
-static void destroySrvMsg(SSrvConn* conn);
+
+static void destroySmsg(SSrvMsg* smsg);
 // check whether already read complete packet
 static bool      readComplete(SConnBuffer* buf);
 static SSrvConn* createConn();
@@ -305,8 +308,10 @@ void uvOnTimeoutCb(uv_timer_t* handle) {
 
 void uvOnWriteCb(uv_write_t* req, int status) {
   SSrvConn* conn = req->data;
-  SSrvMsg*  smsg = conn->pSrvMsg;
-  destroySrvMsg(conn);
+
+  SSrvMsg* smsg = conn->pSrvMsg;
+  destroySmsg(smsg);
+  conn->pSrvMsg = NULL;
 
   transClearBuffer(&conn->readBuf);
   if (status == 0) {
@@ -362,14 +367,12 @@ static void uvStartSendResp(SSrvMsg* smsg) {
 
   return;
 }
-static void destroySrvMsg(SSrvConn* conn) {
-  SSrvMsg* smsg = conn->pSrvMsg;
+static void destroySmsg(SSrvMsg* smsg) {
   if (smsg == NULL) {
     return;
   }
   transFreeMsg(smsg->msg.pCont);
-  free(conn->pSrvMsg);
-  conn->pSrvMsg = NULL;
+  free(smsg);
 }
 void uvWorkerAsyncCb(uv_async_t* handle) {
   SWorkThrdObj* pThrd = handle->data;
@@ -389,7 +392,13 @@ void uvWorkerAsyncCb(uv_async_t* handle) {
       tError("except occurred, continue");
       continue;
     }
-    uvStartSendResp(msg);
+    if (msg->pConn == NULL) {
+      //
+      free(msg);
+      uv_stop(pThrd->loop);
+    } else {
+      uvStartSendResp(msg);
+    }
     // uv_buf_t wb;
     // uvPrepareSendData(msg, &wb);
     // uv_timer_stop(conn->pTimer);
@@ -397,6 +406,10 @@ void uvWorkerAsyncCb(uv_async_t* handle) {
     // uv_write(conn->pWriter, (uv_stream_t*)conn->pTcp, &wb, 1, uvOnWriteCb);
   }
 }
+static void uvAcceptAsyncCb(uv_async_t* async) {
+  SServerObj* srv = async->data;
+  uv_stop(srv->loop);
+}
 
 void uvOnAcceptCb(uv_stream_t* stream, int status) {
   if (status == -1) {
@@ -517,8 +530,12 @@ static bool addHandleToAcceptloop(void* arg) {
     return false;
   }
 
-  struct sockaddr_in bind_addr;
+  // register an async here to quit server gracefully
+  srv->pAcceptAsync = calloc(1, sizeof(uv_async_t));
+  uv_async_init(srv->loop, srv->pAcceptAsync, uvAcceptAsyncCb);
+  srv->pAcceptAsync->data = srv;
 
+  struct sockaddr_in bind_addr;
   uv_ip4_addr("0.0.0.0", srv->port, &bind_addr);
   if ((err = uv_tcp_bind(&srv->server, (const struct sockaddr*)&bind_addr, 0)) != 0) {
     tError("failed to bind: %s", uv_err_name(err));
@@ -546,16 +563,13 @@ static void destroyConn(SSrvConn* conn, bool clear) {
   if (conn == NULL) {
     return;
   }
-  // SRpcMsg* pMsg = &conn->sendMsg;
-  // transFreeMsg(pMsg->pCont);
-  // pMsg->pCont = NULL;
-
   tDebug("conn %p try to destroy", conn);
   if (--conn->ref > 0) {
     return;
   }
   transDestroyBuffer(&conn->readBuf);
-  destroySrvMsg(conn);
+  destroySmsg(conn->pSrvMsg);
+  conn->pSrvMsg = NULL;
 
   if (clear) {
     uv_close((uv_handle_t*)conn->pTcp, uvDestroyConn);
@@ -650,21 +664,42 @@ void destroyWorkThrd(SWorkThrdObj* pThrd) {
     return;
   }
   pthread_join(pThrd->thread, NULL);
-  // free(srv->pipe[i]);
   free(pThrd->loop);
-  pthread_mutex_destroy(&pThrd->msgMtx);
+  free(pThrd->workerAsync);
   free(pThrd);
 }
+void sendQuitToWorkThrd(SWorkThrdObj* pThrd) {
+  SSrvMsg* srvMsg = calloc(1, sizeof(SSrvMsg));
+
+  pthread_mutex_lock(&pThrd->msgMtx);
+  QUEUE_PUSH(&pThrd->msg, &srvMsg->q);
+  pthread_mutex_unlock(&pThrd->msgMtx);
+  tDebug("send quit msg to work thread");
+
+  uv_async_send(pThrd->workerAsync);
+}
+
 void taosCloseServer(void* arg) {
   // impl later
   SServerObj* srv = arg;
   for (int i = 0; i < srv->numOfThreads; i++) {
+    sendQuitToWorkThrd(srv->pThreadObj[i]);
     destroyWorkThrd(srv->pThreadObj[i]);
   }
-  free(srv->loop);
-  free(srv->pipe);
-  free(srv->pThreadObj);
+
+  tDebug("send quit msg to accept thread");
+  uv_async_send(srv->pAcceptAsync);
   pthread_join(srv->thread, NULL);
+
+  free(srv->pThreadObj);
+  free(srv->pAcceptAsync);
+  free(srv->loop);
+
+  for (int i = 0; i < srv->numOfThreads; i++) {
+    free(srv->pipe[i]);
+  }
+  free(srv->pipe);
+
   free(srv);
 }
 
diff --git a/source/libs/transport/test/CMakeLists.txt b/source/libs/transport/test/CMakeLists.txt
index c61f688060..3d9c396336 100644
--- a/source/libs/transport/test/CMakeLists.txt
+++ b/source/libs/transport/test/CMakeLists.txt
@@ -1,6 +1,12 @@
 add_executable(transportTest "")
 add_executable(client "")
 add_executable(server "")
+add_executable(transUT "")
+
+target_sources(transUT
+  PRIVATE
+  "transUT.cc"
+)  
 
 target_sources(transportTest 
   PRIVATE
@@ -28,6 +34,13 @@ target_link_libraries (transportTest
   gtest_main
   transport 
 )
+target_link_libraries (transUT
+  os  
+  util
+  common
+  gtest_main
+  transport 
+)
 
 target_include_directories(client
   PUBLIC
@@ -48,6 +61,13 @@ target_include_directories(server
   "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
 ) 
 
+target_include_directories(transUT
+  PUBLIC
+  "${CMAKE_SOURCE_DIR}/include/libs/transport" 
+  "${CMAKE_CURRENT_SOURCE_DIR}/../inc"
+) 
+
+
 target_link_libraries (server
   os  
   util
diff --git a/source/libs/transport/test/rclient.c b/source/libs/transport/test/rclient.c
index f9ad20c065..6767e704b5 100644
--- a/source/libs/transport/test/rclient.c
+++ b/source/libs/transport/test/rclient.c
@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <tep.h>
 #include "os.h"
 #include "rpcLog.h"
 #include "taoserror.h"
@@ -87,12 +88,9 @@ int main(int argc, char *argv[]) {
   pthread_attr_t thattr;
 
   // server info
-  epSet.numOfEps = 1;
   epSet.inUse = 0;
-  epSet.port[0] = 7000;
-  epSet.port[1] = 7000;
-  strcpy(epSet.fqdn[0], serverIp);
-  strcpy(epSet.fqdn[1], "192.168.0.1");
+  addEpIntoEpSet(&epSet, serverIp, 7000);
+  addEpIntoEpSet(&epSet, "192.168.0.1", 7000);
 
   // client info
   memset(&rpcInit, 0, sizeof(rpcInit));
@@ -110,9 +108,9 @@ int main(int argc, char *argv[]) {
 
   for (int i = 1; i < argc; ++i) {
     if (strcmp(argv[i], "-p") == 0 && i < argc - 1) {
-      epSet.port[0] = atoi(argv[++i]);
+      epSet.eps[0].port = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-i") == 0 && i < argc - 1) {
-      tstrncpy(epSet.fqdn[0], argv[++i], sizeof(epSet.fqdn[0]));
+      tstrncpy(epSet.eps[0].fqdn, argv[++i], sizeof(epSet.eps[0].fqdn));
     } else if (strcmp(argv[i], "-t") == 0 && i < argc - 1) {
       rpcInit.numOfThreads = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-m") == 0 && i < argc - 1) {
@@ -136,7 +134,7 @@ int main(int argc, char *argv[]) {
     } else {
       printf("\nusage: %s [options] \n", argv[0]);
       printf("  [-i ip]: first server IP address, default is:%s\n", serverIp);
-      printf("  [-p port]: server port number, default is:%d\n", epSet.port[0]);
+      printf("  [-p port]: server port number, default is:%d\n", epSet.eps[0].port);
       printf("  [-t threads]: number of rpc threads, default is:%d\n", rpcInit.numOfThreads);
       printf("  [-s sessions]: number of rpc sessions, default is:%d\n", rpcInit.sessions);
       printf("  [-m msgSize]: message body size, default is:%d\n", msgSize);
diff --git a/source/libs/transport/test/rserver.c b/source/libs/transport/test/rserver.c
index 12d8a01819..d1a587f4e5 100644
--- a/source/libs/transport/test/rserver.c
+++ b/source/libs/transport/test/rserver.c
@@ -165,6 +165,7 @@ int main(int argc, char *argv[]) {
     tError("failed to start RPC server");
     return -1;
   }
+  // sleep(5);
 
   tInfo("RPC server is running, ctrl-c to exit");
 
@@ -172,7 +173,6 @@ int main(int argc, char *argv[]) {
     dataFd = open(dataName, O_APPEND | O_CREAT | O_WRONLY, S_IRWXU | S_IRWXG | S_IRWXO);
     if (dataFd < 0) tInfo("failed to open data file, reason:%s", strerror(errno));
   }
-
   qhandle = taosOpenQueue();
   qset = taosOpenQset();
   taosAddIntoQset(qset, qhandle, NULL);
diff --git a/source/libs/transport/test/transUT.cc b/source/libs/transport/test/transUT.cc
new file mode 100644
index 0000000000..08c683590b
--- /dev/null
+++ b/source/libs/transport/test/transUT.cc
@@ -0,0 +1,82 @@
+/*
+ * 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 <cstdio>
+#include <cstring>
+#include "trpc.h"
+using namespace std;
+
+class TransObj {
+ public:
+  TransObj() {
+    const char *label = "APP";
+    const char *secret = "secret";
+    const char *user = "user";
+    const char *ckey = "ckey";
+
+    memset(&rpcInit, 0, sizeof(rpcInit));
+    rpcInit.localPort = 0;
+    rpcInit.label = (char *)label;
+    rpcInit.numOfThreads = 5;
+    rpcInit.cfp = NULL;
+    rpcInit.sessions = 100;
+    rpcInit.idleTime = 100;
+    rpcInit.user = (char *)user;
+    rpcInit.secret = (char *)secret;
+    rpcInit.ckey = (char *)ckey;
+    rpcInit.spi = 1;
+  }
+  bool startCli() {
+    trans = NULL;
+    rpcInit.connType = TAOS_CONN_CLIENT;
+    trans = rpcOpen(&rpcInit);
+    return trans != NULL ? true : false;
+  }
+  bool startSrv() {
+    trans = NULL;
+    rpcInit.connType = TAOS_CONN_SERVER;
+    trans = rpcOpen(&rpcInit);
+    return trans != NULL ? true : false;
+  }
+  bool stop() {
+    rpcClose(trans);
+    trans = NULL;
+    return true;
+  }
+
+ private:
+  void *   trans;
+  SRpcInit rpcInit;
+};
+class TransEnv : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    // set up trans obj
+    tr = new TransObj();
+  }
+  virtual void TearDown() {
+    // tear down
+    delete tr;
+  }
+
+  TransObj *tr = NULL;
+};
+TEST_F(TransEnv, test_start_stop) {
+  assert(tr->startCli());
+  assert(tr->stop());
+
+  assert(tr->startSrv());
+  assert(tr->stop());
+}
diff --git a/source/nodes/src/nodesClone.c b/source/nodes/src/nodesCloneFuncs.c
similarity index 93%
rename from source/nodes/src/nodesClone.c
rename to source/nodes/src/nodesCloneFuncs.c
index 04f6df5623..2d0a6483ae 100644
--- a/source/nodes/src/nodesClone.c
+++ b/source/nodes/src/nodesCloneFuncs.c
@@ -15,6 +15,6 @@
 
 #include "nodes.h"
 
-void cloneNode(const SNode* pNode) {
+void nodesCloneNode(const SNode* pNode) {
 
 }
diff --git a/source/nodes/src/nodesCodeFuncs.c b/source/nodes/src/nodesCodeFuncs.c
new file mode 100644
index 0000000000..959e10fb82
--- /dev/null
+++ b/source/nodes/src/nodesCodeFuncs.c
@@ -0,0 +1,45 @@
+/*
+ * 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 "nodes.h"
+
+int32_t nodesNodeToString(const SNode* pNode, char** pStr, int32_t* pLen) {
+  switch (nodeType(pNode)) {
+    case QUERY_NODE_COLUMN:
+    case QUERY_NODE_VALUE:
+    case QUERY_NODE_OPERATOR:
+    case QUERY_NODE_LOGIC_CONDITION:
+    case QUERY_NODE_IS_NULL_CONDITION:
+    case QUERY_NODE_FUNCTION:
+    case QUERY_NODE_REAL_TABLE:
+    case QUERY_NODE_TEMP_TABLE:
+    case QUERY_NODE_JOIN_TABLE:
+    case QUERY_NODE_GROUPING_SET:
+    case QUERY_NODE_ORDER_BY_EXPR:
+    case QUERY_NODE_LIMIT:
+    case QUERY_NODE_STATE_WINDOW:
+    case QUERY_NODE_SESSION_WINDOW:
+    case QUERY_NODE_INTERVAL_WINDOW:
+    case QUERY_NODE_SET_OPERATOR:
+    case QUERY_NODE_SELECT_STMT:
+    case QUERY_NODE_SHOW_STMT:
+    default:
+      break;
+  }
+}
+
+int32_t nodesStringToNode(const char* pStr, SNode** pNode) {
+
+}
diff --git a/source/nodes/src/nodesEqual.c b/source/nodes/src/nodesEqualFuncs.c
similarity index 86%
rename from source/nodes/src/nodesEqual.c
rename to source/nodes/src/nodesEqualFuncs.c
index bef025fbea..f2752fe7f9 100644
--- a/source/nodes/src/nodesEqual.c
+++ b/source/nodes/src/nodesEqualFuncs.c
@@ -32,17 +32,17 @@
 
 #define COMPARE_NODE_FIELD(fldname) \
 	do { \
-		if (!nodeEqual(a->fldname, b->fldname)) \
+		if (!nodesEqualNode(a->fldname, b->fldname)) \
 			return false; \
 	} while (0)
 
-#define COMPARE_ARRAY_FIELD(fldname) \
+#define COMPARE_NODE_LIST_FIELD(fldname) \
 	do { \
-		if (!nodeArrayEqual(a->fldname, b->fldname)) \
+		if (!nodeNodeListEqual(a->fldname, b->fldname)) \
 			return false; \
 	} while (0)
 
-static bool nodeArrayEqual(const SArray* a, const SArray* b) {
+static bool nodeNodeListEqual(const SNodeList* a, const SNodeList* b) {
   if (a == b) {
     return true;
   }
@@ -51,13 +51,13 @@ static bool nodeArrayEqual(const SArray* a, const SArray* b) {
     return false;
   }
 
-  if (taosArrayGetSize(a) != taosArrayGetSize(b)) {
+  if (LIST_LENGTH(a) != LIST_LENGTH(b)) {
     return false;
   }
 
-  size_t size = taosArrayGetSize(a);
-  for (size_t i = 0; i < size; ++i) {
-    if (!nodeEqual((SNode*)taosArrayGetP(a, i), (SNode*)taosArrayGetP(b, i))) {
+  SNode* na, *nb;
+  FORBOTH(na, a, nb, b) {
+    if (!nodesEqualNode(na, nb)) {
       return false;
     }
   }
@@ -85,7 +85,7 @@ static bool operatorNodeEqual(const SOperatorNode* a, const SOperatorNode* b) {
 
 static bool logicConditionNodeEqual(const SLogicConditionNode* a, const SLogicConditionNode* b) {
   COMPARE_SCALAR_FIELD(condType);
-  COMPARE_ARRAY_FIELD(pParameterList);
+  COMPARE_NODE_LIST_FIELD(pParameterList);
   return true;
 }
 
@@ -97,11 +97,11 @@ static bool isNullConditionNodeEqual(const SIsNullCondNode* a, const SIsNullCond
 
 static bool functionNodeEqual(const SFunctionNode* a, const SFunctionNode* b) {
   COMPARE_SCALAR_FIELD(funcId);
-  COMPARE_ARRAY_FIELD(pParameterList);
+  COMPARE_NODE_LIST_FIELD(pParameterList);
   return true;
 }
 
-bool nodeEqual(const SNode* a, const SNode* b) {
+bool nodesEqualNode(const SNode* a, const SNode* b) {
   if (a == b) {
     return true;
   }
@@ -132,6 +132,7 @@ bool nodeEqual(const SNode* a, const SNode* b) {
     case QUERY_NODE_JOIN_TABLE:
     case QUERY_NODE_GROUPING_SET:
     case QUERY_NODE_ORDER_BY_EXPR:
+    case QUERY_NODE_LIMIT:
       return false; // todo
     default:
       break;
diff --git a/source/nodes/src/nodesTraverse.c b/source/nodes/src/nodesTraverseFuncs.c
similarity index 57%
rename from source/nodes/src/nodesTraverse.c
rename to source/nodes/src/nodesTraverseFuncs.c
index eac8288099..ffe40073e6 100644
--- a/source/nodes/src/nodesTraverse.c
+++ b/source/nodes/src/nodesTraverseFuncs.c
@@ -17,17 +17,17 @@
 
 typedef bool (*FQueryNodeWalker)(SNode* pNode, void* pContext);
 
-bool nodeArrayWalker(SArray* pArray, FQueryNodeWalker walker, void* pContext) {
-    size_t size = taosArrayGetSize(pArray);
-    for (size_t i = 0; i < size; ++i) {
-      if (!nodeTreeWalker((SNode*)taosArrayGetP(pArray, i), walker, pContext)) {
-        return false;
-      }
+bool nodesWalkNodeList(SNodeList* pNodeList, FQueryNodeWalker walker, void* pContext) {
+  SNode* node;
+  FOREACH(node, pNodeList) {
+    if (!nodesWalkNode(node, walker, pContext)) {
+      return false;
     }
-    return true;
+  }
+  return true;
 }
 
-bool nodeTreeWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
+bool nodesWalkNode(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
   if (NULL == pNode) {
     return true;
   }
@@ -39,38 +39,39 @@ bool nodeTreeWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
   switch (nodeType(pNode)) {
     case QUERY_NODE_COLUMN:
     case QUERY_NODE_VALUE:
+    case QUERY_NODE_LIMIT:
       // these node types with no subnodes
       return true;
     case QUERY_NODE_OPERATOR: {
       SOperatorNode* pOpNode = (SOperatorNode*)pNode;
-      if (!nodeTreeWalker(pOpNode->pLeft, walker, pContext)) {
+      if (!nodesWalkNode(pOpNode->pLeft, walker, pContext)) {
         return false;
       }
-      return nodeTreeWalker(pOpNode->pRight, walker, pContext);
+      return nodesWalkNode(pOpNode->pRight, walker, pContext);
     }
     case QUERY_NODE_LOGIC_CONDITION:
-      return nodeArrayWalker(((SLogicConditionNode*)pNode)->pParameterList, walker, pContext);
+      return nodesWalkNodeList(((SLogicConditionNode*)pNode)->pParameterList, walker, pContext);
     case QUERY_NODE_IS_NULL_CONDITION:
-      return nodeTreeWalker(((SIsNullCondNode*)pNode)->pExpr, walker, pContext);
+      return nodesWalkNode(((SIsNullCondNode*)pNode)->pExpr, walker, pContext);
     case QUERY_NODE_FUNCTION:
-      return nodeArrayWalker(((SFunctionNode*)pNode)->pParameterList, walker, pContext);
+      return nodesWalkNodeList(((SFunctionNode*)pNode)->pParameterList, walker, pContext);
     case QUERY_NODE_REAL_TABLE:
     case QUERY_NODE_TEMP_TABLE:
       return true; // todo
     case QUERY_NODE_JOIN_TABLE: {
       SJoinTableNode* pJoinTableNode = (SJoinTableNode*)pNode;
-      if (!nodeTreeWalker(pJoinTableNode->pLeft, walker, pContext)) {
+      if (!nodesWalkNode(pJoinTableNode->pLeft, walker, pContext)) {
         return false;
       }
-      if (!nodeTreeWalker(pJoinTableNode->pRight, walker, pContext)) {
+      if (!nodesWalkNode(pJoinTableNode->pRight, walker, pContext)) {
         return false;
       }
-      return nodeTreeWalker(pJoinTableNode->pOnCond, walker, pContext);
+      return nodesWalkNode(pJoinTableNode->pOnCond, walker, pContext);
     }
     case QUERY_NODE_GROUPING_SET:
-      return nodeArrayWalker(((SGroupingSetNode*)pNode)->pParameterList, walker, pContext);
+      return nodesWalkNodeList(((SGroupingSetNode*)pNode)->pParameterList, walker, pContext);
     case QUERY_NODE_ORDER_BY_EXPR:
-      return nodeTreeWalker(((SOrderByExprNode*)pNode)->pExpr, walker, pContext);
+      return nodesWalkNode(((SOrderByExprNode*)pNode)->pExpr, walker, pContext);
     default:
       break;
   }
@@ -78,6 +79,6 @@ bool nodeTreeWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
   return false;
 }
 
-bool stmtWalker(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
+bool nodesWalkStmt(SNode* pNode, FQueryNodeWalker walker, void* pContext) {
 
 }
diff --git a/source/nodes/src/nodesUtilFuncs.c b/source/nodes/src/nodesUtilFuncs.c
new file mode 100644
index 0000000000..535bd8e171
--- /dev/null
+++ b/source/nodes/src/nodesUtilFuncs.c
@@ -0,0 +1,83 @@
+/*
+ * 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 "nodes.h"
+#include "nodesShowStmts.h"
+
+bool nodesIsTimeorderQuery(const SNode* pQuery) {
+
+}
+
+bool nodesIsTimelineQuery(const SNode* pQuery) {
+
+}
+
+static SNode* makeNode(ENodeType type, size_t size) {
+  SNode* p = calloc(1, size);
+  setNodeType(p, type);
+  return p;
+}
+
+SNode* nodesMakeNode(ENodeType type) {
+  switch (type) {
+    case QUERY_NODE_COLUMN:
+      return makeNode(type, sizeof(SColumnNode));
+    case QUERY_NODE_VALUE:
+      return makeNode(type, sizeof(SValueNode));
+    case QUERY_NODE_OPERATOR:
+      return makeNode(type, sizeof(SOperatorNode));
+    case QUERY_NODE_LOGIC_CONDITION:
+      return makeNode(type, sizeof(SLogicConditionNode));
+    case QUERY_NODE_IS_NULL_CONDITION:
+      return makeNode(type, sizeof(SIsNullCondNode));
+    case QUERY_NODE_FUNCTION:
+      return makeNode(type, sizeof(SFunctionNode));
+    case QUERY_NODE_REAL_TABLE:
+      return makeNode(type, sizeof(SRealTableNode));
+    case QUERY_NODE_TEMP_TABLE:
+      return makeNode(type, sizeof(STempTableNode));
+    case QUERY_NODE_JOIN_TABLE:
+      return makeNode(type, sizeof(SJoinTableNode));
+    case QUERY_NODE_GROUPING_SET:
+      return makeNode(type, sizeof(SGroupingSetNode));
+    case QUERY_NODE_ORDER_BY_EXPR:
+      return makeNode(type, sizeof(SOrderByExprNode));
+    case QUERY_NODE_LIMIT:
+      return makeNode(type, sizeof(SLimitNode));
+    case QUERY_NODE_STATE_WINDOW:
+      return makeNode(type, sizeof(SStateWindowNode));
+    case QUERY_NODE_SESSION_WINDOW:
+      return makeNode(type, sizeof(SSessionWindowNode));
+    case QUERY_NODE_INTERVAL_WINDOW:
+      return makeNode(type, sizeof(SIntervalWindowNode));
+    case QUERY_NODE_SET_OPERATOR:
+      return makeNode(type, sizeof(SSetOperator));
+    case QUERY_NODE_SELECT_STMT:
+      return makeNode(type, sizeof(SSelectStmt));
+    case QUERY_NODE_SHOW_STMT:
+      return makeNode(type, sizeof(SShowStmt));
+    default:
+      break;
+  }
+  return NULL;
+}
+
+void nodesDestroyNode(SNode* pNode) {
+
+}
+
+void nodesDestroyNodeList(SNodeList* pList) {
+
+}
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index 56919ff99e..489fff5d64 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -410,7 +410,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_FS_INVLD_LEVEL,               "tfs invalid level")
 TAOS_DEFINE_ERROR(TSDB_CODE_FS_NO_VALID_DISK,             "tfs no valid disk")
 
 // catalog
-TAOS_DEFINE_ERROR(TSDB_CODE_CTG_INTERNAL_ERROR,           "catalog interval error")
+TAOS_DEFINE_ERROR(TSDB_CODE_CTG_INTERNAL_ERROR,           "catalog internal error")
 TAOS_DEFINE_ERROR(TSDB_CODE_CTG_INVALID_INPUT,            "invalid catalog input parameters")
 TAOS_DEFINE_ERROR(TSDB_CODE_CTG_NOT_READY,                "catalog is not ready")
 TAOS_DEFINE_ERROR(TSDB_CODE_CTG_MEM_ERROR,                "catalog memory error")
diff --git a/source/util/src/tworker.c b/source/util/src/tworker.c
index 97440f8dae..ca4e5a6f30 100644
--- a/source/util/src/tworker.c
+++ b/source/util/src/tworker.c
@@ -181,7 +181,7 @@ static void *tFWorkerThreadFp(SQWorker *worker) {
 }
 
 STaosQueue *tFWorkerAllocQueue(SQWorkerPool *pool, void *ahandle, FItem fp) {
-  return tWorkerAllocQueue(pool, ahandle, fp, (ThreadFp)tFWorkerThreadFp);
+  return tWorkerAllocQueue(pool, ahandle, fp, (ThreadFp)tQWorkerThreadFp);
 }
 
 void tFWorkerFreeQueue(SFWorkerPool *pool, STaosQueue *queue) { tQWorkerFreeQueue(pool, queue); }
diff --git a/tools/shell/src/shellEngine.c b/tools/shell/src/shellEngine.c
index c283423fbf..4186f0dae1 100644
--- a/tools/shell/src/shellEngine.c
+++ b/tools/shell/src/shellEngine.c
@@ -360,6 +360,7 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
     }
   } else {
     int num_rows_affacted = taos_affected_rows(pSql);
+    taos_free_result(pSql);
     et = taosGetTimestampUs();
     printf("Query OK, %d of %d row(s) in database (%.6fs)\n", num_rows_affacted, num_rows_affacted, (et - st) / 1E6);
   }
@@ -965,7 +966,7 @@ int isCommentLine(char *line) {
 void source_file(TAOS *con, char *fptr) {
   wordexp_t full_path;
   int       read_len = 0;
-  char     *cmd = calloc(1, tsMaxSQLStringLen + 1);
+  char     *cmd = calloc(1, TSDB_MAX_ALLOWED_SQL_LEN + 1);
   size_t    cmd_len = 0;
   char     *line = NULL;
   size_t    line_len = 0;
@@ -997,7 +998,7 @@ void source_file(TAOS *con, char *fptr) {
   }
 
   while ((read_len = tgetline(&line, &line_len, f)) != -1) {
-    if (read_len >= tsMaxSQLStringLen) continue;
+    if (read_len >= TSDB_MAX_ALLOWED_SQL_LEN) continue;
     line[--read_len] = '\0';
 
     if (read_len == 0 || isCommentLine(line)) {  // line starts with #
@@ -1014,7 +1015,7 @@ void source_file(TAOS *con, char *fptr) {
     memcpy(cmd + cmd_len, line, read_len);
     printf("%s%s\n", PROMPT_HEADER, cmd);
     shellRunCommand(con, cmd);
-    memset(cmd, 0, tsMaxSQLStringLen);
+    memset(cmd, 0, TSDB_MAX_ALLOWED_SQL_LEN);
     cmd_len = 0;
   }