diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 7f3a73f96e..39f1bd172b 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -57,46 +57,6 @@ extern int   tMsgDict[];
 
 typedef uint16_t tmsg_t;
 
-/* ------------------------ ENCODE/DECODE FUNCTIONS AND MACROS ------------------------ */
-struct SMEListNode {
-  TD_SLIST_NODE(SMEListNode);
-  SEncoder coder;
-};
-
-typedef struct SMsgEncoder {
-  SEncoder coder;
-  TD_SLIST(SMEListNode) eStack;  // encode stack
-} SMsgEncoder;
-
-struct SMDFreeListNode {
-  TD_SLIST_NODE(SMDFreeListNode);
-  char payload[];
-};
-
-struct SMDListNode {
-  TD_SLIST_NODE(SMDListNode);
-  SDecoder coder;
-};
-
-typedef struct SMsgDecoder {
-  SDecoder coder;
-  TD_SLIST(SMDListNode) dStack;
-  TD_SLIST(SMDFreeListNode) freeList;
-} SMsgDecoder;
-
-#define TMSG_MALLOC(SIZE, DECODER)                                         \
-  ({                                                                       \
-    void* ptr = malloc((SIZE) + sizeof(struct SMDFreeListNode));           \
-    if (ptr) {                                                             \
-      TD_SLIST_PUSH(&((DECODER)->freeList), (struct SMDFreeListNode*)ptr); \
-      ptr = POINTER_SHIFT(ptr, sizeof(struct SMDFreeListNode*));           \
-    }                                                                      \
-    ptr;                                                                   \
-  })
-
-void tmsgInitMsgDecoder(SMsgDecoder* pMD, td_endian_t endian, uint8_t* data, int64_t size);
-void tmsgClearMsgDecoder(SMsgDecoder* pMD);
-
 /* ------------------------ OTHER DEFINITIONS ------------------------ */
 // IE type
 #define TSDB_IE_TYPE_SEC 1
@@ -1286,10 +1246,10 @@ typedef struct {
   SArray*  pArray;
 } SVCreateTbBatchReq;
 
-int   tmsgSVCreateTbReqEncode(SMsgEncoder* pCoder, SVCreateTbReq* pReq);
-int   tmsgSVCreateTbReqDecode(SMsgDecoder* pCoder, SVCreateTbReq* pReq);
-int   tSerializeSVCreateTbReq(void** buf, const SVCreateTbReq* pReq);
+int   tSerializeSVCreateTbReq(void** buf, SVCreateTbReq* pReq);
 void* tDeserializeSVCreateTbReq(void* buf, SVCreateTbReq* pReq);
+int   tSVCreateTbBatchReqSerialize(void** buf, SVCreateTbBatchReq* pReq);
+void* tSVCreateTbBatchReqDeserialize(void* buf, SVCreateTbBatchReq* pReq);
 
 typedef struct SVCreateTbRsp {
 } SVCreateTbRsp;
diff --git a/include/common/tmsgtype.h b/include/common/tmsgtype.h
index 8e7ad87a0a..ebbf99b942 100644
--- a/include/common/tmsgtype.h
+++ b/include/common/tmsgtype.h
@@ -40,8 +40,9 @@ enum {
   // the SQL below is for mgmt node
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MGMT, "mgmt" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_DB, "create-db" )
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_STABLE, "create-stable" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_TABLE, "create-table" )
-  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_FUNCTION, "create-function" )  
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_FUNCTION, "create-function" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_DB, "drop-db" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_TABLE, "drop-table" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_DROP_FUNCTION, "drop-function" )
diff --git a/include/libs/parser/parsenodes.h b/include/libs/parser/parsenodes.h
index 041adbb582..b326ac032c 100644
--- a/include/libs/parser/parsenodes.h
+++ b/include/libs/parser/parsenodes.h
@@ -27,7 +27,7 @@ extern "C" {
 #include "tname.h"
 #include "tvariant.h"
 
-/*
+/**
  * The first field of a node of any type is guaranteed to be the int16_t.
  * Hence the type of any node can be gotten by casting it to SQueryNode. 
  */
@@ -157,7 +157,7 @@ typedef struct SVgDataBlocks {
 typedef struct SInsertStmtInfo {
   int16_t     nodeType;
   SArray*     pDataBlocks;         // data block for each vgroup, SArray<SVgDataBlocks*>.
-  int8_t      schemaAttache;        // denote if submit block is built with table schema or not
+  int8_t      schemaAttache;       // denote if submit block is built with table schema or not
   uint8_t     payloadType;         // EPayloadType. 0: K-V payload for non-prepare insert, 1: rawPayload for prepare insert
   uint32_t    insertType;          // insert data from [file|sql statement| bound statement]
   const char* sql;                 // current sql statement position
diff --git a/include/libs/planner/planner.h b/include/libs/planner/planner.h
index 81a6d59e8d..e55a2b1c7a 100644
--- a/include/libs/planner/planner.h
+++ b/include/libs/planner/planner.h
@@ -120,11 +120,12 @@ typedef struct SSubplanId {
 } SSubplanId;
 
 typedef struct SSubplan {
-  SSubplanId id;          // unique id of the subplan
+  SSubplanId id;           // unique id of the subplan
   int32_t    type;         // QUERY_TYPE_MERGE|QUERY_TYPE_PARTIAL|QUERY_TYPE_SCAN|QUERY_TYPE_MODIFY
-  int32_t    level;        // the execution level of current subplan, starting from 0.
+  int32_t    msgType;      // message type for subplan, used to denote the send message type to vnode.
+  int32_t    level;        // the execution level of current subplan, starting from 0 in a top-down manner.
   SQueryNodeAddr     execNode;    // for the scan/modify subplan, the optional execution node
-  SArray    *pChildern;    // the datasource subplan,from which to fetch the result
+  SArray    *pChildren;    // the datasource subplan,from which to fetch the result
   SArray    *pParents;     // the data destination subplan, get data from current subplan
   SPhyNode  *pNode;        // physical plan of current subplan
   SDataSink *pDataSink;    // data of the subplan flow into the datasink
diff --git a/include/util/encode.h b/include/util/encode.h
index ee35791012..ba63759737 100644
--- a/include/util/encode.h
+++ b/include/util/encode.h
@@ -16,6 +16,7 @@
 #ifndef _TD_UTIL_ENCODE_H_
 #define _TD_UTIL_ENCODE_H_
 
+#include "freelist.h"
 #include "tcoding.h"
 #include "tmacro.h"
 
@@ -23,13 +24,6 @@
 extern "C" {
 #endif
 
-typedef struct {
-  td_endian_t endian;
-  uint8_t*    data;
-  int32_t     size;
-  int32_t     pos;
-} SEncoder, SDecoder;
-
 #define tPut(TYPE, BUF, VAL) ((TYPE*)(BUF))[0] = (VAL)
 #define tGet(TYPE, BUF, VAL) (VAL) = ((TYPE*)(BUF))[0]
 
@@ -57,31 +51,157 @@ typedef struct {
 #define tRGet32 tRPut32
 #define tRGet64 tRPut64
 
+typedef enum { TD_ENCODER, TD_DECODER } td_coder_t;
+
+#define CODER_NODE_FIELDS \
+  uint8_t* data;          \
+  int32_t  size;          \
+  int32_t  pos;
+
+struct SCoderNode {
+  TD_SLIST_NODE(SCoderNode);
+  CODER_NODE_FIELDS
+};
+
+typedef struct {
+  td_coder_t  type;
+  td_endian_t endian;
+  SFreeList   fl;
+  CODER_NODE_FIELDS
+  TD_SLIST(SCoderNode) stack;
+} SCoder;
+
+#define TD_CODER_POS(CODER) ((CODER)->pos)
 #define TD_CODER_CURRENT(CODER) ((CODER)->data + (CODER)->pos)
 #define TD_CODER_MOVE_POS(CODER, MOVE) ((CODER)->pos += (MOVE))
-#define TD_CHECK_CODER_CAPACITY_FAILED(CODER, EXPSIZE) (((CODER)->size - (CODER)->pos) < (EXPSIZE))
+#define TD_CODER_CHECK_CAPACITY_FAILED(CODER, EXPSIZE) (((CODER)->size - (CODER)->pos) < (EXPSIZE))
+#define TCODER_MALLOC(SIZE, CODER) TFL_MALLOC(SIZE, &((CODER)->fl))
 
-/* ------------------------ FOR ENCODER ------------------------ */
-static FORCE_INLINE void tInitEncoder(SEncoder* pEncoder, td_endian_t endian, uint8_t* data, int32_t size) {
-  pEncoder->endian = endian;
-  pEncoder->data = data;
-  pEncoder->size = (data) ? size : 0;
-  pEncoder->pos = 0;
-}
+void tCoderInit(SCoder* pCoder, td_endian_t endian, uint8_t* data, int32_t size, td_coder_t type);
+void tCoderClear(SCoder* pCoder);
+
+/* ------------------------ ENCODE ------------------------ */
+int        tStartEncode(SCoder* pEncoder);
+void       tEndEncode(SCoder* pEncoder);
+static int tEncodeU8(SCoder* pEncoder, uint8_t val);
+static int tEncodeI8(SCoder* pEncoder, int8_t val);
+static int tEncodeU16(SCoder* pEncoder, uint16_t val);
+static int tEncodeI16(SCoder* pEncoder, int16_t val);
+static int tEncodeU32(SCoder* pEncoder, uint32_t val);
+static int tEncodeI32(SCoder* pEncoder, int32_t val);
+static int tEncodeU64(SCoder* pEncoder, uint64_t val);
+static int tEncodeI64(SCoder* pEncoder, int64_t val);
+static int tEncodeU16v(SCoder* pEncoder, uint16_t val);
+static int tEncodeI16v(SCoder* pEncoder, int16_t val);
+static int tEncodeU32v(SCoder* pEncoder, uint32_t val);
+static int tEncodeI32v(SCoder* pEncoder, int32_t val);
+static int tEncodeU64v(SCoder* pEncoder, uint64_t val);
+static int tEncodeI64v(SCoder* pEncoder, int64_t val);
+static int tEncodeFloat(SCoder* pEncoder, float val);
+static int tEncodeDouble(SCoder* pEncoder, double val);
+static int tEncodeBinary(SCoder* pEncoder, const void* val, uint64_t len);
+static int tEncodeCStrWithLen(SCoder* pEncoder, const char* val, uint64_t len);
+static int tEncodeCStr(SCoder* pEncoder, const char* val);
+
+/* ------------------------ DECODE ------------------------ */
+int         tStartDecode(SCoder* pDecoder);
+void        tEndDecode(SCoder* pDecoder);
+static bool tDecodeIsEnd(SCoder* pCoder);
+static int  tDecodeU8(SCoder* pDecoder, uint8_t* val);
+static int  tDecodeI8(SCoder* pDecoder, int8_t* val);
+static int  tDecodeU16(SCoder* pDecoder, uint16_t* val);
+static int  tDecodeI16(SCoder* pDecoder, int16_t* val);
+static int  tDecodeU32(SCoder* pDecoder, uint32_t* val);
+static int  tDecodeI32(SCoder* pDecoder, int32_t* val);
+static int  tDecodeU64(SCoder* pDecoder, uint64_t* val);
+static int  tDecodeI64(SCoder* pDecoder, int64_t* val);
+static int  tDecodeU16v(SCoder* pDecoder, uint16_t* val);
+static int  tDecodeI16v(SCoder* pDecoder, int16_t* val);
+static int  tDecodeU32v(SCoder* pDecoder, uint32_t* val);
+static int  tDecodeI32v(SCoder* pDecoder, int32_t* val);
+static int  tDecodeU64v(SCoder* pDecoder, uint64_t* val);
+static int  tDecodeI64v(SCoder* pDecoder, int64_t* val);
+static int  tDecodeFloat(SCoder* pDecoder, float* val);
+static int  tDecodeDouble(SCoder* pDecoder, double* val);
+static int  tDecodeBinary(SCoder* pDecoder, const void** val, uint64_t* len);
+static int  tDecodeCStrAndLen(SCoder* pDecoder, const char** val, uint64_t* len);
+static int  tDecodeCStr(SCoder* pDecoder, const char** val);
+static int  tDecodeCStrTo(SCoder* pDecoder, char* val);
+
+/* ------------------------ IMPL ------------------------ */
+#define TD_ENCODE_MACRO(CODER, VAL, TYPE, BITS)                        \
+  if ((CODER)->data) {                                                 \
+    if (TD_CODER_CHECK_CAPACITY_FAILED(CODER, sizeof(VAL))) return -1; \
+    if (TD_RT_ENDIAN() == (CODER)->endian) {                           \
+      tPut(TYPE, TD_CODER_CURRENT(CODER), (VAL));                      \
+    } else {                                                           \
+      tRPut##BITS(TD_CODER_CURRENT(CODER), &(VAL));                    \
+    }                                                                  \
+  }                                                                    \
+  TD_CODER_MOVE_POS(CODER, sizeof(VAL));                               \
+  return 0;
+
+#define TD_ENCODE_VARIANT_MACRO(CODER, VAL)                       \
+  while ((VAL) >= ENCODE_LIMIT) {                                 \
+    if ((CODER)->data) {                                          \
+      if (TD_CODER_CHECK_CAPACITY_FAILED(CODER, 1)) return -1;    \
+      TD_CODER_CURRENT(CODER)[0] = ((VAL) | ENCODE_LIMIT) & 0xff; \
+    }                                                             \
+                                                                  \
+    (VAL) >>= 7;                                                  \
+    TD_CODER_MOVE_POS(CODER, 1);                                  \
+  }                                                               \
+                                                                  \
+  if ((CODER)->data) {                                            \
+    if (TD_CODER_CHECK_CAPACITY_FAILED(CODER, 1)) return -1;      \
+    TD_CODER_CURRENT(CODER)[0] = (uint8_t)(VAL);                  \
+  }                                                               \
+  TD_CODER_MOVE_POS(CODER, 1);                                    \
+  return 0;
+
+#define TD_DECODE_MACRO(CODER, PVAL, TYPE, BITS)                         \
+  if (TD_CODER_CHECK_CAPACITY_FAILED(CODER, sizeof(*(PVAL)))) return -1; \
+  if (TD_RT_ENDIAN() == (CODER)->endian) {                               \
+    tGet(TYPE, TD_CODER_CURRENT(CODER), *(PVAL));                        \
+  } else {                                                               \
+    tRGet##BITS(PVAL, TD_CODER_CURRENT(CODER));                          \
+  }                                                                      \
+                                                                         \
+  TD_CODER_MOVE_POS(CODER, sizeof(*(PVAL)));                             \
+  return 0;
+
+#define TD_DECODE_VARIANT_MACRO(CODER, PVAL, TYPE)           \
+  int32_t i = 0;                                             \
+  *(PVAL) = 0;                                               \
+  for (;;) {                                                 \
+    if (TD_CODER_CHECK_CAPACITY_FAILED(CODER, 1)) return -1; \
+    TYPE tval = TD_CODER_CURRENT(CODER)[0];                  \
+    if (tval < ENCODE_LIMIT) {                               \
+      *(PVAL) |= (tval << (7 * i));                          \
+      TD_CODER_MOVE_POS(pDecoder, 1);                        \
+      break;                                                 \
+    } else {                                                 \
+      *(PVAL) |= (((tval) & (ENCODE_LIMIT - 1)) << (7 * i)); \
+      i++;                                                   \
+      TD_CODER_MOVE_POS(pDecoder, 1);                        \
+    }                                                        \
+  }                                                          \
+                                                             \
+  return 0;
 
 // 8
-static FORCE_INLINE int tEncodeU8(SEncoder* pEncoder, uint8_t val) {
+static FORCE_INLINE int tEncodeU8(SCoder* pEncoder, uint8_t val) {
   if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    if (TD_CODER_CHECK_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
     tPut(uint8_t, TD_CODER_CURRENT(pEncoder), val);
   }
   TD_CODER_MOVE_POS(pEncoder, sizeof(val));
   return 0;
 }
 
-static FORCE_INLINE int tEncodeI8(SEncoder* pEncoder, int8_t val) {
+static FORCE_INLINE int tEncodeI8(SCoder* pEncoder, int8_t val) {
   if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    if (TD_CODER_CHECK_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
     tPut(int8_t, TD_CODER_CURRENT(pEncoder), val);
   }
   TD_CODER_MOVE_POS(pEncoder, sizeof(val));
@@ -89,303 +209,99 @@ static FORCE_INLINE int tEncodeI8(SEncoder* pEncoder, int8_t val) {
 }
 
 // 16
-static FORCE_INLINE int tEncodeU16(SEncoder* pEncoder, uint16_t val) {
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
-    if (TD_RT_ENDIAN() == pEncoder->endian) {
-      tPut(uint16_t, TD_CODER_CURRENT(pEncoder), val);
-    } else {
-      tRPut16(TD_CODER_CURRENT(pEncoder), &val);
-    }
-  }
-  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
-  return 0;
-}
-
-static FORCE_INLINE int tEncodeI16(SEncoder* pEncoder, int16_t val) {
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
-    if (TD_RT_ENDIAN() == pEncoder->endian) {
-      tPut(int16_t, TD_CODER_CURRENT(pEncoder), val);
-    } else {
-      tRPut16(TD_CODER_CURRENT(pEncoder), &val);
-    }
-  }
-  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
-  return 0;
-}
-
+static FORCE_INLINE int tEncodeU16(SCoder* pEncoder, uint16_t val) { TD_ENCODE_MACRO(pEncoder, val, uint16_t, 16); }
+static FORCE_INLINE int tEncodeI16(SCoder* pEncoder, int16_t val) { TD_ENCODE_MACRO(pEncoder, val, int16_t, 16); }
 // 32
-static FORCE_INLINE int tEncodeU32(SEncoder* pEncoder, uint32_t val) {
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
-    if (TD_RT_ENDIAN() == pEncoder->endian) {
-      tPut(uint32_t, TD_CODER_CURRENT(pEncoder), val);
-    } else {
-      tRPut32(TD_CODER_CURRENT(pEncoder), &val);
-    }
-  }
-  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
-  return 0;
-}
-
-static FORCE_INLINE int tEncodeI32(SEncoder* pEncoder, int32_t val) {
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
-    if (TD_RT_ENDIAN() == pEncoder->endian) {
-      tPut(int32_t, TD_CODER_CURRENT(pEncoder), val);
-    } else {
-      tRPut32(TD_CODER_CURRENT(pEncoder), &val);
-    }
-  }
-  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
-  return 0;
-}
-
+static FORCE_INLINE int tEncodeU32(SCoder* pEncoder, uint32_t val) { TD_ENCODE_MACRO(pEncoder, val, uint32_t, 32); }
+static FORCE_INLINE int tEncodeI32(SCoder* pEncoder, int32_t val) { TD_ENCODE_MACRO(pEncoder, val, int32_t, 32); }
 // 64
-static FORCE_INLINE int tEncodeU64(SEncoder* pEncoder, uint64_t val) {
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
-    if (TD_RT_ENDIAN() == pEncoder->endian) {
-      tPut(uint64_t, TD_CODER_CURRENT(pEncoder), val);
-    } else {
-      tRPut64(TD_CODER_CURRENT(pEncoder), &val);
-    }
-  }
-  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
-  return 0;
-}
-
-static FORCE_INLINE int tEncodeI64(SEncoder* pEncoder, int64_t val) {
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
-    if (TD_RT_ENDIAN() == pEncoder->endian) {
-      tPut(int64_t, TD_CODER_CURRENT(pEncoder), val);
-    } else {
-      tRPut64(TD_CODER_CURRENT(pEncoder), &val);
-    }
-  }
-  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
-  return 0;
-}
-
+static FORCE_INLINE int tEncodeU64(SCoder* pEncoder, uint64_t val) { TD_ENCODE_MACRO(pEncoder, val, uint64_t, 64); }
+static FORCE_INLINE int tEncodeI64(SCoder* pEncoder, int64_t val) { TD_ENCODE_MACRO(pEncoder, val, int64_t, 64); }
 // 16v
-static FORCE_INLINE int tEncodeU16v(SEncoder* pEncoder, uint16_t val) {
-  int64_t i = 0;
-  while (val >= ENCODE_LIMIT) {
-    if (pEncoder->data) {
-      if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
-      TD_CODER_CURRENT(pEncoder)[i] = (val | ENCODE_LIMIT) & 0xff;
-    }
-
-    val >>= 7;
-    i++;
-  }
-
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
-    TD_CODER_CURRENT(pEncoder)[i] = (uint8_t)val;
-  }
-
-  TD_CODER_MOVE_POS(pEncoder, i + 1);
-
-  return 0;
-}
-
-static FORCE_INLINE int tEncodeI16v(SEncoder* pEncoder, int16_t val) {
+static FORCE_INLINE int tEncodeU16v(SCoder* pEncoder, uint16_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
+static FORCE_INLINE int tEncodeI16v(SCoder* pEncoder, int16_t val) {
   return tEncodeU16v(pEncoder, ZIGZAGE(int16_t, val));
 }
-
 // 32v
-static FORCE_INLINE int tEncodeU32v(SEncoder* pEncoder, uint32_t val) {
-  int64_t i = 0;
-  while (val >= ENCODE_LIMIT) {
-    if (pEncoder->data) {
-      if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
-      TD_CODER_CURRENT(pEncoder)[i] = (val | ENCODE_LIMIT) & 0xff;
-    }
-
-    val >>= 7;
-    i++;
-  }
-
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
-    TD_CODER_CURRENT(pEncoder)[i] = (uint8_t)val;
-  }
-
-  TD_CODER_MOVE_POS(pEncoder, i + 1);
-
-  return 0;
-}
-
-static FORCE_INLINE int tEncodeI32v(SEncoder* pEncoder, int32_t val) {
+static FORCE_INLINE int tEncodeU32v(SCoder* pEncoder, uint32_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
+static FORCE_INLINE int tEncodeI32v(SCoder* pEncoder, int32_t val) {
   return tEncodeU32v(pEncoder, ZIGZAGE(int32_t, val));
 }
-
 // 64v
-static FORCE_INLINE int tEncodeU64v(SEncoder* pEncoder, uint64_t val) {
-  int64_t i = 0;
-  while (val >= ENCODE_LIMIT) {
-    if (pEncoder->data) {
-      if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
-      TD_CODER_CURRENT(pEncoder)[i] = (val | ENCODE_LIMIT) & 0xff;
-    }
-
-    val >>= 7;
-    i++;
-  }
-
-  if (pEncoder->data) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
-    TD_CODER_CURRENT(pEncoder)[i] = (uint8_t)val;
-  }
-
-  TD_CODER_MOVE_POS(pEncoder, i + 1);
-
-  return 0;
-}
-
-static FORCE_INLINE int tEncodeI64v(SEncoder* pEncoder, int64_t val) {
+static FORCE_INLINE int tEncodeU64v(SCoder* pEncoder, uint64_t val) { TD_ENCODE_VARIANT_MACRO(pEncoder, val); }
+static FORCE_INLINE int tEncodeI64v(SCoder* pEncoder, int64_t val) {
   return tEncodeU64v(pEncoder, ZIGZAGE(int64_t, val));
 }
 
-static FORCE_INLINE int tEncodeFloat(SEncoder* pEncoder, float val) {
-  // TODO
+static FORCE_INLINE int tEncodeFloat(SCoder* pEncoder, float val) {
+  union {
+    uint32_t ui;
+    float    f;
+  } v = {.f = val};
+
+  return tEncodeU32(pEncoder, v.ui);
+}
+
+static FORCE_INLINE int tEncodeDouble(SCoder* pEncoder, double val) {
+  union {
+    uint64_t ui;
+    double   d;
+  } v = {.d = val};
+
+  return tEncodeU64(pEncoder, v.ui);
+}
+
+static FORCE_INLINE int tEncodeBinary(SCoder* pEncoder, const void* val, uint64_t len) {
+  if (tEncodeU64v(pEncoder, len) < 0) return -1;
+  if (pEncoder->data) {
+    if (TD_CODER_CHECK_CAPACITY_FAILED(pEncoder, len)) return -1;
+    memcpy(TD_CODER_CURRENT(pEncoder), val, len);
+  }
+
+  TD_CODER_MOVE_POS(pEncoder, len);
   return 0;
 }
 
-static FORCE_INLINE int tEncodeDouble(SEncoder* pEncoder, double val) {
-  // TODO
-  return 0;
+static FORCE_INLINE int tEncodeCStrWithLen(SCoder* pEncoder, const char* val, uint64_t len) {
+  return tEncodeBinary(pEncoder, (void*)val, len + 1);
 }
 
-static FORCE_INLINE int tEncodeCStr(SEncoder* pEncoder, const char* val) {
-  // TODO
-  return 0;
+static FORCE_INLINE int tEncodeCStr(SCoder* pEncoder, const char* val) {
+  return tEncodeCStrWithLen(pEncoder, val, (uint64_t)strlen(val));
 }
 
 /* ------------------------ FOR DECODER ------------------------ */
-static FORCE_INLINE void tInitDecoder(SDecoder* pDecoder, td_endian_t endian, uint8_t* data, int32_t size) {
-  ASSERT(!TD_IS_NULL(data));
-  pDecoder->endian = endian;
-  pDecoder->data = data;
-  pDecoder->size = size;
-  pDecoder->pos = 0;
-}
-
 // 8
-static FORCE_INLINE int tDecodeU8(SDecoder* pDecoder, uint8_t* val) {
-  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+static FORCE_INLINE int tDecodeU8(SCoder* pDecoder, uint8_t* val) {
+  if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
   tGet(uint8_t, TD_CODER_CURRENT(pDecoder), *val);
   TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
   return 0;
 }
 
-static FORCE_INLINE int tDecodeI8(SDecoder* pDecoder, int8_t* val) {
-  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+static FORCE_INLINE int tDecodeI8(SCoder* pDecoder, int8_t* val) {
+  if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
   tGet(int8_t, TD_CODER_CURRENT(pDecoder), *val);
   TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
   return 0;
 }
 
 // 16
-static FORCE_INLINE int tDecodeU16(SDecoder* pDecoder, uint16_t* val) {
-  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
-  if (TD_RT_ENDIAN() == pDecoder->endian) {
-    tGet(uint16_t, TD_CODER_CURRENT(pDecoder), *val);
-  } else {
-    tRGet16(val, TD_CODER_CURRENT(pDecoder));
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
-  return 0;
-}
-
-static FORCE_INLINE int tDecodeI16(SDecoder* pDecoder, int16_t* val) {
-  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
-  if (TD_RT_ENDIAN() == pDecoder->endian) {
-    tGet(int16_t, TD_CODER_CURRENT(pDecoder), *val);
-  } else {
-    tRGet16(val, TD_CODER_CURRENT(pDecoder));
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
-  return 0;
-}
-
+static FORCE_INLINE int tDecodeU16(SCoder* pDecoder, uint16_t* val) { TD_DECODE_MACRO(pDecoder, val, uint16_t, 16); }
+static FORCE_INLINE int tDecodeI16(SCoder* pDecoder, int16_t* val) { TD_DECODE_MACRO(pDecoder, val, int16_t, 16); }
 // 32
-static FORCE_INLINE int tDecodeU32(SDecoder* pDecoder, uint32_t* val) {
-  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
-  if (TD_RT_ENDIAN() == pDecoder->endian) {
-    tGet(uint32_t, TD_CODER_CURRENT(pDecoder), *val);
-  } else {
-    tRGet32(val, TD_CODER_CURRENT(pDecoder));
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
-  return 0;
-}
-
-static FORCE_INLINE int tDecodeI32(SDecoder* pDecoder, int32_t* val) {
-  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
-  if (TD_RT_ENDIAN() == pDecoder->endian) {
-    tGet(int32_t, TD_CODER_CURRENT(pDecoder), *val);
-  } else {
-    tRGet32(val, TD_CODER_CURRENT(pDecoder));
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
-  return 0;
-}
-
+static FORCE_INLINE int tDecodeU32(SCoder* pDecoder, uint32_t* val) { TD_DECODE_MACRO(pDecoder, val, uint32_t, 32); }
+static FORCE_INLINE int tDecodeI32(SCoder* pDecoder, int32_t* val) { TD_DECODE_MACRO(pDecoder, val, int32_t, 32); }
 // 64
-static FORCE_INLINE int tDecodeU64(SDecoder* pDecoder, uint64_t* val) {
-  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
-  if (TD_RT_ENDIAN() == pDecoder->endian) {
-    tGet(uint64_t, TD_CODER_CURRENT(pDecoder), *val);
-  } else {
-    tRGet64(val, TD_CODER_CURRENT(pDecoder));
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
-  return 0;
-}
-
-static FORCE_INLINE int tDecodeI64(SDecoder* pDecoder, int64_t* val) {
-  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
-  if (TD_RT_ENDIAN() == pDecoder->endian) {
-    tGet(int64_t, TD_CODER_CURRENT(pDecoder), *val);
-  } else {
-    tRGet64(val, TD_CODER_CURRENT(pDecoder));
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
-  return 0;
-}
+static FORCE_INLINE int tDecodeU64(SCoder* pDecoder, uint64_t* val) { TD_DECODE_MACRO(pDecoder, val, uint64_t, 64); }
+static FORCE_INLINE int tDecodeI64(SCoder* pDecoder, int64_t* val) { TD_DECODE_MACRO(pDecoder, val, int64_t, 64); }
 
 // 16v
-static FORCE_INLINE int tDecodeU16v(SDecoder* pDecoder, uint16_t* val) {
-  int64_t i = 0;
-  *val = 0;
-  for (;;) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, 1)) return -1;
-    uint16_t tval = TD_CODER_CURRENT(pDecoder)[i];
-    if (tval < ENCODE_LIMIT) {
-      (*val) |= (tval << (7 * i));
-      break;
-    } else {
-      (*val) |= (((tval) & (ENCODE_LIMIT - 1)) << (7 * i));
-      i++;
-    }
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, i);
-
-  return 0;
+static FORCE_INLINE int tDecodeU16v(SCoder* pDecoder, uint16_t* val) {
+  TD_DECODE_VARIANT_MACRO(pDecoder, val, uint16_t);
 }
 
-static FORCE_INLINE int tDecodeI16v(SDecoder* pDecoder, int16_t* val) {
+static FORCE_INLINE int tDecodeI16v(SCoder* pDecoder, int16_t* val) {
   uint16_t tval;
   if (tDecodeU16v(pDecoder, &tval) < 0) {
     return -1;
@@ -395,27 +311,11 @@ static FORCE_INLINE int tDecodeI16v(SDecoder* pDecoder, int16_t* val) {
 }
 
 // 32v
-static FORCE_INLINE int tDecodeU32v(SDecoder* pDecoder, uint32_t* val) {
-  int64_t i = 0;
-  *val = 0;
-  for (;;) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, 1)) return -1;
-    uint32_t tval = TD_CODER_CURRENT(pDecoder)[i];
-    if (tval < ENCODE_LIMIT) {
-      (*val) |= (tval << (7 * i));
-      break;
-    } else {
-      (*val) |= (((tval) & (ENCODE_LIMIT - 1)) << (7 * i));
-      i++;
-    }
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, i);
-
-  return 0;
+static FORCE_INLINE int tDecodeU32v(SCoder* pDecoder, uint32_t* val) {
+  TD_DECODE_VARIANT_MACRO(pDecoder, val, uint32_t);
 }
 
-static FORCE_INLINE int tDecodeI32v(SDecoder* pDecoder, int32_t* val) {
+static FORCE_INLINE int tDecodeI32v(SCoder* pDecoder, int32_t* val) {
   uint32_t tval;
   if (tDecodeU32v(pDecoder, &tval) < 0) {
     return -1;
@@ -425,27 +325,11 @@ static FORCE_INLINE int tDecodeI32v(SDecoder* pDecoder, int32_t* val) {
 }
 
 // 64v
-static FORCE_INLINE int tDecodeU64v(SDecoder* pDecoder, uint64_t* val) {
-  int64_t i = 0;
-  *val = 0;
-  for (;;) {
-    if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, 1)) return -1;
-    uint64_t tval = TD_CODER_CURRENT(pDecoder)[i];
-    if (tval < ENCODE_LIMIT) {
-      (*val) |= (tval << (7 * i));
-      break;
-    } else {
-      (*val) |= (((tval) & (ENCODE_LIMIT - 1)) << (7 * i));
-      i++;
-    }
-  }
-
-  TD_CODER_MOVE_POS(pDecoder, i);
-
-  return 0;
+static FORCE_INLINE int tDecodeU64v(SCoder* pDecoder, uint64_t* val) {
+  TD_DECODE_VARIANT_MACRO(pDecoder, val, uint64_t);
 }
 
-static FORCE_INLINE int tDecodeI64v(SDecoder* pDecoder, int64_t* val) {
+static FORCE_INLINE int tDecodeI64v(SCoder* pDecoder, int64_t* val) {
   uint64_t tval;
   if (tDecodeU64v(pDecoder, &tval) < 0) {
     return -1;
@@ -454,21 +338,66 @@ static FORCE_INLINE int tDecodeI64v(SDecoder* pDecoder, int64_t* val) {
   return 0;
 }
 
-static FORCE_INLINE int tDecodeFloat(SDecoder* pDecoder, float* val) {
-  // TODO
+static FORCE_INLINE int tDecodeFloat(SCoder* pDecoder, float* val) {
+  union {
+    uint32_t ui;
+    float    f;
+  } v;
+
+  if (tDecodeU32(pDecoder, &(v.ui)) < 0) {
+    return -1;
+  }
+
+  *val = v.f;
   return 0;
 }
 
-static FORCE_INLINE int tDecodeDouble(SDecoder* pDecoder, double* val) {
-  // TODO
+static FORCE_INLINE int tDecodeDouble(SCoder* pDecoder, double* val) {
+  union {
+    uint64_t ui;
+    double   d;
+  } v;
+
+  if (tDecodeU64(pDecoder, &(v.ui)) < 0) {
+    return -1;
+  }
+
+  *val = v.d;
   return 0;
 }
 
-static FORCE_INLINE int tDecodeCStr(SDecoder* pEncoder, const char** val) {
-  // TODO
+static FORCE_INLINE int tDecodeBinary(SCoder* pDecoder, const void** val, uint64_t* len) {
+  if (tDecodeU64v(pDecoder, len) < 0) return -1;
+
+  if (TD_CODER_CHECK_CAPACITY_FAILED(pDecoder, *len)) return -1;
+  *val = (void*)TD_CODER_CURRENT(pDecoder);
+
+  TD_CODER_MOVE_POS(pDecoder, *len);
   return 0;
 }
 
+static FORCE_INLINE int tDecodeCStrAndLen(SCoder* pDecoder, const char** val, uint64_t* len) {
+  if (tDecodeBinary(pDecoder, (const void**)val, len) < 0) return -1;
+  (*len) -= 1;
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeCStr(SCoder* pDecoder, const char** val) {
+  uint64_t len;
+  return tDecodeCStrAndLen(pDecoder, val, &len);
+}
+
+static int tDecodeCStrTo(SCoder* pDecoder, char* val) {
+  const char* pStr;
+  uint64_t    len;
+  if (tDecodeCStrAndLen(pDecoder, &pStr, &len) < 0) return -1;
+
+  memcpy(val, pStr, len + 1);
+  return 0;
+}
+
+static FORCE_INLINE bool tDecodeIsEnd(SCoder* pCoder) { return (pCoder->size == pCoder->pos); }
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/client/CMakeLists.txt b/source/client/CMakeLists.txt
index ad6a93415c..3210c0c6de 100644
--- a/source/client/CMakeLists.txt
+++ b/source/client/CMakeLists.txt
@@ -11,4 +11,6 @@ target_link_libraries(
     PRIVATE os util common transport parser planner catalog scheduler function qcom
 )
 
-ADD_SUBDIRECTORY(test)
\ No newline at end of file
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
\ No newline at end of file
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 050e763919..b0b2c57ee4 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -202,7 +202,7 @@ int32_t getPlan(SRequestObj* pRequest, SQueryNode* pQuery, SQueryDag** pDag) {
 }
 
 int32_t scheduleQuery(SRequestObj* pRequest, SQueryDag* pDag, void** pJob) {
-  if (TSDB_SQL_INSERT == pRequest->type) {
+  if (TSDB_SQL_INSERT == pRequest->type || TSDB_SQL_CREATE_TABLE == pRequest->type) {
     return scheduleExecJob(pRequest->pTscObj->pTransporter, NULL/*todo appInfo.xxx*/, pDag, pJob, &pRequest->affectedRows);
   }
   return scheduleAsyncExecJob(pRequest->pTscObj->pTransporter, NULL/*todo appInfo.xxx*/, pDag, pJob);
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index 894b810d7b..e5f3eba5c2 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -29,7 +29,7 @@ int taos_options(TSDB_OPTION option, const void *arg, ...) {
 
 // this function may be called by user or system, or by both simultaneously.
 void taos_cleanup(void) {
-  tscDebug("start to cleanup client environment");
+  tscInfo("start to cleanup client environment");
 
   if (atomic_val_compare_exchange_32(&sentinel, TSC_VAR_NOT_RELEASE, TSC_VAR_RELEASED) != TSC_VAR_NOT_RELEASE) {
     return;
@@ -47,6 +47,8 @@ void taos_cleanup(void) {
 
   rpcCleanup();
   taosCloseLog();
+
+  tscInfo("all local resources released");
 }
 
 TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
@@ -140,7 +142,9 @@ TAOS_ROW taos_fetch_row(TAOS_RES *pRes) {
 
   SRequestObj *pRequest = (SRequestObj *) pRes;
   if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
-      pRequest->type == TSDB_SQL_INSERT || pRequest->code != TSDB_CODE_SUCCESS) {
+      pRequest->type == TSDB_SQL_INSERT ||
+      pRequest->code != TSDB_CODE_SUCCESS ||
+      taos_num_fields(pRes) == 0) {
     return NULL;
   }
 
diff --git a/source/client/test/clientTests.cpp b/source/client/test/clientTests.cpp
index 7a87acfc36..a3116fecea 100644
--- a/source/client/test/clientTests.cpp
+++ b/source/client/test/clientTests.cpp
@@ -279,7 +279,7 @@ TEST(testCase, connect_Test) {
 //  taos_free_result(pRes);
 //  taos_close(pConn);
 //}
-//
+
 //TEST(testCase, create_table_Test) {
 //  //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  //  assert(pConn != NULL);
@@ -470,9 +470,9 @@ TEST(testCase, create_multiple_tables) {
   TAOS_RES* pRes = taos_query(pConn, "use abc1");
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "create table t_2 using st1 tags(1) t_3 using st1 tags(2)");
+  pRes = taos_query(pConn, "create table t_2 using st1 tags(1)");
   if (taos_errno(pRes) != 0) {
-    printf("failed to show vgroups, reason:%s\n", taos_errstr(pRes));
+    printf("failed to create multiple tables, reason:%s\n", taos_errstr(pRes));
     taos_free_result(pRes);
     ASSERT_TRUE(false);
   }
diff --git a/source/common/CMakeLists.txt b/source/common/CMakeLists.txt
index 1ff83b091d..04e5a36e86 100644
--- a/source/common/CMakeLists.txt
+++ b/source/common/CMakeLists.txt
@@ -12,4 +12,6 @@ target_link_libraries(
     INTERFACE api
 )
 
-ADD_SUBDIRECTORY(test)
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index b81143ee62..0874c471aa 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -27,78 +27,7 @@
 #undef TD_MSG_SEG_CODE_
 #include "tmsgdef.h"
 
-static int  tmsgStartEncode(SMsgEncoder *pME);
-static void tmsgEndEncode(SMsgEncoder *pME);
-static int  tmsgStartDecode(SMsgDecoder *pMD);
-static void tmsgEndDecode(SMsgDecoder *pMD);
-
-/* ------------------------ ENCODE/DECODE FUNCTIONS ------------------------ */
-void tmsgInitMsgEncoder(SMsgEncoder *pME, td_endian_t endian, uint8_t *data, int64_t size) {
-  tInitEncoder(&(pME->coder), endian, data, size);
-  TD_SLIST_INIT(&(pME->eStack));
-}
-
-void tmsgClearMsgEncoder(SMsgEncoder *pME) {
-  struct SMEListNode *pNode;
-  for (;;) {
-    pNode = TD_SLIST_HEAD(&(pME->eStack));
-    if (TD_IS_NULL(pNode)) break;
-    TD_SLIST_POP(&(pME->eStack));
-    free(pNode);
-  }
-}
-
-void tmsgInitMsgDecoder(SMsgDecoder *pMD, td_endian_t endian, uint8_t *data, int64_t size) {
-  tInitDecoder(&pMD->coder, endian, data, size);
-  TD_SLIST_INIT(&(pMD->dStack));
-  TD_SLIST_INIT(&(pMD->freeList));
-}
-
-void tmsgClearMsgDecoder(SMsgDecoder *pMD) {
-  {
-    struct SMDFreeListNode *pNode;
-    for (;;) {
-      pNode = TD_SLIST_HEAD(&(pMD->freeList));
-      if (TD_IS_NULL(pNode)) break;
-      TD_SLIST_POP(&(pMD->freeList));
-      free(pNode);
-    }
-  }
-  {
-    struct SMDListNode *pNode;
-    for (;;) {
-      pNode = TD_SLIST_HEAD(&(pMD->dStack));
-      if (TD_IS_NULL(pNode)) break;
-      TD_SLIST_POP(&(pMD->dStack));
-      free(pNode);
-    }
-  }
-}
-
-/* ------------------------ MESSAGE ENCODE/DECODE ------------------------ */
-int tmsgSVCreateTbReqEncode(SMsgEncoder *pCoder, SVCreateTbReq *pReq) {
-  tmsgStartEncode(pCoder);
-  // TODO
-
-  tmsgEndEncode(pCoder);
-  return 0;
-}
-
-int tmsgSVCreateTbReqDecode(SMsgDecoder *pCoder, SVCreateTbReq *pReq) {
-  tmsgStartDecode(pCoder);
-
-  // TODO: decode
-
-  // Decode is not end
-  if (pCoder->coder.pos != pCoder->coder.size) {
-    // Continue decode
-  }
-
-  tmsgEndDecode(pCoder);
-  return 0;
-}
-
-int tSerializeSVCreateTbReq(void **buf, const SVCreateTbReq *pReq) {
+int tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
   int tlen = 0;
 
   tlen += taosEncodeFixedU64(buf, pReq->ver);
@@ -193,62 +122,29 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
   return buf;
 }
 
-/* ------------------------ STATIC METHODS ------------------------ */
-static int tmsgStartEncode(SMsgEncoder *pME) {
-  struct SMEListNode *pNode = (struct SMEListNode *)malloc(sizeof(*pNode));
-  if (TD_IS_NULL(pNode)) return -1;
+int tSVCreateTbBatchReqSerialize(void **buf, SVCreateTbBatchReq *pReq) {
+  int tlen = 0;
 
-  pNode->coder = pME->coder;
-  TD_SLIST_PUSH(&(pME->eStack), pNode);
-  TD_CODER_MOVE_POS(&(pME->coder), sizeof(int32_t));
+  tlen += taosEncodeFixedU64(buf, pReq->ver);
+  tlen += taosEncodeFixedU32(buf, taosArrayGetSize(pReq->pArray));
+  for (size_t i = 0; i < taosArrayGetSize(pReq->pArray); i++) {
+    SVCreateTbReq *pCreateTbReq = taosArrayGet(pReq->pArray, i);
+    tlen += tSerializeSVCreateTbReq(buf, pCreateTbReq);
+  }
 
-  return 0;
+  return tlen;
 }
 
-static void tmsgEndEncode(SMsgEncoder *pME) {
-  int32_t             size;
-  struct SMEListNode *pNode;
+void *tSVCreateTbBatchReqDeserialize(void *buf, SVCreateTbBatchReq *pReq) {
+  uint32_t nsize = 0;
 
-  pNode = TD_SLIST_HEAD(&(pME->eStack));
-  ASSERT(pNode);
-  TD_SLIST_POP(&(pME->eStack));
+  buf = taosDecodeFixedU64(buf, &pReq->ver);
+  buf = taosDecodeFixedU32(buf, &nsize);
+  for (size_t i = 0; i < nsize; i++) {
+    SVCreateTbReq req;
+    buf = tDeserializeSVCreateTbReq(buf, &req);
+    taosArrayPush(pReq->pArray, &req);
+  }
 
-  size = pME->coder.pos - pNode->coder.pos;
-  tEncodeI32(&(pNode->coder), size);
-
-  free(pNode);
-}
-
-static int tmsgStartDecode(SMsgDecoder *pMD) {
-  struct SMDListNode *pNode;
-  int32_t             size;
-
-  pNode = (struct SMDListNode *)malloc(sizeof(*pNode));
-  if (pNode == NULL) return -1;
-
-  tDecodeI32(&(pMD->coder), &size);
-
-  pNode->coder = pMD->coder;
-  TD_SLIST_PUSH(&(pMD->dStack), pNode);
-
-  pMD->coder.pos = 0;
-  pMD->coder.size = size - sizeof(int32_t);
-  pMD->coder.data = TD_CODER_CURRENT(&(pNode->coder));
-
-  return 0;
-}
-
-static void tmsgEndDecode(SMsgDecoder *pMD) {
-  ASSERT(pMD->coder.pos == pMD->coder.size);
-  struct SMDListNode *pNode;
-
-  pNode = TD_SLIST_HEAD(&(pMD->dStack));
-  ASSERT(pNode);
-  TD_SLIST_POP(&(pMD->dStack));
-
-  pNode->coder.pos += pMD->coder.size;
-
-  pMD->coder = pNode->coder;
-
-  free(pNode);
+  return buf;
 }
\ No newline at end of file
diff --git a/source/dnode/vnode/impl/src/vnodeWrite.c b/source/dnode/vnode/impl/src/vnodeWrite.c
index 3b1442a02c..88a73ca174 100644
--- a/source/dnode/vnode/impl/src/vnodeWrite.c
+++ b/source/dnode/vnode/impl/src/vnodeWrite.c
@@ -27,7 +27,7 @@ int vnodeProcessNoWalWMsgs(SVnode *pVnode, SRpcMsg *pMsg) {
 }
 
 int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
-  SRpcMsg *  pMsg;
+  SRpcMsg *pMsg;
 
   for (int i = 0; i < taosArrayGetSize(pMsgs); i++) {
     pMsg = *(SRpcMsg **)taosArrayGet(pMsgs, i);
@@ -50,8 +50,9 @@ int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
 }
 
 int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
-  SVCreateTbReq vCreateTbReq;
-  void *        ptr = vnodeMalloc(pVnode, pMsg->contLen);
+  SVCreateTbReq      vCreateTbReq;
+  SVCreateTbBatchReq vCreateTbBatchReq;
+  void *             ptr = vnodeMalloc(pVnode, pMsg->contLen);
   if (ptr == NULL) {
     // TODO: handle error
   }
@@ -68,7 +69,6 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
 
   switch (pMsg->msgType) {
     case TDMT_VND_CREATE_STB:
-    case TDMT_VND_CREATE_TABLE:
       tDeserializeSVCreateTbReq(POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)), &vCreateTbReq);
       if (metaCreateTable(pVnode->pMeta, &(vCreateTbReq)) < 0) {
         // TODO: handle error
@@ -76,6 +76,15 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
 
       // TODO: maybe need to clear the requst struct
       break;
+    case TDMT_VND_CREATE_TABLE:
+      tSVCreateTbBatchReqDeserialize(POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)), &vCreateTbBatchReq);
+      for (int i = 0; i < taosArrayGetSize(vCreateTbBatchReq.pArray); i++) {
+        SVCreateTbReq *pCreateTbReq = taosArrayGet(vCreateTbBatchReq.pArray, i);
+        if (metaCreateTable(pVnode->pMeta, pCreateTbReq) < 0) {
+          // TODO: handle error
+        }
+      }
+      
     case TDMT_VND_DROP_STB:
     case TDMT_VND_DROP_TABLE:
       // if (metaDropTable(pVnode->pMeta, vReq.dtReq.uid) < 0) {
diff --git a/source/libs/catalog/CMakeLists.txt b/source/libs/catalog/CMakeLists.txt
index f47e105b8a..bb9ed686a7 100644
--- a/source/libs/catalog/CMakeLists.txt
+++ b/source/libs/catalog/CMakeLists.txt
@@ -11,4 +11,6 @@ target_link_libraries(
    PRIVATE os util transport qcom
 )
 
-ADD_SUBDIRECTORY(test)
\ No newline at end of file
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
\ No newline at end of file
diff --git a/source/libs/index/inc/indexInt.h b/source/libs/index/inc/indexInt.h
index 048c9e804e..6e1256d857 100644
--- a/source/libs/index/inc/indexInt.h
+++ b/source/libs/index/inc/indexInt.h
@@ -108,8 +108,17 @@ void iterateValueDestroy(IterateValue* iv, bool destroy);
 
 extern void* indexQhandle;
 
+typedef struct TFileCacheKey {
+  uint64_t suid;
+  uint8_t  colType;
+  char*    colName;
+  int32_t  nColName;
+} ICacheKey;
+
 int indexFlushCacheTFile(SIndex* sIdx, void*);
 
+int32_t indexSerialCacheKey(ICacheKey* key, char* buf);
+
 #define indexFatal(...)                                                               \
   do {                                                                                \
     if (sDebugFlag & DEBUG_FATAL) { taosPrintLog("index FATAL ", 255, __VA_ARGS__); } \
diff --git a/source/libs/index/inc/index_cache.h b/source/libs/index/inc/index_cache.h
index 12b66bca2c..805137ccaf 100644
--- a/source/libs/index/inc/index_cache.h
+++ b/source/libs/index/inc/index_cache.h
@@ -42,6 +42,7 @@ typedef struct IndexCache {
   int32_t   version;
   int32_t   nTerm;
   int8_t    type;
+  uint64_t  suid;
 
   pthread_mutex_t mtx;
 } IndexCache;
@@ -58,7 +59,7 @@ typedef struct CacheTerm {
 } CacheTerm;
 //
 
-IndexCache* indexCacheCreate(SIndex* idx, const char* colName, int8_t type);
+IndexCache* indexCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8_t type);
 
 void indexCacheDestroy(void* cache);
 
diff --git a/source/libs/index/inc/index_fst_counting_writer.h b/source/libs/index/inc/index_fst_counting_writer.h
index 1504a69a08..fcc0d5a0b3 100644
--- a/source/libs/index/inc/index_fst_counting_writer.h
+++ b/source/libs/index/inc/index_fst_counting_writer.h
@@ -38,6 +38,7 @@ typedef struct WriterCtx {
       int  fd;
       bool readOnly;
       char buf[256];
+      int  size;
     } file;
     struct {
       int32_t capa;
diff --git a/source/libs/index/inc/index_tfile.h b/source/libs/index/inc/index_tfile.h
index 4928e01a63..4618a39197 100644
--- a/source/libs/index/inc/index_tfile.h
+++ b/source/libs/index/inc/index_tfile.h
@@ -49,13 +49,6 @@ typedef struct TFileValue {
   int32_t offset;
 } TFileValue;
 
-typedef struct TFileCacheKey {
-  uint64_t suid;
-  uint8_t  colType;
-  char*    colName;
-  int32_t  nColName;
-} TFileCacheKey;
-
 // table cache
 // refactor to LRU cache later
 typedef struct TFileCache {
@@ -103,10 +96,10 @@ typedef struct TFileReaderOpt {
 // tfile cache, manage tindex reader
 TFileCache*  tfileCacheCreate(const char* path);
 void         tfileCacheDestroy(TFileCache* tcache);
-TFileReader* tfileCacheGet(TFileCache* tcache, TFileCacheKey* key);
-void         tfileCachePut(TFileCache* tcache, TFileCacheKey* key, TFileReader* reader);
+TFileReader* tfileCacheGet(TFileCache* tcache, ICacheKey* key);
+void         tfileCachePut(TFileCache* tcache, ICacheKey* key, TFileReader* reader);
 
-TFileReader* tfileGetReaderByCol(IndexTFile* tf, char* colName);
+TFileReader* tfileGetReaderByCol(IndexTFile* tf, uint64_t suid, char* colName);
 
 TFileReader* tfileReaderOpen(char* path, uint64_t suid, int32_t version, const char* colName);
 TFileReader* tfileReaderCreate(WriterCtx* ctx);
@@ -124,6 +117,7 @@ int          tfileWriterFinish(TFileWriter* tw);
 
 //
 IndexTFile* indexTFileCreate(const char* path);
+void        indexTFileDestroy(IndexTFile* tfile);
 int         indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid);
 int         indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result);
 
diff --git a/source/libs/index/inc/index_util.h b/source/libs/index/inc/index_util.h
index 21c5ca155b..adeb52bb8c 100644
--- a/source/libs/index/inc/index_util.h
+++ b/source/libs/index/inc/index_util.h
@@ -34,7 +34,7 @@ extern "C" {
 #define SERIALIZE_VAR_TO_BUF(buf, var, type)  \
   do {                                        \
     type c = var;                             \
-    assert(sizeof(var) == sizeof(type));      \
+    assert(sizeof(type) == sizeof(c));        \
     memcpy((void*)buf, (void*)&c, sizeof(c)); \
     buf += sizeof(c);                         \
   } while (0)
diff --git a/source/libs/index/src/index.c b/source/libs/index/src/index.c
index 5167196031..0657c68458 100644
--- a/source/libs/index/src/index.c
+++ b/source/libs/index/src/index.c
@@ -17,6 +17,7 @@
 #include "indexInt.h"
 #include "index_cache.h"
 #include "index_tfile.h"
+#include "index_util.h"
 #include "tdef.h"
 #include "tsched.h"
 
@@ -72,6 +73,7 @@ int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
 #ifdef USE_INVERTED_INDEX
   // sIdx->cache = (void*)indexCacheCreate(sIdx);
   sIdx->tindex = indexTFileCreate(path);
+  if (sIdx->tindex == NULL) { goto END; }
   sIdx->colObj = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   sIdx->cVersion = 1;
   sIdx->path = calloc(1, strlen(path) + 1);
@@ -82,6 +84,8 @@ int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
 
   return 0;
 #endif
+END:
+  if (sIdx != NULL) { indexClose(sIdx); }
 
   *index = NULL;
   return -1;
@@ -102,6 +106,7 @@ void indexClose(SIndex* sIdx) {
   }
   taosHashCleanup(sIdx->colObj);
   pthread_mutex_destroy(&sIdx->mtx);
+  indexTFileDestroy(sIdx->tindex);
 #endif
   free(sIdx->path);
   free(sIdx);
@@ -130,18 +135,28 @@ int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
   // TODO(yihao): reduce the lock range
   pthread_mutex_lock(&index->mtx);
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
-    SIndexTerm*  p = taosArrayGetP(fVals, i);
-    IndexCache** cache = taosHashGet(index->colObj, p->colName, p->nColName);
+    SIndexTerm* p = taosArrayGetP(fVals, i);
+
+    char      buf[128] = {0};
+    ICacheKey key = {.suid = p->suid, .colName = p->colName, .nColName = strlen(p->colName)};
+    int32_t   sz = indexSerialCacheKey(&key, buf);
+
+    IndexCache** cache = taosHashGet(index->colObj, buf, sz);
     if (cache == NULL) {
-      IndexCache* pCache = indexCacheCreate(index, p->colName, p->colType);
-      taosHashPut(index->colObj, p->colName, p->nColName, &pCache, sizeof(void*));
+      IndexCache* pCache = indexCacheCreate(index, p->suid, p->colName, p->colType);
+      taosHashPut(index->colObj, buf, sz, &pCache, sizeof(void*));
     }
   }
   pthread_mutex_unlock(&index->mtx);
 
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
-    SIndexTerm*  p = taosArrayGetP(fVals, i);
-    IndexCache** cache = taosHashGet(index->colObj, p->colName, p->nColName);
+    SIndexTerm* p = taosArrayGetP(fVals, i);
+
+    char      buf[128] = {0};
+    ICacheKey key = {.suid = p->suid, .colName = p->colName, .nColName = strlen(p->colName)};
+    int32_t   sz = indexSerialCacheKey(&key, buf);
+
+    IndexCache** cache = taosHashGet(index->colObj, buf, sz);
     assert(*cache != NULL);
     int ret = indexCachePut(*cache, p, uid);
     if (ret != 0) { return ret; }
@@ -200,7 +215,7 @@ int indexSearch(SIndex* index, SIndexMultiTermQuery* multiQuerys, SArray* result
   indexInterResultsDestroy(interResults);
 
 #endif
-  return 1;
+  return 0;
 }
 
 int indexDelete(SIndex* index, SIndexMultiTermQuery* query) {
@@ -296,7 +311,12 @@ static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result
   // Get col info
   IndexCache* cache = NULL;
   pthread_mutex_lock(&sIdx->mtx);
-  IndexCache** pCache = taosHashGet(sIdx->colObj, colName, nColName);
+
+  char      buf[128] = {0};
+  ICacheKey key = {.suid = term->suid, .colName = term->colName, .nColName = strlen(term->colName)};
+  int32_t   sz = indexSerialCacheKey(&key, buf);
+
+  IndexCache** pCache = taosHashGet(sIdx->colObj, buf, sz);
   if (pCache == NULL) {
     pthread_mutex_unlock(&sIdx->mtx);
     return -1;
@@ -360,6 +380,7 @@ static void indexMergeSameKey(SArray* result, TFileValue* tv) {
   if (sz > 0) {
     // TODO(yihao): remove duplicate tableid
     TFileValue* lv = taosArrayGetP(result, sz - 1);
+    // indexError("merge colVal: %s", lv->colVal);
     if (strcmp(lv->colVal, tv->colVal) == 0) {
       taosArrayAddAll(lv->tableId, tv->tableId);
       tfileValueDestroy(tv);
@@ -368,6 +389,7 @@ static void indexMergeSameKey(SArray* result, TFileValue* tv) {
     }
   } else {
     taosArrayPush(result, &tv);
+    // indexError("merge colVal: %s", tv->colVal);
   }
 }
 static void indexDestroyTempResult(SArray* result) {
@@ -383,10 +405,12 @@ int indexFlushCacheTFile(SIndex* sIdx, void* cache) {
   indexWarn("suid %" PRIu64 " merge cache into tindex", sIdx->suid);
 
   IndexCache*  pCache = (IndexCache*)cache;
-  TFileReader* pReader = tfileGetReaderByCol(sIdx->tindex, pCache->colName);
+  TFileReader* pReader = tfileGetReaderByCol(sIdx->tindex, pCache->suid, pCache->colName);
+  if (pReader == NULL) { indexWarn("empty pReader found"); }
   // handle flush
   Iterate* cacheIter = indexCacheIteratorCreate(pCache);
   Iterate* tfileIter = tfileIteratorCreate(pReader);
+  if (tfileIter == NULL) { indexWarn("empty tfile reader iterator"); }
 
   SArray* result = taosArrayInit(1024, sizeof(void*));
 
@@ -459,14 +483,14 @@ void iterateValueDestroy(IterateValue* value, bool destroy) {
   } else {
     if (value->val != NULL) { taosArrayClear(value->val); }
   }
-  // free(value->colVal);
+  free(value->colVal);
   value->colVal = NULL;
 }
 static int indexGenTFile(SIndex* sIdx, IndexCache* cache, SArray* batch) {
   int32_t version = CACHE_VERSION(cache);
   uint8_t colType = cache->type;
 
-  TFileWriter* tw = tfileWriterOpen(sIdx->path, sIdx->suid, version, cache->colName, colType);
+  TFileWriter* tw = tfileWriterOpen(sIdx->path, cache->suid, version, cache->colName, colType);
   if (tw == NULL) {
     indexError("failed to open file to write");
     return -1;
@@ -479,14 +503,13 @@ static int indexGenTFile(SIndex* sIdx, IndexCache* cache, SArray* batch) {
   }
   tfileWriterClose(tw);
 
-  TFileReader* reader = tfileReaderOpen(sIdx->path, sIdx->suid, version, cache->colName);
+  TFileReader* reader = tfileReaderOpen(sIdx->path, cache->suid, version, cache->colName);
+
+  char         buf[128] = {0};
+  TFileHeader* header = &reader->header;
+  ICacheKey    key = {
+      .suid = cache->suid, .colName = header->colName, .nColName = strlen(header->colName), .colType = header->colType};
 
-  char          buf[128] = {0};
-  TFileHeader*  header = &reader->header;
-  TFileCacheKey key = {.suid = header->suid,
-                       .colName = header->colName,
-                       .nColName = strlen(header->colName),
-                       .colType = header->colType};
   pthread_mutex_lock(&sIdx->mtx);
 
   IndexTFile* ifile = (IndexTFile*)sIdx->tindex;
@@ -497,3 +520,13 @@ static int indexGenTFile(SIndex* sIdx, IndexCache* cache, SArray* batch) {
 END:
   tfileWriterClose(tw);
 }
+
+int32_t indexSerialCacheKey(ICacheKey* key, char* buf) {
+  char* p = buf;
+  SERIALIZE_MEM_TO_BUF(buf, key, suid);
+  SERIALIZE_VAR_TO_BUF(buf, '_', char);
+  // SERIALIZE_MEM_TO_BUF(buf, key, colType);
+  // SERIALIZE_VAR_TO_BUF(buf, '_', char);
+  SERIALIZE_STR_MEM_TO_BUF(buf, key, colName, key->nColName);
+  return buf - p;
+}
diff --git a/source/libs/index/src/index_cache.c b/source/libs/index/src/index_cache.c
index 0e46445a00..e95de9286e 100644
--- a/source/libs/index/src/index_cache.c
+++ b/source/libs/index/src/index_cache.c
@@ -20,7 +20,7 @@
 
 #define MAX_INDEX_KEY_LEN 256  // test only, change later
 
-#define MEM_TERM_LIMIT 10000 * 10
+#define MEM_TERM_LIMIT 5 * 10000
 // ref index_cache.h:22
 //#define CACHE_KEY_LEN(p) \
 //  (sizeof(int32_t) + sizeof(uint16_t) + sizeof(p->colType) + sizeof(p->nColVal) + p->nColVal + sizeof(uint64_t) +
@@ -40,7 +40,7 @@ static bool indexCacheIteratorNext(Iterate* itera);
 
 static IterateValue* indexCacheIteratorGetValue(Iterate* iter);
 
-IndexCache* indexCacheCreate(SIndex* idx, const char* colName, int8_t type) {
+IndexCache* indexCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8_t type) {
   IndexCache* cache = calloc(1, sizeof(IndexCache));
   if (cache == NULL) {
     indexError("failed to create index cache");
@@ -53,7 +53,7 @@ IndexCache* indexCacheCreate(SIndex* idx, const char* colName, int8_t type) {
   cache->type = type;
   cache->index = idx;
   cache->version = 0;
-
+  cache->suid = suid;
   pthread_mutex_init(&cache->mtx, NULL);
   indexCacheRef(cache);
   return cache;
@@ -150,6 +150,7 @@ Iterate* indexCacheIteratorCreate(IndexCache* cache) {
 
   MemTable* tbl = cache->imm;
   iiter->val.val = taosArrayInit(1, sizeof(uint64_t));
+  iiter->val.colVal = NULL;
   iiter->iter = tbl != NULL ? tSkipListCreateIter(tbl->mem) : NULL;
   iiter->next = indexCacheIteratorNext;
   iiter->getValue = indexCacheIteratorGetValue;
@@ -353,6 +354,9 @@ static bool indexCacheIteratorNext(Iterate* itera) {
   SSkipListIterator* iter = itera->iter;
   if (iter == NULL) { return false; }
   IterateValue* iv = &itera->val;
+  if (iv->colVal != NULL && iv->val != NULL) {
+    // indexError("value in cache: colVal: %s, size: %d", iv->colVal, (int)taosArrayGetSize(iv->val));
+  }
   iterateValueDestroy(iv, false);
 
   bool next = tSkipListIterNext(iter);
diff --git a/source/libs/index/src/index_fst.c b/source/libs/index/src/index_fst.c
index 04a08dafd2..bfaeeaaa33 100644
--- a/source/libs/index/src/index_fst.c
+++ b/source/libs/index/src/index_fst.c
@@ -319,7 +319,7 @@ void fstStateSetCommInput(FstState* s, uint8_t inp) {
   assert(s->state == OneTransNext || s->state == OneTrans);
 
   uint8_t val;
-  COMMON_INDEX(inp, 0x111111, val);
+  COMMON_INDEX(inp, 0b111111, val);
   s->val = (s->val & fstStateDict[s->state].val) | val;
 }
 
@@ -369,7 +369,7 @@ uint8_t fstStateInput(FstState* s, FstNode* node) {
   bool      null = false;
   uint8_t   inp = fstStateCommInput(s, &null);
   uint8_t*  data = fstSliceData(slice, NULL);
-  return null == false ? inp : data[-1];
+  return null == false ? inp : data[node->start - 1];
 }
 uint8_t fstStateInputForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
   assert(s->state == AnyTrans);
@@ -1062,6 +1062,7 @@ Output fstEmptyFinalOutput(Fst* fst, bool* null) {
   } else {
     *null = true;
   }
+  fstNodeDestroy(node);
   return res;
 }
 
@@ -1286,6 +1287,7 @@ StreamWithStateResult* streamWithStateNextWith(StreamWithState* sws, StreamCallb
       StreamWithStateResult* result = swsResultCreate(&slice, fOutput, tState);
       free(buf);
       fstSliceDestroy(&slice);
+      taosArrayDestroy(nodes);
       return result;
     }
     free(buf);
diff --git a/source/libs/index/src/index_fst_counting_writer.c b/source/libs/index/src/index_fst_counting_writer.c
index 7906dfea11..0f29da1c27 100644
--- a/source/libs/index/src/index_fst_counting_writer.c
+++ b/source/libs/index/src/index_fst_counting_writer.c
@@ -72,9 +72,17 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int
     if (readOnly == false) {
       // ctx->file.fd = open(path, O_WRONLY | O_CREAT | O_APPEND, S_IRWXU | S_IRWXG | S_IRWXO);
       ctx->file.fd = tfOpenCreateWriteAppend(path);
+
+      struct stat fstat;
+      stat(path, &fstat);
+      ctx->file.size = fstat.st_size;
     } else {
       // ctx->file.fd = open(path, O_RDONLY, S_IRWXU | S_IRWXG | S_IRWXO);
       ctx->file.fd = tfOpenRead(path);
+
+      struct stat fstat;
+      stat(path, &fstat);
+      ctx->file.size = fstat.st_size;
     }
     memcpy(ctx->file.buf, path, strlen(path));
     if (ctx->file.fd < 0) {
@@ -104,6 +112,7 @@ void writerCtxDestroy(WriterCtx* ctx, bool remove) {
     free(ctx->mem.buf);
   } else {
     tfClose(ctx->file.fd);
+    ctx->flush(ctx);
     if (remove) { unlink(ctx->file.buf); }
   }
   free(ctx);
diff --git a/source/libs/index/src/index_tfile.c b/source/libs/index/src/index_tfile.c
index fc4f8593a1..d4d13ddf19 100644
--- a/source/libs/index/src/index_tfile.c
+++ b/source/libs/index/src/index_tfile.c
@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
+p *
  * 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.
@@ -45,13 +45,13 @@ static int tfileReaderLoadHeader(TFileReader* reader);
 static int tfileReaderLoadFst(TFileReader* reader);
 static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray* result);
 
-static int  tfileGetFileList(const char* path, SArray* result);
-static int  tfileRmExpireFile(SArray* result);
-static void tfileDestroyFileName(void* elem);
-static int  tfileCompare(const void* a, const void* b);
-static int  tfileParseFileName(const char* filename, uint64_t* suid, int* colId, int* version);
-static void tfileGenFileName(char* filename, uint64_t suid, int colId, int version);
-static void tfileSerialCacheKey(TFileCacheKey* key, char* buf);
+static SArray* tfileGetFileList(const char* path);
+static int     tfileRmExpireFile(SArray* result);
+static void    tfileDestroyFileName(void* elem);
+static int     tfileCompare(const void* a, const void* b);
+static int     tfileParseFileName(const char* filename, uint64_t* suid, char* col, int* version);
+static void    tfileGenFileName(char* filename, uint64_t suid, const char* col, int version);
+static void    tfileGenFileFullName(char* fullname, const char* path, uint64_t suid, const char* col, int32_t version);
 
 TFileCache* tfileCacheCreate(const char* path) {
   TFileCache* tcache = calloc(1, sizeof(TFileCache));
@@ -60,38 +60,41 @@ TFileCache* tfileCacheCreate(const char* path) {
   tcache->tableCache = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   tcache->capacity = 64;
 
-  SArray* files = taosArrayInit(4, sizeof(void*));
-  tfileGetFileList(path, files);
-  taosArraySort(files, tfileCompare);
-  tfileRmExpireFile(files);
+  SArray* files = tfileGetFileList(path);
 
   uint64_t suid;
   int32_t  colId, version;
   for (size_t i = 0; i < taosArrayGetSize(files); i++) {
     char* file = taosArrayGetP(files, i);
-    if (0 != tfileParseFileName(file, &suid, (int*)&colId, (int*)&version)) {
+
+    // refactor later, use colname and version info
+    char colName[256] = {0};
+    if (0 != tfileParseFileName(file, &suid, colName, (int*)&version)) {
       indexInfo("try parse invalid file:  %s, skip it", file);
       continue;
     }
 
-    WriterCtx* wc = writerCtxCreate(TFile, file, true, 1024 * 1024 * 64);
+    char fullName[256] = {0};
+    sprintf(fullName, "%s/%s", path, file);
+
+    WriterCtx* wc = writerCtxCreate(TFile, fullName, true, 1024 * 1024 * 64);
     if (wc == NULL) {
       indexError("failed to open index:%s", file);
       goto End;
     }
 
-    char          buf[128] = {0};
-    TFileReader*  reader = tfileReaderCreate(wc);
-    TFileHeader*  header = &reader->header;
-    TFileCacheKey key = {.suid = header->suid,
-                         .colName = header->colName,
-                         .nColName = strlen(header->colName),
-                         .colType = header->colType};
-    tfileSerialCacheKey(&key, buf);
+    char         buf[128] = {0};
+    TFileReader* reader = tfileReaderCreate(wc);
+    TFileHeader* header = &reader->header;
+    ICacheKey    key = {.suid = header->suid,
+                     .colName = header->colName,
+                     .nColName = strlen(header->colName),
+                     .colType = header->colType};
 
+    int32_t sz = indexSerialCacheKey(&key, buf);
+    assert(sz < sizeof(buf));
+    taosHashPut(tcache->tableCache, buf, sz, &reader, sizeof(void*));
     tfileReaderRef(reader);
-    // indexTable
-    taosHashPut(tcache->tableCache, buf, strlen(buf), &reader, sizeof(void*));
   }
   taosArrayDestroyEx(files, tfileDestroyFileName);
   return tcache;
@@ -117,30 +120,30 @@ void tfileCacheDestroy(TFileCache* tcache) {
   free(tcache);
 }
 
-TFileReader* tfileCacheGet(TFileCache* tcache, TFileCacheKey* key) {
-  char buf[128] = {0};
-  tfileSerialCacheKey(key, buf);
-
-  TFileReader** reader = taosHashGet(tcache->tableCache, buf, strlen(buf));
+TFileReader* tfileCacheGet(TFileCache* tcache, ICacheKey* key) {
+  char    buf[128] = {0};
+  int32_t sz = indexSerialCacheKey(key, buf);
+  assert(sz < sizeof(buf));
+  TFileReader** reader = taosHashGet(tcache->tableCache, buf, sz);
   if (reader == NULL) { return NULL; }
   tfileReaderRef(*reader);
 
   return *reader;
 }
-void tfileCachePut(TFileCache* tcache, TFileCacheKey* key, TFileReader* reader) {
-  char buf[128] = {0};
-  tfileSerialCacheKey(key, buf);
+void tfileCachePut(TFileCache* tcache, ICacheKey* key, TFileReader* reader) {
+  char    buf[128] = {0};
+  int32_t sz = indexSerialCacheKey(key, buf);
   // remove last version index reader
-  TFileReader** p = taosHashGet(tcache->tableCache, buf, strlen(buf));
+  TFileReader** p = taosHashGet(tcache->tableCache, buf, sz);
   if (p != NULL) {
     TFileReader* oldReader = *p;
-    taosHashRemove(tcache->tableCache, buf, strlen(buf));
+    taosHashRemove(tcache->tableCache, buf, sz);
     oldReader->remove = true;
     tfileReaderUnRef(oldReader);
   }
 
+  taosHashPut(tcache->tableCache, buf, sz, &reader, sizeof(void*));
   tfileReaderRef(reader);
-  taosHashPut(tcache->tableCache, buf, strlen(buf), &reader, sizeof(void*));
   return;
 }
 TFileReader* tfileReaderCreate(WriterCtx* ctx) {
@@ -201,12 +204,9 @@ int tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArray* resul
 }
 
 TFileWriter* tfileWriterOpen(char* path, uint64_t suid, int32_t version, const char* colName, uint8_t colType) {
-  char    filename[128] = {0};
-  int32_t coldId = 1;
-  tfileGenFileName(filename, suid, coldId, version);
-
   char fullname[256] = {0};
-  snprintf(fullname, sizeof(fullname), "%s/%s", path, filename);
+  tfileGenFileFullName(fullname, path, suid, colName, version);
+  // indexInfo("open write file name %s", fullname);
   WriterCtx* wcx = writerCtxCreate(TFile, fullname, false, 1024 * 1024 * 64);
   if (wcx == NULL) { return NULL; }
 
@@ -219,19 +219,15 @@ TFileWriter* tfileWriterOpen(char* path, uint64_t suid, int32_t version, const c
   return tfileWriterCreate(wcx, &tfh);
 }
 TFileReader* tfileReaderOpen(char* path, uint64_t suid, int32_t version, const char* colName) {
-  char    filename[128] = {0};
-  int32_t coldId = 1;
-  tfileGenFileName(filename, suid, coldId, version);
-
   char fullname[256] = {0};
-  snprintf(fullname, sizeof(fullname), "%s/%s", path, filename);
+  tfileGenFileFullName(fullname, path, suid, colName, version);
+
   WriterCtx* wc = writerCtxCreate(TFile, fullname, true, 1024 * 1024 * 1024);
+  // indexInfo("open read file name:%s, size: %d", wc->file.buf, wc->file.size);
   if (wc == NULL) { return NULL; }
 
   TFileReader* reader = tfileReaderCreate(wc);
   return reader;
-
-  // tfileSerialCacheKey(&key, buf);
 }
 TFileWriter* tfileWriterCreate(WriterCtx* ctx, TFileHeader* header) {
   // char pathBuf[128] = {0};
@@ -325,17 +321,19 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) {
     tfileWriterClose(tw);
     return -1;
   }
-  // write fst
-  indexError("--------Begin----------------");
+
+  // write data
   for (size_t i = 0; i < sz; i++) {
     // TODO, fst batch write later
     TFileValue* v = taosArrayGetP((SArray*)data, i);
-    if (tfileWriteData(tw, v) == 0) {
-      //
+    if (tfileWriteData(tw, v) != 0) {
+      indexError("failed to write data: %s, offset: %d len: %d", v->colVal, v->offset,
+                 (int)taosArrayGetSize(v->tableId));
+    } else {
+      // indexInfo("success to write data: %s, offset: %d len: %d", v->colVal, v->offset,
+      //          (int)taosArrayGetSize(v->tableId));
     }
-    indexError("data: %s, offset: %d len: %d", v->colVal, v->offset, (int)taosArrayGetSize(v->tableId));
   }
-  indexError("--------End----------------");
   fstBuilderFinish(tw->fb);
   fstBuilderDestroy(tw->fb);
   tw->fb = NULL;
@@ -359,7 +357,8 @@ IndexTFile* indexTFileCreate(const char* path) {
   tfile->cache = tfileCacheCreate(path);
   return tfile;
 }
-void IndexTFileDestroy(IndexTFile* tfile) {
+void indexTFileDestroy(IndexTFile* tfile) {
+  if (tfile == NULL) { return; }
   tfileCacheDestroy(tfile->cache);
   free(tfile);
 }
@@ -369,9 +368,8 @@ int indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result) {
   if (tfile == NULL) { return ret; }
   IndexTFile* pTfile = (IndexTFile*)tfile;
 
-  SIndexTerm*   term = query->term;
-  TFileCacheKey key = {
-      .suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName};
+  SIndexTerm* term = query->term;
+  ICacheKey key = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName};
   TFileReader* reader = tfileCacheGet(pTfile->cache, &key);
   if (reader == NULL) { return 0; }
 
@@ -385,8 +383,10 @@ int indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) {
 }
 static bool tfileIteratorNext(Iterate* iiter) {
   IterateValue* iv = &iiter->val;
+  if (iv->colVal != NULL && iv->val != NULL) {
+    // indexError("value in fst: colVal: %s, size: %d", iv->colVal, (int)taosArrayGetSize(iv->val));
+  }
   iterateValueDestroy(iv, false);
-  // SArray* tblIds = iv->val;
 
   char*    colVal = NULL;
   uint64_t offset = 0;
@@ -406,14 +406,14 @@ static bool tfileIteratorNext(Iterate* iiter) {
   if (tfileReaderLoadTableIds(tIter->rdr, offset, iv->val) != 0) { return false; }
 
   iv->colVal = colVal;
-
+  return true;
   // std::string key(ch, sz);
 }
 
 static IterateValue* tifileIterateGetValue(Iterate* iter) { return &iter->val; }
 
 static TFileFstIter* tfileFstIteratorCreate(TFileReader* reader) {
-  TFileFstIter* tIter = calloc(1, sizeof(Iterate));
+  TFileFstIter* tIter = calloc(1, sizeof(TFileFstIter));
   if (tIter == NULL) { return NULL; }
 
   tIter->ctx = automCtxCreate(NULL, AUTOMATION_ALWAYS);
@@ -435,6 +435,7 @@ Iterate* tfileIteratorCreate(TFileReader* reader) {
   iter->next = tfileIteratorNext;
   iter->getValue = tifileIterateGetValue;
   iter->val.val = taosArrayInit(1, sizeof(uint64_t));
+  iter->val.colVal = NULL;
   return iter;
 }
 void tfileIteratorDestroy(Iterate* iter) {
@@ -447,13 +448,14 @@ void tfileIteratorDestroy(Iterate* iter) {
   streamWithStateDestroy(tIter->st);
   fstStreamBuilderDestroy(tIter->fb);
   automCtxDestroy(tIter->ctx);
+  free(tIter);
 
   free(iter);
 }
 
-TFileReader* tfileGetReaderByCol(IndexTFile* tf, char* colName) {
+TFileReader* tfileGetReaderByCol(IndexTFile* tf, uint64_t suid, char* colName) {
   if (tf == NULL) { return NULL; }
-  TFileCacheKey key = {.suid = 0, .colType = TSDB_DATA_TYPE_BINARY, .colName = colName, .nColName = strlen(colName)};
+  ICacheKey key = {.suid = suid, .colType = TSDB_DATA_TYPE_BINARY, .colName = colName, .nColName = strlen(colName)};
   return tfileCacheGet(tf->cache, &key);
 }
 
@@ -480,7 +482,7 @@ static int tfileValueCompare(const void* a, const void* b, const void* param) {
 TFileValue* tfileValueCreate(char* val) {
   TFileValue* tf = calloc(1, sizeof(TFileValue));
   if (tf == NULL) { return NULL; }
-  tf->colVal = val;
+  tf->colVal = tstrdup(val);
   tf->tableId = taosArrayInit(32, sizeof(uint64_t));
   return tf;
 }
@@ -491,6 +493,7 @@ int tfileValuePush(TFileValue* tf, uint64_t val) {
 }
 void tfileValueDestroy(TFileValue* tf) {
   taosArrayDestroy(tf->tableId);
+  free(tf->colVal);
   free(tf);
 }
 static void tfileSerialTableIdsToBuf(char* buf, SArray* ids) {
@@ -545,6 +548,9 @@ static int tfileReaderLoadHeader(TFileReader* reader) {
     //
     indexError("actual Read: %d, to read: %d, errno: %d, filefd: %d, filename: %s", (int)(nread), (int)sizeof(buf),
                errno, reader->ctx->file.fd, reader->ctx->file.buf);
+  } else {
+    indexError("actual Read: %d, to read: %d, errno: %d, filefd: %d, filename: %s", (int)(nread), (int)sizeof(buf),
+               errno, reader->ctx->file.fd, reader->ctx->file.buf);
   }
   // assert(nread == sizeof(buf));
   memcpy(&reader->header, buf, sizeof(buf));
@@ -553,13 +559,14 @@ static int tfileReaderLoadHeader(TFileReader* reader) {
 }
 static int tfileReaderLoadFst(TFileReader* reader) {
   // current load fst into memory, refactor it later
-  static int FST_MAX_SIZE = 64 * 1024;
+  static int FST_MAX_SIZE = 64 * 1024 * 1024;
 
   char* buf = calloc(1, sizeof(char) * FST_MAX_SIZE);
   if (buf == NULL) { return -1; }
 
   WriterCtx* ctx = reader->ctx;
   int32_t    nread = ctx->readFrom(ctx, buf, FST_MAX_SIZE, reader->header.fstOffset);
+  indexError("nread = %d, and fst offset=%d, filename: %s ", nread, reader->header.fstOffset, ctx->file.buf);
   // we assuse fst size less than FST_MAX_SIZE
   assert(nread > 0 && nread < FST_MAX_SIZE);
 
@@ -603,19 +610,26 @@ void tfileReaderUnRef(TFileReader* reader) {
   }
 }
 
-static int tfileGetFileList(const char* path, SArray* result) {
+static SArray* tfileGetFileList(const char* path) {
+  SArray* files = taosArrayInit(4, sizeof(void*));
+
   DIR* dir = opendir(path);
-  if (NULL == dir) { return -1; }
+  if (NULL == dir) { return NULL; }
 
   struct dirent* entry;
   while ((entry = readdir(dir)) != NULL) {
+    if (entry->d_type && DT_DIR) { continue; }
     size_t len = strlen(entry->d_name);
     char*  buf = calloc(1, len + 1);
     memcpy(buf, entry->d_name, len);
-    taosArrayPush(result, &buf);
+    taosArrayPush(files, &buf);
   }
   closedir(dir);
-  return 0;
+
+  taosArraySort(files, tfileCompare);
+  tfileRmExpireFile(files);
+
+  return files;
 }
 static int tfileRmExpireFile(SArray* result) {
   // TODO(yihao): remove expire tindex after restart
@@ -636,22 +650,21 @@ static int tfileCompare(const void* a, const void* b) {
   if (ret == 0) { return ret; }
   return ret < 0 ? -1 : 1;
 }
-// tfile name suid-colId-version.tindex
-static void tfileGenFileName(char* filename, uint64_t suid, int colId, int version) {
-  sprintf(filename, "%" PRIu64 "-%d-%d.tindex", suid, colId, version);
-  return;
-}
-static int tfileParseFileName(const char* filename, uint64_t* suid, int* colId, int* version) {
-  if (3 == sscanf(filename, "%" PRIu64 "-%d-%d.tindex", suid, colId, version)) {
+
+static int tfileParseFileName(const char* filename, uint64_t* suid, char* col, int* version) {
+  if (3 == sscanf(filename, "%" PRIu64 "-%[^-]-%d.tindex", suid, col, version)) {
     // read suid & colid & version  success
     return 0;
   }
   return -1;
 }
-static void tfileSerialCacheKey(TFileCacheKey* key, char* buf) {
-  // SERIALIZE_MEM_TO_BUF(buf, key, suid);
-  // SERIALIZE_VAR_TO_BUF(buf, '_', char);
-  // SERIALIZE_MEM_TO_BUF(buf, key, colType);
-  // SERIALIZE_VAR_TO_BUF(buf, '_', char);
-  SERIALIZE_STR_MEM_TO_BUF(buf, key, colName, key->nColName);
+// tfile name suid-colId-version.tindex
+static void tfileGenFileName(char* filename, uint64_t suid, const char* col, int version) {
+  sprintf(filename, "%" PRIu64 "-%s-%d.tindex", suid, col, version);
+  return;
+}
+static void tfileGenFileFullName(char* fullname, const char* path, uint64_t suid, const char* col, int32_t version) {
+  char filename[128] = {0};
+  tfileGenFileName(filename, suid, col, version);
+  sprintf(fullname, "%s/%s", path, filename);
 }
diff --git a/source/libs/index/test/fstTest.cc b/source/libs/index/test/fstTest.cc
index da974ce6c4..3d978c05a5 100644
--- a/source/libs/index/test/fstTest.cc
+++ b/source/libs/index/test/fstTest.cc
@@ -24,8 +24,13 @@ class FstWriter {
     _b = fstBuilderCreate(_wc, 0);
   }
   bool Put(const std::string& key, uint64_t val) {
+    // char buf[128] = {0};
+    // int  len = 0;
+    // taosMbsToUcs4(key.c_str(), key.size(), buf, 128, &len);
+    // FstSlice skey = fstSliceCreate((uint8_t*)buf, len);
     FstSlice skey = fstSliceCreate((uint8_t*)key.c_str(), key.size());
     bool     ok = fstBuilderInsert(_b, skey, val);
+
     fstSliceDestroy(&skey);
     return ok;
   }
@@ -61,6 +66,11 @@ class FstReadMemory {
     return _fst != NULL;
   }
   bool Get(const std::string& key, uint64_t* val) {
+    // char buf[128] = {0};
+    // int  len = 0;
+    // taosMbsToUcs4(key.c_str(), key.size(), buf, 128, &len);
+    // FstSlice skey = fstSliceCreate((uint8_t*)buf, len);
+
     FstSlice skey = fstSliceCreate((uint8_t*)key.c_str(), key.size());
     bool     ok = fstGet(_fst, &skey, val);
     fstSliceDestroy(&skey);
@@ -135,15 +145,109 @@ int Performance_fstWriteRecords(FstWriter* b) {
   }
   return L * M * N;
 }
+void Performance_fstReadRecords(FstReadMemory* m) {
+  std::string str("aa");
+  for (int i = 0; i < M; i++) {
+    str[0] = 'a' + i;
+    str.resize(2);
+    for (int j = 0; j < N; j++) {
+      str[1] = 'a' + j;
+      str.resize(2);
+      for (int k = 0; k < L; k++) {
+        str.push_back('a');
+        uint64_t val, cost;
+        if (m->GetWithTimeCostUs(str, &val, &cost)) {
+          printf("succes to get kv(%s, %" PRId64 "), cost: %" PRId64 "\n", str.c_str(), val, cost);
+        } else {
+          printf("failed to get key: %s\n", str.c_str());
+        }
+      }
+    }
+  }
+}
+
+void checkMillonWriteAndReadOfFst() {
+  tfInit();
+  FstWriter* fw = new FstWriter;
+  Performance_fstWriteRecords(fw);
+  delete fw;
+  FstReadMemory* fr = new FstReadMemory(1024 * 64 * 1024);
+
+  if (fr->init()) { printf("success to init fst read"); }
+
+  Performance_fstReadRecords(fr);
+  tfCleanup();
+  delete fr;
+}
+void checkFstLongTerm() {
+  tfInit();
+  FstWriter* fw = new FstWriter;
+  // Performance_fstWriteRecords(fw);
+
+  fw->Put("A B", 1);
+  fw->Put("C", 2);
+  fw->Put("a", 3);
+  delete fw;
+
+  FstReadMemory* m = new FstReadMemory(1024 * 64);
+  if (m->init() == false) {
+    std::cout << "init readMemory failed" << std::endl;
+    delete m;
+    return;
+  }
+  {
+    uint64_t val = 0;
+    if (m->Get("A B", &val)) {
+      std::cout << "success to Get: " << val << std::endl;
+    } else {
+      std::cout << "failed to Get:" << val << std::endl;
+    }
+  }
+  {
+    uint64_t val = 0;
+    if (m->Get("C", &val)) {
+      std::cout << "success to Get: " << val << std::endl;
+    } else {
+      std::cout << "failed to Get:" << val << std::endl;
+    }
+  }
+  {
+    uint64_t val = 0;
+    if (m->Get("a", &val)) {
+      std::cout << "success to Get: " << val << std::endl;
+    } else {
+      std::cout << "failed to Get:" << val << std::endl;
+    }
+  }
+
+  // prefix search
+  // std::vector<uint64_t> result;
+
+  // AutomationCtx* ctx = automCtxCreate((void*)"ab", AUTOMATION_ALWAYS);
+  // m->Search(ctx, result);
+  // std::cout << "size: " << result.size() << std::endl;
+  // assert(result.size() == count);
+  // for (int i = 0; i < result.size(); i++) {
+  // assert(result[i] == i);  // check result
+  //}
+  tfCleanup();
+  // free(ctx);
+  // delete m;
+}
 void checkFstCheckIterator() {
   tfInit();
   FstWriter* fw = new FstWriter;
   int64_t    s = taosGetTimestampUs();
   int        count = 2;
-  Performance_fstWriteRecords(fw);
+  // Performance_fstWriteRecords(fw);
   int64_t e = taosGetTimestampUs();
 
   std::cout << "insert data count :  " << count << "elapas time: " << e - s << std::endl;
+
+  fw->Put("Hello world", 1);
+  fw->Put("hello world", 2);
+  fw->Put("hello worle", 3);
+  fw->Put("hello worlf", 4);
   delete fw;
 
   FstReadMemory* m = new FstReadMemory(1024 * 64);
@@ -171,7 +275,7 @@ void checkFstCheckIterator() {
 
 void fst_get(Fst* fst) {
   for (int i = 0; i < 10000; i++) {
-    std::string term = "Hello";
+    std::string term = "Hello World";
     FstSlice    key = fstSliceCreate((uint8_t*)term.c_str(), term.size());
     uint64_t    offset = 0;
     bool        ret = fstGet(fst, &key, &offset);
@@ -189,7 +293,7 @@ void validateTFile(char* arg) {
 
   std::thread threads[NUM_OF_THREAD];
   // std::vector<std::thread> threads;
-  TFileReader* reader = tfileReaderOpen(arg, 0, 295868, "tag1");
+  TFileReader* reader = tfileReaderOpen(arg, 0, 999992, "tag1");
 
   for (int i = 0; i < NUM_OF_THREAD; i++) {
     threads[i] = std::thread(fst_get, reader->fst);
@@ -203,9 +307,12 @@ void validateTFile(char* arg) {
   tfCleanup();
 }
 int main(int argc, char* argv[]) {
-  if (argc > 1) { validateTFile(argv[1]); }
+  // tool to check all kind of fst test 
+  // if (argc > 1) { validateTFile(argv[1]); }
   // checkFstCheckIterator();
+  // checkFstLongTerm();
   // checkFstPrefixSearch();
 
+  checkMillonWriteAndReadOfFst();
   return 1;
 }
diff --git a/source/libs/index/test/indexTests.cc b/source/libs/index/test/indexTests.cc
index 080becccf1..77b6e02f18 100644
--- a/source/libs/index/test/indexTests.cc
+++ b/source/libs/index/test/indexTests.cc
@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 #include <gtest/gtest.h>
+#include <algorithm>
 #include <iostream>
 #include <string>
 #include <thread>
@@ -457,7 +458,10 @@ TEST_F(IndexTFileEnv, test_tfile_write) {
   // taosArrayPush(data, &v4);
 
   fObj->Put(data);
-  for (size_t i = 0; i < taosArrayGetSize(data); i++) { destroyTFileValue(taosArrayGetP(data, i)); }
+  for (size_t i = 0; i < taosArrayGetSize(data); i++) {
+    // data
+    destroyTFileValue(taosArrayGetP(data, i));
+  }
   taosArrayDestroy(data);
 
   std::string     colName("voltage");
@@ -470,6 +474,7 @@ TEST_F(IndexTFileEnv, test_tfile_write) {
   fObj->Get(&query, result);
   assert(taosArrayGetSize(result) == 200);
   indexTermDestroy(term);
+  taosArrayDestroy(result);
 
   // tfileWriterDestroy(twrite);
 }
@@ -477,7 +482,7 @@ class CacheObj {
  public:
   CacheObj() {
     // TODO
-    cache = indexCacheCreate(NULL, "voltage", TSDB_DATA_TYPE_BINARY);
+    cache = indexCacheCreate(NULL, 0, "voltage", TSDB_DATA_TYPE_BINARY);
   }
   int Put(SIndexTerm* term, int16_t colId, int32_t version, uint64_t uid) {
     int ret = indexCachePut(cache, term, uid);
@@ -534,6 +539,7 @@ TEST_F(IndexCacheEnv, cache_test) {
     SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                        colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
+    indexTermDestroy(term);
     // indexTermDestry(term);
   }
   {
@@ -541,24 +547,28 @@ TEST_F(IndexCacheEnv, cache_test) {
     SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                        colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
+    indexTermDestroy(term);
   }
   {
     std::string colVal("v2");
     SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                        colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
+    indexTermDestroy(term);
   }
   {
     std::string colVal("v3");
     SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                        colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
+    indexTermDestroy(term);
   }
   {
     std::string colVal("v3");
     SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                        colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
+    indexTermDestroy(term);
   }
   coj->Debug();
   std::cout << "--------first----------" << std::endl;
@@ -567,12 +577,14 @@ TEST_F(IndexCacheEnv, cache_test) {
     SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                        colVal.c_str(), colVal.size());
     coj->Put(term, othColId, version++, suid++);
+    indexTermDestroy(term);
   }
   {
     std::string colVal("v4");
     SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                        colVal.c_str(), colVal.size());
     coj->Put(term, othColId, version++, suid++);
+    indexTermDestroy(term);
   }
   coj->Debug();
   std::cout << "--------second----------" << std::endl;
@@ -583,6 +595,7 @@ TEST_F(IndexCacheEnv, cache_test) {
       SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                          colVal.c_str(), colVal.size());
       coj->Put(term, colId, version++, suid++);
+      indexTermDestroy(term);
     }
   }
   coj->Debug();
@@ -598,6 +611,9 @@ TEST_F(IndexCacheEnv, cache_test) {
     coj->Get(&query, colId, 10000, ret, &valType);
     std::cout << "size : " << taosArrayGetSize(ret) << std::endl;
     assert(taosArrayGetSize(ret) == 4);
+    taosArrayDestroy(ret);
+
+    indexTermDestroy(term);
   }
   {
     std::string     colVal("v2");
@@ -609,6 +625,9 @@ TEST_F(IndexCacheEnv, cache_test) {
 
     coj->Get(&query, colId, 10000, ret, &valType);
     assert(taosArrayGetSize(ret) == 1);
+    taosArrayDestroy(ret);
+
+    indexTermDestroy(term);
   }
 }
 class IndexObj {
@@ -620,7 +639,7 @@ class IndexObj {
     indexInit();
   }
   int Init(const std::string& dir) {
-    taosRemoveDir(dir.c_str());
+    // taosRemoveDir(dir.c_str());
     taosMkDir(dir.c_str());
     int ret = indexOpen(&opts, dir.c_str(), &idx);
     if (ret != 0) {
@@ -645,10 +664,11 @@ class IndexObj {
   int WriteMultiMillonData(const std::string& colName, const std::string& colVal = "Hello world",
                            size_t numOfTable = 100 * 10000) {
     std::string tColVal = colVal;
+    size_t      colValSize = tColVal.size();
     for (int i = 0; i < numOfTable; i++) {
-      tColVal[tColVal.size() - 1] = 'a' + i % 26;
+      tColVal[i % colValSize] = 'a' + i % 26;
       SIndexTerm*      term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
-                                         colVal.c_str(), colVal.size());
+                                         tColVal.c_str(), tColVal.size());
       SIndexMultiTerm* terms = indexMultiTermCreate();
       indexMultiTermAdd(terms, term);
       for (size_t i = 0; i < 10; i++) {
@@ -677,14 +697,23 @@ class IndexObj {
     indexMultiTermQueryAdd(mq, term, QUERY_TERM);
 
     SArray* result = (SArray*)taosArrayInit(1, sizeof(uint64_t));
-    if (Search(mq, result) == 0) { std::cout << "search one successfully" << std::endl; }
-    return taosArrayGetSize(result);
+
+    int64_t s = taosGetTimestampUs();
+    if (Search(mq, result) == 0) {
+      int64_t e = taosGetTimestampUs();
+      std::cout << "search one successfully and time cost:" << e - s << std::endl;
+    } else {
+    }
+    int sz = taosArrayGetSize(result);
+    indexMultiTermQueryDestroy(mq);
+    taosArrayDestroy(result);
+    return sz;
     // assert(taosArrayGetSize(result) == targetSize);
   }
   void PutOne(const std::string& colName, const std::string& colVal) {
+    SIndexMultiTerm* terms = indexMultiTermCreate();
     SIndexTerm*      term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
                                        colVal.c_str(), colVal.size());
-    SIndexMultiTerm* terms = indexMultiTermCreate();
     indexMultiTermAdd(terms, term);
     Put(terms, 10);
     indexMultiTermDestroy(terms);
@@ -783,18 +812,21 @@ TEST_F(IndexEnv2, testIndexOpen) {
     index->Search(mq, result);
     std::cout << "target size: " << taosArrayGetSize(result) << std::endl;
     assert(taosArrayGetSize(result) == 400);
+    taosArrayDestroy(result);
+    indexMultiTermQueryDestroy(mq);
   }
 }
 
 TEST_F(IndexEnv2, testIndex_TrigeFlush) {
-  std::string path = "/tmp/test";
+  std::string path = "/tmp/testxxx";
   if (index->Init(path) != 0) {
     // r
     std::cout << "failed to init" << std::endl;
   }
   int numOfTable = 100 * 10000;
-  index->WriteMillonData("tag1", "Hello", numOfTable);
-  int target = index->SearchOne("tag1", "Hello");
+  index->WriteMillonData("tag1", "Hello Wolrd", numOfTable);
+  int target = index->SearchOne("tag1", "Hello Wolrd");
+  std::cout << "Get Index: " << target << std::endl;
   assert(numOfTable == target);
 }
 
@@ -802,6 +834,10 @@ static void write_and_search(IndexObj* idx) {
   std::string colName("tag1"), colVal("Hello");
 
   int target = idx->SearchOne("tag1", "Hello");
+  std::cout << "search: " << target << std::endl;
+  target = idx->SearchOne("tag2", "Test");
+  std::cout << "search: " << target << std::endl;
+
   idx->PutOne(colName, colVal);
 }
 TEST_F(IndexEnv2, testIndex_serarch_cache_and_tfile) {
@@ -809,7 +845,10 @@ TEST_F(IndexEnv2, testIndex_serarch_cache_and_tfile) {
   if (index->Init(path) != 0) {
     // opt
   }
-  index->WriteMultiMillonData("tag1", "Hello", 200000);
+  index->PutOne("tag1", "Hello");
+  index->PutOne("tag2", "Test");
+  index->WriteMultiMillonData("tag1", "Hello", 50 * 10000);
+  index->WriteMultiMillonData("tag2", "Test", 50 * 10000);
   std::thread threads[NUM_OF_THREAD];
 
   for (int i = 0; i < NUM_OF_THREAD; i++) {
@@ -821,25 +860,17 @@ TEST_F(IndexEnv2, testIndex_serarch_cache_and_tfile) {
     threads[i].join();
   }
 }
-TEST_F(IndexEnv2, testIndex_multi_thread_write) {
-  std::string path = "/tmp";
-  if (index->Init(path) != 0) {}
-}
-TEST_F(IndexEnv2, testIndex_multi_thread_read) {
-  std::string path = "/tmp";
-  if (index->Init(path) != 0) {}
-}
 
 TEST_F(IndexEnv2, testIndex_restart) {
-  std::string path = "/tmp";
+  std::string path = "/tmp/test1";
   if (index->Init(path) != 0) {}
 }
 
 TEST_F(IndexEnv2, testIndex_performance) {
-  std::string path = "/tmp";
+  std::string path = "/tmp/test2";
   if (index->Init(path) != 0) {}
 }
 TEST_F(IndexEnv2, testIndexMultiTag) {
-  std::string path = "/tmp";
+  std::string path = "/tmp/test3";
   if (index->Init(path) != 0) {}
 }
diff --git a/source/libs/parser/CMakeLists.txt b/source/libs/parser/CMakeLists.txt
index 6ab3020935..7f77876c4c 100644
--- a/source/libs/parser/CMakeLists.txt
+++ b/source/libs/parser/CMakeLists.txt
@@ -11,4 +11,6 @@ target_link_libraries(
         PRIVATE os util catalog function transport qcom
 )
 
-ADD_SUBDIRECTORY(test)
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
diff --git a/source/libs/parser/inc/parserInt.h b/source/libs/parser/inc/parserInt.h
index 4bbe6ab907..346bd0cbe4 100644
--- a/source/libs/parser/inc/parserInt.h
+++ b/source/libs/parser/inc/parserInt.h
@@ -68,7 +68,9 @@ int32_t qParserValidateSqlNode(struct SCatalog* pCatalog, SSqlInfo* pSqlInfo, SQ
  * @param type
  * @return
  */
-int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStmtInfo* pDcl, char* msgBuf, int32_t msgBufLen);
+SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen);
+
+SInsertStmtInfo* qParserValidateCreateTbSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen);
 
 /**
  * Evaluate the numeric and timestamp arithmetic expression in the WHERE clause.
diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y
index 789f5a98e2..c6e1c004e3 100644
--- a/source/libs/parser/inc/sql.y
+++ b/source/libs/parser/inc/sql.y
@@ -392,7 +392,7 @@ create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP. {
 %type create_stable_args{SCreateTableSql*}
 create_stable_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
   A = tSetCreateTableInfo(X, Y, NULL, TSQL_CREATE_STABLE);
-  setSqlInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  setSqlInfo(pInfo, A, NULL, TSDB_SQL_CREATE_STABLE);
 
   V.n += Z.n;
   setCreatedTableName(pInfo, &V, &U);
diff --git a/source/libs/parser/src/astGenerator.c b/source/libs/parser/src/astGenerator.c
index 9122b0df96..3f45012405 100644
--- a/source/libs/parser/src/astGenerator.c
+++ b/source/libs/parser/src/astGenerator.c
@@ -785,7 +785,7 @@ void destroySqlInfo(SSqlInfo *pInfo) {
   taosArrayDestroy(pInfo->funcs);
   if (pInfo->type == TSDB_SQL_SELECT) {
     destroyAllSqlNode(&pInfo->sub);
-  } else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
+  } else if (pInfo->type == TSDB_SQL_CREATE_STABLE) {
     pInfo->pCreateTableInfo = destroyCreateTableSql(pInfo->pCreateTableInfo);
   } else if (pInfo->type == TSDB_SQL_ALTER_TABLE) {
     taosArrayDestroyEx(pInfo->pAlterInfo->varList, freeItem);
diff --git a/source/libs/parser/src/dCDAstProcess.c b/source/libs/parser/src/dCDAstProcess.c
index 8c11f6e528..6b42a93b73 100644
--- a/source/libs/parser/src/dCDAstProcess.c
+++ b/source/libs/parser/src/dCDAstProcess.c
@@ -35,7 +35,7 @@ static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx* pCtx, void** ou
     SVShowTablesReq* pShowReq = calloc(1, sizeof(SVShowTablesReq));
 
     SArray* array = NULL;
-    SName name = {0};
+    SName   name = {0};
     tNameSetDbName(&name, pCtx->acctId, pCtx->db, strlen(pCtx->db));
 
     char dbFname[TSDB_DB_FNAME_LEN] = {0};
@@ -48,7 +48,7 @@ static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx* pCtx, void** ou
     pEpSet->numOfEps = info->numOfEps;
     pEpSet->inUse = info->inUse;
 
-    for(int32_t i = 0; i < pEpSet->numOfEps; ++i) {
+    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;
     }
@@ -190,7 +190,7 @@ static int32_t doCheckDbOptions(SCreateDbMsg* pCreate, SMsgBuf* pMsgBuf) {
   val = htonl(pCreate->numOfVgroups);
   if (val < TSDB_MIN_VNODES_PER_DB || val > TSDB_MAX_VNODES_PER_DB) {
     snprintf(msg, tListLen(msg), "invalid number of vgroups for DB:%d valid range: [%d, %d]", val,
-        TSDB_MIN_VNODES_PER_DB, TSDB_MAX_VNODES_PER_DB);
+             TSDB_MIN_VNODES_PER_DB, TSDB_MAX_VNODES_PER_DB);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -326,8 +326,7 @@ typedef struct SVgroupTablesBatch {
   SVgroupInfo        info;
 } SVgroupTablesBatch;
 
-int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SMsgBuf* pMsgBuf, char** pOutput, int32_t* len,
-                               SEpSet* pEpSet) {
+int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SMsgBuf* pMsgBuf, char** pOutput, int32_t* len) {
   const char* msg1 = "invalid table name";
   const char* msg2 = "tags number not matched";
   const char* msg3 = "tag value too long";
@@ -359,7 +358,11 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SMsgBuf* p
     size_t      numOfInputTag = taosArrayGetSize(pValList);
     STableMeta* pSuperTableMeta = NULL;
 
-    catalogGetTableMeta(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, &name, &pSuperTableMeta);
+    code = catalogGetTableMeta(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, &name, &pSuperTableMeta);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+
     assert(pSuperTableMeta != NULL);
 
     // too long tag values will return invalid sql, not be truncated automatically
@@ -468,7 +471,7 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SMsgBuf* p
 
         SKvParam param = {.builder = &kvRowBuilder, .schema = pSchema};
 
-        SToken*  pItem = taosArrayGet(pValList, i);
+        SToken* pItem = taosArrayGet(pValList, i);
         code = parseValueToken(&endPtr, pItem, pSchema, tinfo.precision, tmpTokenBuf, KvRowAppend, &param, pMsgBuf);
 
         if (code != TSDB_CODE_SUCCESS) {
@@ -481,7 +484,7 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SMsgBuf* p
     SKVRow row = tdGetKVRowFromBuilder(&kvRowBuilder);
     tdDestroyKVRowBuilder(&kvRowBuilder);
     if (row == NULL) {
-        return TSDB_CODE_QRY_OUT_OF_MEMORY;
+      return TSDB_CODE_QRY_OUT_OF_MEMORY;
     }
 
     tdSortKVRowByColIdx(row);
@@ -501,15 +504,7 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SMsgBuf* p
     req.ctbCfg.suid = pSuperTableMeta->suid;
     req.ctbCfg.pTag = row;
 
-//    pEpSet->inUse = info.inUse;
-//    pEpSet->numOfEps = info.numOfEps;
-//    for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
-//      pEpSet->port[i] = info.epAddr[i].port;
-//      tstrncpy(pEpSet->fqdn[i], info.epAddr[i].fqdn, tListLen(pEpSet->fqdn[i]));
-//    }
-//    ((SMsgHead*)(*pOutput))->vgId = htonl(info.vgId);
-//    ((SMsgHead*)(*pOutput))->contLen = htonl(serLen);
-    SVgroupTablesBatch *pTableBatch = taosHashGet(pVgroupHashmap, &info.vgId, sizeof(info.vgId));
+    SVgroupTablesBatch* pTableBatch = taosHashGet(pVgroupHashmap, &info.vgId, sizeof(info.vgId));
     if (pTableBatch == NULL) {
       SVgroupTablesBatch tBatch = {0};
       tBatch.info = info;
@@ -518,22 +513,55 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SMsgBuf* p
       taosArrayPush(tBatch.req.pArray, &req);
 
       taosHashPut(pVgroupHashmap, &info.vgId, sizeof(info.vgId), &tBatch, sizeof(tBatch));
-    } else { // add to the correct vgroup
+    } else {  // add to the correct vgroup
       assert(info.vgId == pTableBatch->info.vgId);
       taosArrayPush(pTableBatch->req.pArray, &req);
     }
   }
 
   // TODO: serialize and
-  void *pBuf = NULL;
+  SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*));
+
+  SVgroupTablesBatch* pTbBatch = NULL;
+  do {
+    pTbBatch = taosHashIterate(pVgroupHashmap, pTbBatch);
+    if (pTbBatch == NULL) break;
+
+    int   tlen = sizeof(SMsgHead) + tSVCreateTbBatchReqSerialize(NULL, &(pTbBatch->req));
+    void* buf = malloc(tlen);
+    if (buf == NULL) {
+      // TODO: handle error
+    }
+
+    ((SMsgHead*)buf)->vgId = htonl(pTbBatch->info.vgId);
+    ((SMsgHead*)buf)->contLen = htonl(tlen);
+
+    void* pBuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
+    tSVCreateTbBatchReqSerialize(&pBuf, &(pTbBatch->req));
+
+    SVgDataBlocks* pVgData = calloc(1, sizeof(SVgDataBlocks));
+    pVgData->vg    = pTbBatch->info;
+    pVgData->pData = buf;
+    pVgData->size  = tlen;
+    pVgData->numOfTables = (int32_t) taosArrayGetSize(pTbBatch->req.pArray);
+
+    taosArrayPush(pBufArray, &pVgData);
+  } while (true);
+
+  SInsertStmtInfo* pStmtInfo = calloc(1, sizeof(SInsertStmtInfo));
+  pStmtInfo->nodeType = TSDB_SQL_CREATE_TABLE;
+  pStmtInfo->pDataBlocks = pBufArray;
+  *pOutput = pStmtInfo;
+  *len = sizeof(SInsertStmtInfo);
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStmtInfo* pDcl, char* msgBuf,
-                                  int32_t msgBufLen) {
+SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen) {
   int32_t code = 0;
 
+  SDclStmtInfo* pDcl = calloc(1, sizeof(SDclStmtInfo));
+
   SMsgBuf  m = {.buf = msgBuf, .len = msgBufLen};
   SMsgBuf* pMsgBuf = &m;
 
@@ -550,21 +578,25 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       SToken*    pPwd = &pUser->passwd;
 
       if (pName->n >= TSDB_USER_LEN) {
-        return buildInvalidOperationMsg(pMsgBuf, msg3);
+        code = buildInvalidOperationMsg(pMsgBuf, msg3);
+        goto _error;
       }
 
       if (parserValidateIdToken(pName) != TSDB_CODE_SUCCESS) {
-        return buildInvalidOperationMsg(pMsgBuf, msg2);
+        code = buildInvalidOperationMsg(pMsgBuf, msg2);
+        goto _error;
       }
 
       if (pInfo->type == TSDB_SQL_CREATE_USER) {
         if (parserValidatePassword(pPwd, pMsgBuf) != TSDB_CODE_SUCCESS) {
-          return TSDB_CODE_TSC_INVALID_OPERATION;
+          code = TSDB_CODE_TSC_INVALID_OPERATION;
+          goto _error;
         }
       } else {
         if (pUser->type == TSDB_ALTER_USER_PASSWD) {
           if (parserValidatePassword(pPwd, pMsgBuf) != TSDB_CODE_SUCCESS) {
-            return TSDB_CODE_TSC_INVALID_OPERATION;
+            code = TSDB_CODE_TSC_INVALID_OPERATION;
+            goto _error;
           }
         } else if (pUser->type == TSDB_ALTER_USER_PRIVILEGES) {
           assert(pPwd->type == TSDB_DATA_TYPE_NULL);
@@ -575,10 +607,12 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
           } else if (strncasecmp(pPrivilege->z, "normal", 4) == 0 && pPrivilege->n == 4) {
             //            pCmd->count = 2;
           } else {
-            return buildInvalidOperationMsg(pMsgBuf, msg4);
+            code = buildInvalidOperationMsg(pMsgBuf, msg4);
+            goto _error;
           }
         } else {
-          return buildInvalidOperationMsg(pMsgBuf, msg1);
+          code = buildInvalidOperationMsg(pMsgBuf, msg1);
+          goto _error;
         }
       }
 
@@ -597,15 +631,18 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       SToken* pPwd = &pInfo->pMiscInfo->user.passwd;
 
       if (parserValidatePassword(pPwd, pMsgBuf) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_OPERATION;
+        code = TSDB_CODE_TSC_INVALID_OPERATION;
+        goto _error;
       }
 
       if (pName->n >= TSDB_USER_LEN) {
-        return buildInvalidOperationMsg(pMsgBuf, msg3);
+        code = buildInvalidOperationMsg(pMsgBuf, msg3);
+        goto _error;
       }
 
       if (parserValidateNameToken(pName) != TSDB_CODE_SUCCESS) {
-        return buildInvalidOperationMsg(pMsgBuf, msg2);
+        code = buildInvalidOperationMsg(pMsgBuf, msg2);
+        goto _error;
       }
 
       SCreateAcctInfo* pAcctOpt = &pInfo->pMiscInfo->acctOpt;
@@ -615,7 +652,8 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
         } else if (strncmp(pAcctOpt->stat.z, "all", 3) == 0 && pAcctOpt->stat.n == 3) {
         } else if (strncmp(pAcctOpt->stat.z, "no", 2) == 0 && pAcctOpt->stat.n == 2) {
         } else {
-          return buildInvalidOperationMsg(pMsgBuf, msg1);
+          code = buildInvalidOperationMsg(pMsgBuf, msg1);
+          goto _error;
         }
       }
 
@@ -634,7 +672,11 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
     case TSDB_SQL_SHOW: {
       SShowInfo* pShowInfo = &pInfo->pMiscInfo->showOpt;
       code = setShowInfo(pShowInfo, pCtx, (void**)&pDcl->pMsg, &pDcl->msgLen, &pDcl->epSet, &pDcl->pExtension, pMsgBuf);
-      pDcl->msgType = (pShowInfo->showType == TSDB_MGMT_TABLE_TABLE)? TDMT_VND_SHOW_TABLES:TDMT_MND_SHOW;
+      if (code != TSDB_CODE_SUCCESS) {
+        goto _error;
+      }
+      
+      pDcl->msgType = (pShowInfo->showType == TSDB_MGMT_TABLE_TABLE) ? TDMT_VND_SHOW_TABLES : TDMT_MND_SHOW;
       break;
     }
 
@@ -643,13 +685,15 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
       SToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if (parserValidateNameToken(pToken) != TSDB_CODE_SUCCESS) {
-        return buildInvalidOperationMsg(pMsgBuf, msg);
+        code = buildInvalidOperationMsg(pMsgBuf, msg);
+        goto _error;
       }
 
       SName   n = {0};
       int32_t ret = tNameSetDbName(&n, pCtx->acctId, pToken->z, pToken->n);
       if (ret != TSDB_CODE_SUCCESS) {
-        return buildInvalidOperationMsg(pMsgBuf, msg);
+        code = buildInvalidOperationMsg(pMsgBuf, msg);
+        goto _error;
       }
 
       SUseDbMsg* pUseDbMsg = (SUseDbMsg*)calloc(1, sizeof(SUseDbMsg));
@@ -668,19 +712,22 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
       SCreateDbInfo* pCreateDB = &(pInfo->pMiscInfo->dbOpt);
       if (pCreateDB->dbname.n >= TSDB_DB_NAME_LEN) {
-        return buildInvalidOperationMsg(pMsgBuf, msg2);
+        code = buildInvalidOperationMsg(pMsgBuf, msg2);
+        goto _error;
       }
 
       char   buf[TSDB_DB_NAME_LEN] = {0};
       SToken token = taosTokenDup(&pCreateDB->dbname, buf, tListLen(buf));
 
       if (parserValidateNameToken(&token) != TSDB_CODE_SUCCESS) {
-        return buildInvalidOperationMsg(pMsgBuf, msg1);
+        code = buildInvalidOperationMsg(pMsgBuf, msg1);
+        goto _error;
       }
 
       SCreateDbMsg* pCreateMsg = buildCreateDbMsg(pCreateDB, pCtx, pMsgBuf);
       if (doCheckDbOptions(pCreateMsg, pMsgBuf) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_OPERATION;
+        code = TSDB_CODE_TSC_INVALID_OPERATION;
+        goto _error;
       }
 
       pDcl->pMsg = (char*)pCreateMsg;
@@ -698,7 +745,8 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       SName name = {0};
       code = tNameSetDbName(&name, pCtx->acctId, dbName->z, dbName->n);
       if (code != TSDB_CODE_SUCCESS) {
-        return buildInvalidOperationMsg(pMsgBuf, msg1);
+        code = buildInvalidOperationMsg(pMsgBuf, msg1);
+        goto _error;
       }
 
       SDropDbMsg* pDropDbMsg = (SDropDbMsg*)calloc(1, sizeof(SDropDbMsg));
@@ -710,25 +758,21 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       pDcl->msgType = TDMT_MND_DROP_DB;
       pDcl->msgLen = sizeof(SDropDbMsg);
       pDcl->pMsg = (char*)pDropDbMsg;
-      return TSDB_CODE_SUCCESS;
+      break;
     }
 
-    case TSDB_SQL_CREATE_TABLE: {
+    case TSDB_SQL_CREATE_STABLE: {
       SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
+      assert(pCreateTable->type != TSQL_CREATE_CTABLE);
 
       if (pCreateTable->type == TSQL_CREATE_TABLE || pCreateTable->type == TSQL_CREATE_STABLE) {
         if ((code = doCheckForCreateTable(pInfo, pMsgBuf)) != TSDB_CODE_SUCCESS) {
-          return code;
-        }
-        pDcl->pMsg = (char*)buildCreateTableMsg(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf);
-        pDcl->msgType = (pCreateTable->type == TSQL_CREATE_TABLE) ? TDMT_VND_CREATE_TABLE : TDMT_MND_CREATE_STB;
-      } else if (pCreateTable->type == TSQL_CREATE_CTABLE) {
-        if ((code = doCheckForCreateCTable(pInfo, pCtx, pMsgBuf, &pDcl->pMsg, &pDcl->msgLen, &pDcl->epSet)) !=
-            TSDB_CODE_SUCCESS) {
-          return code;
+          terrno = code;
+          goto _error;
         }
 
-        pDcl->msgType = TDMT_VND_CREATE_TABLE;
+        pDcl->pMsg = (char*)buildCreateTableMsg(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf);
+        pDcl->msgType = (pCreateTable->type == TSQL_CREATE_TABLE) ? TDMT_VND_CREATE_TABLE : TDMT_MND_CREATE_STB;
       } else if (pCreateTable->type == TSQL_CREATE_STREAM) {
         //        if ((code = doCheckForStream(pSql, pInfo)) != TSDB_CODE_SUCCESS) {
         //          return code;
@@ -740,7 +784,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
     case TSDB_SQL_DROP_TABLE: {
       pDcl->pMsg = (char*)buildDropStableMsg(pInfo, &pDcl->msgLen, pCtx, pMsgBuf);
       if (pDcl->pMsg == NULL) {
-        code = terrno;
+        goto _error;
       }
 
       pDcl->msgType = TDMT_MND_DROP_STB;
@@ -750,7 +794,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
     case TSDB_SQL_CREATE_DNODE: {
       pDcl->pMsg = (char*)buildCreateDnodeMsg(pInfo, &pDcl->msgLen, pMsgBuf);
       if (pDcl->pMsg == NULL) {
-        code = terrno;
+        goto _error;
       }
 
       pDcl->msgType = TDMT_MND_CREATE_DNODE;
@@ -760,7 +804,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
     case TSDB_SQL_DROP_DNODE: {
       pDcl->pMsg = (char*)buildDropDnodeMsg(pInfo, &pDcl->msgLen, pMsgBuf);
       if (pDcl->pMsg == NULL) {
-        code = terrno;
+        goto _error;
       }
 
       pDcl->msgType = TDMT_MND_DROP_DNODE;
@@ -771,5 +815,29 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       break;
   }
 
-  return code;
+  return pDcl;
+
+  _error:
+    terrno = code;
+    tfree(pDcl);
+    return NULL;
 }
+
+SInsertStmtInfo* qParserValidateCreateTbSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen) {
+  SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
+  assert(pCreateTable->type == TSQL_CREATE_CTABLE);
+
+  SMsgBuf  m = {.buf = msgBuf, .len = msgBufLen};
+  SMsgBuf* pMsgBuf = &m;
+
+  SInsertStmtInfo* pInsertStmt = NULL;
+
+  int32_t msgLen = 0;
+  int32_t code = doCheckForCreateCTable(pInfo, pCtx, pMsgBuf, (char**) &pInsertStmt, &msgLen);
+  if (code != TSDB_CODE_SUCCESS) {
+    tfree(pInsertStmt);
+    return NULL;
+  }
+
+  return pInsertStmt;
+}
\ No newline at end of file
diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c
index 710cf4b5d0..1b4d05808c 100644
--- a/source/libs/parser/src/parser.c
+++ b/source/libs/parser/src/parser.c
@@ -32,7 +32,7 @@ bool isInsertSql(const char* pStr, size_t length) {
 }
 
 bool qIsDdlQuery(const SQueryNode* pQuery) {
-  return TSDB_SQL_INSERT != pQuery->type && TSDB_SQL_SELECT != pQuery->type;
+  return TSDB_SQL_INSERT != pQuery->type && TSDB_SQL_SELECT != pQuery->type && TSDB_SQL_CREATE_TABLE != pQuery->type;
 }
 
 int32_t parseQuerySql(SParseContext* pCxt, SQueryNode** pQuery) {
@@ -44,16 +44,29 @@ int32_t parseQuerySql(SParseContext* pCxt, SQueryNode** pQuery) {
   }
 
   if (!isDqlSqlStatement(&info)) {
-    SDclStmtInfo* pDcl = calloc(1, sizeof(SDclStmtInfo));
-    if (NULL == pDcl) {
-      terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; // set correct error code.
-      return terrno;
+    bool toVnode = false;
+    if (info.type == TSDB_SQL_CREATE_TABLE) {
+      SCreateTableSql* pCreateSql = info.pCreateTableInfo;
+      if (pCreateSql->type == TSQL_CREATE_CTABLE || pCreateSql->type == TSQL_CREATE_TABLE) {
+        toVnode = true;
+      }
     }
 
-    pDcl->nodeType = info.type;
-    int32_t code = qParserValidateDclSqlNode(&info, &pCxt->ctx, pDcl, pCxt->pMsg, pCxt->msgLen);
-    if (code == TSDB_CODE_SUCCESS) {
+    if (toVnode) {
+      SInsertStmtInfo *pInsertInfo = qParserValidateCreateTbSqlNode(&info, &pCxt->ctx, pCxt->pMsg, pCxt->msgLen);
+      if (pInsertInfo == NULL) {
+        return terrno;
+      }
+
+      *pQuery = (SQueryNode*) pInsertInfo;
+    } else {
+      SDclStmtInfo* pDcl = qParserValidateDclSqlNode(&info, &pCxt->ctx, pCxt->pMsg, pCxt->msgLen);
+      if (pDcl == NULL) {
+        return terrno;
+      }
+
       *pQuery = (SQueryNode*)pDcl;
+      pDcl->nodeType = info.type;
     }
   } else {
     SQueryStmtInfo* pQueryInfo = calloc(1, sizeof(SQueryStmtInfo));
diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c
index f7f56510da..d265031a81 100644
--- a/source/libs/parser/src/sql.c
+++ b/source/libs/parser/src/sql.c
@@ -131,16 +131,16 @@ typedef union {
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
 #define YYNSTATE             366
-#define YYNRULE              303
+#define YYNRULE              302
 #define YYNTOKEN             191
 #define YY_MAX_SHIFT         365
-#define YY_MIN_SHIFTREDUCE   587
-#define YY_MAX_SHIFTREDUCE   889
-#define YY_ERROR_ACTION      890
-#define YY_ACCEPT_ACTION     891
-#define YY_NO_ACTION         892
-#define YY_MIN_REDUCE        893
-#define YY_MAX_REDUCE        1195
+#define YY_MIN_SHIFTREDUCE   586
+#define YY_MAX_SHIFTREDUCE   887
+#define YY_ERROR_ACTION      888
+#define YY_ACCEPT_ACTION     889
+#define YY_NO_ACTION         890
+#define YY_MIN_REDUCE        891
+#define YY_MAX_REDUCE        1192
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -206,168 +206,167 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (782)
+#define YY_ACTTAB_COUNT (777)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   249,  638,  364,  230,  162,  639,  248,   55,   56,  638,
- /*    10 */    59,   60, 1031,  639,  252,   49,   48,   47,   94,   58,
- /*    20 */   323,   63,   61,   64,   62,  674, 1080,  891,  365,   54,
- /*    30 */    53,  206,   82,   52,   51,   50,  253,   55,   56,  638,
- /*    40 */    59,   60, 1171,  639,  252,   49,   48,   47,   21,   58,
- /*    50 */   323,   63,   61,   64,   62, 1017,  203, 1015, 1016,   54,
- /*    60 */    53,  206, 1018,   52,   51,   50, 1019,  206, 1020, 1021,
- /*    70 */   832,  835, 1172,   55,   56, 1070,   59,   60, 1172, 1118,
- /*    80 */   252,   49,   48,   47,   81,   58,  323,   63,   61,   64,
- /*    90 */    62,  321,  319,  274, 1077,   54,   53,  206,  638,   52,
- /*   100 */    51,   50,  639,   55,   57,  353,   59,   60, 1172,  826,
- /*   110 */   252,   49,   48,   47,  155,   58,  323,   63,   61,   64,
- /*   120 */    62,   42,  319,  359,  358,   54,   53,  162,  357,   52,
- /*   130 */    51,   50,  356,   87,  355,  354,  162,  162,  588,  589,
- /*   140 */   590,  591,  592,  593,  594,  595,  596,  597,  598,  599,
- /*   150 */   600,  601,  153,   56,  231,   59,   60,  236, 1057,  252,
- /*   160 */    49,   48,   47,   87,   58,  323,   63,   61,   64,   62,
- /*   170 */   772,   43,   32,   86,   54,   53,  255,  204,   52,   51,
- /*   180 */    50,  309,  209,  280,  279,   59,   60,  941,  839,  252,
- /*   190 */    49,   48,   47,  188,   58,  323,   63,   61,   64,   62,
- /*   200 */   294,   43,   92,  242,   54,   53,  300, 1045,   52,   51,
- /*   210 */    50, 1119,   93,  292,   42,  317,  359,  358,  316,  315,
- /*   220 */   314,  357,  313,  312,  311,  356,  310,  355,  354,   99,
- /*   230 */    22, 1010,  998,  999, 1000, 1001, 1002, 1003, 1004, 1005,
- /*   240 */  1006, 1007, 1008, 1009, 1011, 1012, 1013,  215,  251,  841,
- /*   250 */   830,  833,  836,  256,  216,  254,  776,  331,  330,  250,
- /*   260 */   137,  136,  135,  217, 1033,  266,  719,  328,   87,  251,
- /*   270 */   841,  830,  833,  836,  270,  269,  228,  229,  831,  834,
- /*   280 */   324,    4,   63,   61,   64,   62,  755,  752,  753,  754,
- /*   290 */    54,   53,  343,  342,   52,   51,   50,  228,  229,  747,
- /*   300 */   744,  745,  746,   52,   51,   50,   43,    3,   39,  178,
- /*   310 */   152,  150,  149,  257,  258,  105,   77,  101,  108, 1039,
- /*   320 */    96,  791,  792,  260,   36,   65,  244,  245,  273,   36,
- /*   330 */    79,  197,  195,  193,   36,  305,  210,  224,  192,  141,
- /*   340 */   140,  139,  138,   36,   36,   36,   65,  122,  116,  126,
- /*   350 */    36,  211, 1028, 1029,   33, 1032,  131,  134,  125,  638,
- /*   360 */    36,  842,  837,  639,  243,  128,   36,  232,  838,   54,
- /*   370 */    53, 1042,  240,   52,   51,   50, 1042,  241,   36,   36,
- /*   380 */    36, 1042,  842,  837, 1166,  261,  332,  333,  334,  838,
- /*   390 */  1042, 1042, 1042,  335,  176,   12,  840, 1042,  756,  757,
- /*   400 */   262,   95,  259,  339,  338,  337,  171, 1042,  363,  362,
- /*   410 */   146,  748,  749, 1041,  246,   80,  808, 1070, 1045, 1070,
- /*   420 */   261,  340,  341,  345,  282, 1042, 1042, 1042,  124,  177,
- /*   430 */    98,  261,  952,  942,  769,  233,   27,  234,  188,  188,
- /*   440 */  1043,  275,  353,  360,  979,   84,   85,  788, 1030,  798,
- /*   450 */   799,   71,   74,  729,  297,  731,  299,   37,  325,    7,
- /*   460 */   742,  743,  730,  157,  828,   66,   24,  740,  741,   37,
- /*   470 */    37,   67,   97,  864,  807,  760,  761,  843,   67,  637,
- /*   480 */    14,   78,   13,   70,   70,  115, 1165,  114,   16,   23,
- /*   490 */    15,   75,   72,   23, 1111,   23,  829,  758,  759,  133,
- /*   500 */   132,   18,  121,   17,  120,   20, 1164,   19, 1129,  226,
- /*   510 */   322,  227,  207, 1056,  718,  208,  212,  205,  213,  214,
- /*   520 */  1044,  219, 1072,  220, 1191,  221,  218,  202, 1128, 1183,
- /*   530 */   238, 1125, 1124,  239,  344,  271,  154,   44,  172, 1079,
- /*   540 */   151, 1110, 1090, 1087, 1088, 1071,  277, 1092, 1040,  156,
- /*   550 */  1068,  281,  235,  283,   31,  161,  285,  165,  288,  173,
- /*   560 */   163,  168,  787,  845,  164,  276, 1038,  174,  166,  169,
- /*   570 */   167,  291,  175,  956,  302,  303,  304,   76,  307,  308,
- /*   580 */   200,   40,  320,  951,  950,  329, 1190,  112,   73, 1189,
- /*   590 */  1186,  179,   46,  336,  295, 1182,  118,  287, 1181, 1178,
- /*   600 */   180,  976,   41,   38,  201,  939,  127,  937,  129,  130,
- /*   610 */   935,  934,  263,  190,  191,  931,  930,  929,  928,  293,
- /*   620 */   927,  926,  925,  194,  196,  922,  920,  918,  916,  198,
- /*   630 */   913,  199,  909,  289,  284,   83,   88,   45,  286, 1112,
- /*   640 */   306,  123,  346,  225,  247,  347,  301,  348,  349,  351,
- /*   650 */   222,  223,  350,  352,  361,  955,  954,  106,  889,  264,
- /*   660 */   265,  888,  267,  268,  887,  870,  933,  869,  272,  183,
- /*   670 */   182,  977,  932,  181,  142,  184,  185,  187,  186,  143,
- /*   680 */   144,  924,  978,  923,    2,   70,  145,  915,  914,  296,
- /*   690 */     8,   28,    1,  763,  278,  170,  789,   89,  158,  160,
- /*   700 */   800,  159,  237,  794,   90,   29,  796,   91,  290,    9,
- /*   710 */    30,   10,   11,   25,   26,  298,  100,   34,   98,  103,
- /*   720 */   652,  102,  690,   35,  104,  687,  685,  684,  683,  681,
- /*   730 */   680,  679,  676,  642,  326,  327,  107,  111,  109,  318,
- /*   740 */   113,  110,    5,   68,  844,  846,    6,   69,  721,   37,
- /*   750 */   117,  119,  720,  717,  668,  666,  658,  664,  660,  662,
- /*   760 */   656,  654,  689,  688,  686,  682,  678,  677,  189,  640,
- /*   770 */   893,  605,  892,  892,  892,  892,  892,  892,  892,  892,
- /*   780 */   147,  148,
+ /*     0 */   249,  637,  637, 1077,   83,  717,  248,   55,   56,   88,
+ /*    10 */    59,   60,  364,  230,  252,   49,   48,   47,   78,   58,
+ /*    20 */   323,   63,   61,   64,   62,  236, 1054,  889,  365,   54,
+ /*    30 */    53,  343,  342,   52,   51,   50,  253,   55,   56,  242,
+ /*    40 */    59,   60, 1027, 1042,  252,   49,   48,   47,  104,   58,
+ /*    50 */   323,   63,   61,   64,   62, 1014,  637, 1012, 1013,   54,
+ /*    60 */    53,  206, 1015,   52,   51,   50, 1016,  206, 1017, 1018,
+ /*    70 */   121, 1074, 1169,   55,   56, 1067,   59,   60, 1169,   27,
+ /*    80 */   252,   49,   48,   47,   89,   58,  323,   63,   61,   64,
+ /*    90 */    62,  206,   39,  274,  246,   54,   53,  206, 1042,   52,
+ /*   100 */    51,   50, 1168,   55,   57, 1030,   59,   60, 1169,  824,
+ /*   110 */   252,   49,   48,   47,   80,   58,  323,   63,   61,   64,
+ /*   120 */    62,  294,  637,   81,  159,   54,   53,   91,  319,   52,
+ /*   130 */    51,   50,  104, 1067,   56,  232,   59,   60,  353, 1039,
+ /*   140 */   252,   49,   48,   47,  261,   58,  323,   63,   61,   64,
+ /*   150 */    62,  233,   43,  124,   79,   54,   53,   80,   39,   52,
+ /*   160 */    51,   50,  587,  588,  589,  590,  591,  592,  593,  594,
+ /*   170 */   595,  596,  597,  598,  599,  600,  199,  309,  231,   59,
+ /*   180 */    60,  939, 1067,  252,   49,   48,   47,  158,   58,  323,
+ /*   190 */    63,   61,   64,   62,  353,   43,  280,  279,   54,   53,
+ /*   200 */   234,  240,   52,   51,   50, 1039,   14, 1116,   13,  292,
+ /*   210 */    42,  317,  359,  358,  316,  315,  314,  357,  313,  312,
+ /*   220 */   311,  356,  310,  355,  354, 1007,  995,  996,  997,  998,
+ /*   230 */   999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1008, 1009,
+ /*   240 */  1010,  266,   12,   22,   63,   61,   64,   62,   84,   21,
+ /*   250 */   270,  269,   54,   53,  789,  790,   52,   51,   50,  946,
+ /*   260 */   215,  113,  251,  839,  828,  831,  834,  216,  753,  750,
+ /*   270 */   751,  752,  672,  175,  174,  172,  217,  119,  261,  282,
+ /*   280 */   328,   80,  251,  839,  828,  831,  834,  127,  116,  203,
+ /*   290 */   228,  229,  255,   39,  324,  257,  258,  745,  742,  743,
+ /*   300 */   744,  204,   39, 1036,    3,   32,  131,  261,  209,  260,
+ /*   310 */   228,  229,  129,   85,  123,  133, 1040,   39,   39,   43,
+ /*   320 */  1025, 1026,   30, 1029,  244,  245,  189,  186,  183,   52,
+ /*   330 */    51,   50,  305,  181,  179,  178,  177,  176,  319,   65,
+ /*   340 */  1038,  273,  637,   86,   42,  241,  359,  358,  243, 1039,
+ /*   350 */   224,  357,  770,  830,  833,  356,   39,  355,  354,   65,
+ /*   360 */   332,  333,   54,   53, 1039, 1039,   52,   51,   50,  256,
+ /*   370 */    39,  254,   39,  331,  330,  840,  835,  104,   39,   39,
+ /*   380 */   754,  755,  836,  149,  142,  162,  262,   39,  259,  806,
+ /*   390 */   338,  337,  167,  170,  160,  840,  835,  829,  832,  334,
+ /*   400 */   104,  164,  836, 1039,  826,  363,  362,  190,  767,  746,
+ /*   410 */   747,   92,  949,  335,  940,  339,   93, 1039,  158, 1039,
+ /*   420 */   158,  340,  341,   71,  321, 1039, 1039,  198,  195,  193,
+ /*   430 */   345,  360,  976,    7, 1039,  275,  827,  786,  774,  796,
+ /*   440 */   797,   74,  727,  297,  729,  299,  325,  805,   35,   70,
+ /*   450 */   210,   40, 1115,   97,   70,   66,   24,  728,   40,   40,
+ /*   460 */    67,  117,  740,  741,   72,  738,  739,  862,  841,  250,
+ /*   470 */   636,  837,  140,   67,  139,   82,   16,   18,   15,   17,
+ /*   480 */    75,  211,  300,   23,   23,   77,   23,  758,  759,  169,
+ /*   490 */   168,    4,  756,  757,  147,   20,  146,   19, 1163, 1162,
+ /*   500 */  1161,  226,  227,  207,  208,  212, 1053, 1041,  205, 1126,
+ /*   510 */   213,  214,  219,  220,  221,  838,  218,  202,  716, 1188,
+ /*   520 */  1180, 1125, 1069,  238, 1122, 1121,  239,   44, 1068,  344,
+ /*   530 */   277,  114,  322, 1108, 1107,  196,  271,  785, 1037,  276,
+ /*   540 */  1065,   87, 1076, 1087,  281,  235,   73,   90, 1084, 1085,
+ /*   550 */    76,  843,  283, 1089,  295,   46,  105,  106,   94,  107,
+ /*   560 */   293,   95,  101,  108,  285,  291,  288,  286,  109, 1109,
+ /*   570 */   289,  110,  287,  111,  284,  112,   29,   45,  225,  115,
+ /*   580 */  1035,  306,  150,  247,  118,  952,  346,  120,  301,  953,
+ /*   590 */   302,  303,  304,  974,  307,  308,  200,  347,  348,   38,
+ /*   600 */   320,  349,  948,  951,  947,  130,  329,  350, 1187,  351,
+ /*   610 */   352,  361,  137, 1186, 1183,  887,  141,  222,  336, 1179,
+ /*   620 */   152,  144, 1178,  265, 1175,  886,  148,  223,  973,  268,
+ /*   630 */   885,  868,  867,   70,  296,    8,   28,   41,   31,  761,
+ /*   640 */   278,   96,  153,  201,  937,  151,  154,  156,  157,  155,
+ /*   650 */   163,  935,  165,    1,  166,  933,  264,  932,  263,  171,
+ /*   660 */   267,  975,  931,  930,  173,  929,  928,  927,  926,  925,
+ /*   670 */   924,  272,  923,  787,  180,  184,   98,  182,  922,  798,
+ /*   680 */   185,  921,   99,  188,  187,  920,  918,  792,  100,  916,
+ /*   690 */   914,  102,  194,  913,  911,  912,  197,  907,  794,    2,
+ /*   700 */   237,  103,  290,    9,   33,   34,   10,   11,   25,  298,
+ /*   710 */    26,  122,  119,   36,  126,  125,  650,  688,   37,  128,
+ /*   720 */   685,  683,  682,  681,  679,  678,  677,  674,  640,  132,
+ /*   730 */     5,  134,  135,  842,  318,  844,    6,  326,  327,   68,
+ /*   740 */   136,   40,   69,  719,  718,  138,  143,  145,  715,  666,
+ /*   750 */   664,  656,  662,  658,  660,  654,  652,  687,  686,  684,
+ /*   760 */   680,  676,  675,  161,  604,  638,  891,  890,  890,  890,
+ /*   770 */   890,  890,  890,  890,  890,  191,  192,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   200,    1,  194,  195,  194,    5,  200,    7,    8,    1,
- /*    10 */    10,   11,    0,    5,   14,   15,   16,   17,  245,   19,
- /*    20 */    20,   21,   22,   23,   24,    3,  194,  192,  193,   29,
- /*    30 */    30,  261,  259,   33,   34,   35,  200,    7,    8,    1,
- /*    40 */    10,   11,  272,    5,   14,   15,   16,   17,  261,   19,
- /*    50 */    20,   21,   22,   23,   24,  216,  261,  218,  219,   29,
+ /*     0 */   200,    1,    1,  194,  245,    3,  200,    7,    8,  201,
+ /*    10 */    10,   11,  194,  195,   14,   15,   16,   17,  259,   19,
+ /*    20 */    20,   21,   22,   23,   24,  243,  244,  192,  193,   29,
+ /*    30 */    30,   29,   30,   33,   34,   35,  200,    7,    8,  238,
+ /*    40 */    10,   11,  234,  242,   14,   15,   16,   17,  194,   19,
+ /*    50 */    20,   21,   22,   23,   24,  216,    1,  218,  219,   29,
  /*    60 */    30,  261,  223,   33,   34,   35,  227,  261,  229,  230,
- /*    70 */     3,    4,  272,    7,    8,  240,   10,   11,  272,  269,
+ /*    70 */   201,  262,  272,    7,    8,  240,   10,   11,  272,   78,
  /*    80 */    14,   15,   16,   17,   84,   19,   20,   21,   22,   23,
- /*    90 */    24,   83,   80,  258,  262,   29,   30,  261,    1,   33,
- /*   100 */    34,   35,    5,    7,    8,   88,   10,   11,  272,   79,
- /*   110 */    14,   15,   16,   17,  194,   19,   20,   21,   22,   23,
- /*   120 */    24,   96,   80,   98,   99,   29,   30,  194,  103,   33,
- /*   130 */    34,   35,  107,   78,  109,  110,  194,  194,   41,   42,
- /*   140 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
- /*   150 */    53,   54,   55,    8,   57,   10,   11,  243,  244,   14,
- /*   160 */    15,   16,   17,   78,   19,   20,   21,   22,   23,   24,
- /*   170 */    33,  116,   78,  118,   29,   30,   64,  261,   33,   34,
- /*   180 */    35,   63,  261,  263,  264,   10,   11,  199,  121,   14,
- /*   190 */    15,   16,   17,  205,   19,   20,   21,   22,   23,   24,
- /*   200 */   267,  116,  269,  238,   29,   30,  112,  242,   33,   34,
- /*   210 */    35,  269,  269,  271,   96,   97,   98,   99,  100,  101,
- /*   220 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  201,
- /*   230 */    40,  216,  217,  218,  219,  220,  221,  222,  223,  224,
- /*   240 */   225,  226,  227,  228,  229,  230,  231,   57,    1,    2,
- /*   250 */     3,    4,    5,  141,   64,  143,  119,  145,  146,   56,
- /*   260 */    70,   71,   72,   73,  236,  139,    3,   77,   78,    1,
- /*   270 */     2,    3,    4,    5,  148,  149,   29,   30,    3,    4,
- /*   280 */    33,   78,   21,   22,   23,   24,    2,    3,    4,    5,
- /*   290 */    29,   30,   29,   30,   33,   34,   35,   29,   30,    2,
- /*   300 */     3,    4,    5,   33,   34,   35,  116,   58,   59,   60,
- /*   310 */    58,   59,   60,   29,   30,   66,   67,   68,   69,  194,
- /*   320 */   201,  122,  123,   64,  194,   78,   29,   30,  138,  194,
- /*   330 */   140,   58,   59,   60,  194,   86,  261,  147,   65,   66,
- /*   340 */    67,   68,   69,  194,  194,  194,   78,   58,   59,   60,
- /*   350 */   194,  261,  233,  234,  235,  236,   67,   68,   69,    1,
- /*   360 */   194,  114,  115,    5,  239,   76,  194,  237,  121,   29,
- /*   370 */    30,  241,  237,   33,   34,   35,  241,  237,  194,  194,
- /*   380 */   194,  241,  114,  115,  261,  194,  237,  237,  237,  121,
- /*   390 */   241,  241,  241,  237,  203,   78,  121,  241,  114,  115,
- /*   400 */   141,   84,  143,  237,  145,  146,  248,  241,   61,   62,
- /*   410 */    63,  114,  115,  241,  238,  201,   72,  240,  242,  240,
- /*   420 */   194,  237,  237,  237,  266,  241,  241,  241,   74,  203,
- /*   430 */   113,  194,  199,  199,   95,  258,   78,  258,  205,  205,
- /*   440 */   203,   79,   88,  214,  215,   79,   79,   79,  234,   79,
- /*   450 */    79,   95,   95,   79,   79,   79,   79,   95,    9,  120,
- /*   460 */     3,    4,   79,   95,    1,   95,   95,    3,    4,   95,
- /*   470 */    95,   95,   95,   79,  130,    3,    4,   79,   95,   79,
- /*   480 */   142,   78,  144,  117,  117,  142,  261,  144,  142,   95,
- /*   490 */   144,  134,  136,   95,  270,   95,   33,    3,    4,   74,
- /*   500 */    75,  142,  142,  144,  144,  142,  261,  144,  232,  261,
- /*   510 */   194,  261,  261,  244,  111,  261,  261,  261,  261,  261,
- /*   520 */   242,  261,  240,  261,  244,  261,  261,  261,  232,  244,
- /*   530 */   232,  232,  232,  232,  232,  194,  194,  260,  246,  194,
- /*   540 */    56,  270,  194,  194,  194,  240,  240,  194,  240,  194,
- /*   550 */   257,  265,  265,  265,  247,  194,  265,  254,  194,  194,
- /*   560 */   256,  251,  121,  114,  255,  196,  194,  194,  253,  250,
- /*   570 */   252,  126,  194,  194,  194,  194,  194,  133,  194,  194,
- /*   580 */   194,  194,  194,  194,  194,  194,  194,  194,  135,  194,
- /*   590 */   194,  194,  132,  194,  128,  194,  194,  124,  194,  194,
- /*   600 */   194,  194,  194,  194,  194,  194,  194,  194,  194,  194,
- /*   610 */   194,  194,  194,  194,  194,  194,  194,  194,  194,  131,
- /*   620 */   194,  194,  194,  194,  194,  194,  194,  194,  194,  194,
- /*   630 */   194,  194,  194,  125,  127,  196,  196,  137,  196,  196,
- /*   640 */    87,   94,   93,  196,  196,   47,  196,   90,   92,   91,
- /*   650 */   196,  196,   51,   89,   80,  204,  204,  201,    3,  150,
- /*   660 */     3,    3,  150,    3,    3,   98,  196,   97,  139,  207,
- /*   670 */   211,  213,  196,  212,  197,  210,  208,  206,  209,  197,
- /*   680 */   197,  196,  215,  196,  198,  117,  197,  196,  196,  112,
- /*   690 */    78,   78,  202,   79,   95,  249,   79,   95,   78,   95,
- /*   700 */    79,   78,    1,   79,   78,   95,   79,   78,   78,  129,
- /*   710 */    95,  129,   78,   78,   78,  112,   74,   85,  113,   66,
- /*   720 */     3,   84,    3,   85,   84,    5,    3,    3,    3,    3,
- /*   730 */     3,    3,    3,   81,   20,   55,   74,  144,   82,    9,
- /*   740 */   144,   82,   78,   10,   79,  114,   78,   10,    3,   95,
- /*   750 */   144,  144,    3,   79,    3,    3,    3,    3,    3,    3,
- /*   760 */     3,    3,    3,    3,    3,    3,    3,    3,   95,   81,
- /*   770 */     0,   56,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   780 */    15,   15,  273,  273,  273,  273,  273,  273,  273,  273,
+ /*    90 */    24,  261,  194,  258,  238,   29,   30,  261,  242,   33,
+ /*   100 */    34,   35,  272,    7,    8,  236,   10,   11,  272,   79,
+ /*   110 */    14,   15,   16,   17,   78,   19,   20,   21,   22,   23,
+ /*   120 */    24,  267,    1,  269,   74,   29,   30,  194,   80,   33,
+ /*   130 */    34,   35,  194,  240,    8,  237,   10,   11,   88,  241,
+ /*   140 */    14,   15,   16,   17,  194,   19,   20,   21,   22,   23,
+ /*   150 */    24,  258,  116,  203,  118,   29,   30,   78,  194,   33,
+ /*   160 */    34,   35,   41,   42,   43,   44,   45,   46,   47,   48,
+ /*   170 */    49,   50,   51,   52,   53,   54,   55,   63,   57,   10,
+ /*   180 */    11,  199,  240,   14,   15,   16,   17,  205,   19,   20,
+ /*   190 */    21,   22,   23,   24,   88,  116,  263,  264,   29,   30,
+ /*   200 */   258,  237,   33,   34,   35,  241,  142,  269,  144,  271,
+ /*   210 */    96,   97,   98,   99,  100,  101,  102,  103,  104,  105,
+ /*   220 */   106,  107,  108,  109,  110,  216,  217,  218,  219,  220,
+ /*   230 */   221,  222,  223,  224,  225,  226,  227,  228,  229,  230,
+ /*   240 */   231,  139,   78,   40,   21,   22,   23,   24,   84,  261,
+ /*   250 */   148,  149,   29,   30,  122,  123,   33,   34,   35,    1,
+ /*   260 */    57,  248,    1,    2,    3,    4,    5,   64,    2,    3,
+ /*   270 */     4,    5,    3,   70,   71,   72,   73,  113,  194,  266,
+ /*   280 */    77,   78,    1,    2,    3,    4,    5,  203,  201,  261,
+ /*   290 */    29,   30,   64,  194,   33,   29,   30,    2,    3,    4,
+ /*   300 */     5,  261,  194,  194,   58,   59,   60,  194,  261,   64,
+ /*   310 */    29,   30,   66,   67,   68,   69,  203,  194,  194,  116,
+ /*   320 */   233,  234,  235,  236,   29,   30,   58,   59,   60,   33,
+ /*   330 */    34,   35,   86,   65,   66,   67,   68,   69,   80,   78,
+ /*   340 */   241,  138,    1,  140,   96,  237,   98,   99,  239,  241,
+ /*   350 */   147,  103,   33,    3,    4,  107,  194,  109,  110,   78,
+ /*   360 */   237,  237,   29,   30,  241,  241,   33,   34,   35,  141,
+ /*   370 */   194,  143,  194,  145,  146,  114,  115,  194,  194,  194,
+ /*   380 */   114,  115,  121,   58,   59,   60,  141,  194,  143,   72,
+ /*   390 */   145,  146,   67,   68,   69,  114,  115,    3,    4,  237,
+ /*   400 */   194,   76,  121,  241,    1,   61,   62,   63,   95,  114,
+ /*   410 */   115,   79,  199,  237,  199,  237,   79,  241,  205,  241,
+ /*   420 */   205,  237,  237,   95,   83,  241,  241,   58,   59,   60,
+ /*   430 */   237,  214,  215,  120,  241,   79,   33,   79,  119,   79,
+ /*   440 */    79,   95,   79,   79,   79,   79,    9,  130,   78,  117,
+ /*   450 */   261,   95,  269,   95,  117,   95,   95,   79,   95,   95,
+ /*   460 */    95,   95,    3,    4,  136,    3,    4,   79,   79,   56,
+ /*   470 */    79,  121,  142,   95,  144,  269,  142,  142,  144,  144,
+ /*   480 */   134,  261,  112,   95,   95,   78,   95,    3,    4,   74,
+ /*   490 */    75,   78,    3,    4,  142,  142,  144,  144,  261,  261,
+ /*   500 */   261,  261,  261,  261,  261,  261,  244,  242,  261,  232,
+ /*   510 */   261,  261,  261,  261,  261,  121,  261,  261,  111,  244,
+ /*   520 */   244,  232,  240,  232,  232,  232,  232,  260,  240,  232,
+ /*   530 */   240,  246,  194,  270,  270,   56,  194,  121,  240,  196,
+ /*   540 */   257,  194,  194,  194,  265,  265,  135,  196,  194,  194,
+ /*   550 */   133,  114,  265,  194,  128,  132,  256,  255,  196,  254,
+ /*   560 */   131,  194,  194,  253,  265,  126,  194,  196,  252,  196,
+ /*   570 */   125,  251,  124,  250,  127,  249,  247,  137,  196,  194,
+ /*   580 */   194,   87,   94,  196,  194,  204,   93,  194,  196,  194,
+ /*   590 */   194,  194,  194,  213,  194,  194,  194,   47,   90,  194,
+ /*   600 */   194,   92,  194,  204,  194,  201,  194,   51,  194,   91,
+ /*   610 */    89,   80,  194,  194,  194,    3,  194,  196,  194,  194,
+ /*   620 */   211,  194,  194,    3,  194,    3,  194,  196,  194,    3,
+ /*   630 */     3,   98,   97,  117,  112,   78,   78,  194,  194,   79,
+ /*   640 */    95,   95,  207,  194,  194,  212,  210,  209,  206,  208,
+ /*   650 */   194,  194,  194,  202,  194,  194,  150,  194,  194,  194,
+ /*   660 */   150,  215,  196,  196,  194,  194,  194,  194,  194,  194,
+ /*   670 */   194,  139,  194,   79,  197,  194,   78,  197,  196,   79,
+ /*   680 */   197,  196,   78,  197,  194,  194,  194,   79,   95,  194,
+ /*   690 */   194,   78,  194,  196,  194,  196,  194,  194,   79,  198,
+ /*   700 */     1,   78,   78,  129,   95,   95,  129,   78,   78,  112,
+ /*   710 */    78,   74,  113,   85,   66,   84,    3,    3,   85,   84,
+ /*   720 */     5,    3,    3,    3,    3,    3,    3,    3,   81,   74,
+ /*   730 */    78,   82,   82,   79,    9,  114,   78,   20,   55,   10,
+ /*   740 */   144,   95,   10,    3,    3,  144,  144,  144,   79,    3,
+ /*   750 */     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+ /*   760 */     3,    3,    3,   95,   56,   81,    0,  273,  273,  273,
+ /*   770 */   273,  273,  273,  273,  273,   15,   15,  273,  273,  273,
+ /*   780 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
  /*   790 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
  /*   800 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
  /*   810 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
@@ -385,115 +384,114 @@ static const YYCODETYPE yy_lookahead[] = {
  /*   930 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
  /*   940 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
  /*   950 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   960 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   970 */   273,  273,  273,
+ /*   960 */   273,  273,  273,  273,  273,  273,  273,  273,
 };
 #define YY_SHIFT_COUNT    (365)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (770)
+#define YY_SHIFT_MAX      (766)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   190,  118,   25,   42,  247,  268,  268,  358,   38,   38,
- /*    10 */    38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
- /*    20 */    38,    0,   97,  268,  284,  297,  297,   85,   85,   38,
- /*    30 */    38,  199,   38,   12,   38,   38,   38,   38,  354,   42,
- /*    40 */    17,   17,   22,  782,  268,  268,  268,  268,  268,  268,
- /*    50 */   268,  268,  268,  268,  268,  268,  268,  268,  268,  268,
- /*    60 */   268,  268,  268,  268,  268,  268,  284,  297,  284,  284,
- /*    70 */    55,  263,  263,  263,  263,  263,  263,    8,  263,   38,
- /*    80 */    38,   38,  137,   38,   38,   38,   85,   85,   38,   38,
- /*    90 */    38,   38,  344,  344,  339,   85,   38,   38,   38,   38,
- /*   100 */    38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
- /*   110 */    38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
- /*   120 */    38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
- /*   130 */    38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
- /*   140 */    38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
- /*   150 */    38,   38,   38,   38,  484,  484,  484,  441,  441,  441,
- /*   160 */   441,  484,  484,  444,  453,  466,  460,  488,  445,  508,
- /*   170 */   473,  507,  500,  484,  484,  484,  553,  553,   42,  484,
- /*   180 */   484,  547,  549,  598,  557,  556,  601,  558,  564,   22,
- /*   190 */   484,  484,  574,  574,  484,  574,  484,  574,  484,  484,
- /*   200 */   782,  782,   30,   66,   66,   96,   66,  145,  175,  261,
- /*   210 */   261,  261,  261,  261,  261,  249,  273,  289,  340,  340,
- /*   220 */   340,  340,  112,  259,  126,  317,  270,  270,   67,  275,
- /*   230 */   347,  252,  362,  366,  367,  368,  370,  371,  356,  357,
- /*   240 */   374,  375,  376,  377,  457,  464,  383,   94,  394,  398,
- /*   250 */   463,  203,  449,  400,  338,  343,  346,  472,  494,  359,
- /*   260 */   360,  403,  363,  425,  655,  509,  657,  658,  512,  660,
- /*   270 */   661,  567,  570,  529,  568,  577,  612,  614,  613,  599,
- /*   280 */   602,  617,  620,  621,  623,  624,  604,  626,  627,  629,
- /*   290 */   701,  630,  610,  580,  615,  582,  634,  577,  635,  603,
- /*   300 */   636,  605,  642,  632,  637,  653,  717,  638,  640,  719,
- /*   310 */   720,  723,  724,  725,  726,  727,  728,  729,  652,  730,
- /*   320 */   662,  656,  659,  664,  665,  631,  668,  714,  680,  733,
- /*   330 */   593,  596,  654,  654,  654,  654,  737,  606,  607,  654,
- /*   340 */   654,  654,  745,  749,  674,  654,  751,  752,  753,  754,
- /*   350 */   755,  756,  757,  758,  759,  760,  761,  762,  763,  764,
- /*   360 */   673,  688,  765,  766,  715,  770,
+ /*     0 */   203,  114,  248,   48,  261,  281,  281,    1,   55,   55,
+ /*    10 */    55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
+ /*    20 */    55,    0,  121,  281,  266,  295,  295,   79,   79,  132,
+ /*    30 */   258,   50,   48,   55,   55,   55,   55,   55,  106,   55,
+ /*    40 */    55,  106,  269,  777,  281,  281,  281,  281,  281,  281,
+ /*    50 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
+ /*    60 */   281,  281,  281,  281,  281,  281,  266,  295,  266,  266,
+ /*    70 */    36,    2,    2,    2,    2,    2,    2,    2,  319,   79,
+ /*    80 */    79,  317,  317,  313,   79,  341,   55,  479,   55,   55,
+ /*    90 */    55,  479,   55,   55,   55,  479,   55,  416,  416,  416,
+ /*   100 */   416,  479,   55,   55,  479,  417,  411,  426,  423,  429,
+ /*   110 */   439,  445,  448,  447,  440,  479,   55,   55,  479,   55,
+ /*   120 */   479,   55,   55,   55,  494,   55,   55,  494,   55,   55,
+ /*   130 */    55,   48,   55,   55,   55,   55,   55,   55,   55,   55,
+ /*   140 */    55,  479,   55,   55,   55,   55,   55,   55,  479,   55,
+ /*   150 */    55,  488,  493,  550,  508,  509,  556,  518,  521,   55,
+ /*   160 */    55,  269,   55,   55,   55,   55,   55,   55,   55,   55,
+ /*   170 */    55,  479,   55,  479,   55,   55,   55,   55,   55,   55,
+ /*   180 */    55,  531,   55,  531,  479,   55,  531,  479,   55,  531,
+ /*   190 */    55,   55,   55,   55,  479,   55,   55,  479,   55,   55,
+ /*   200 */   777,  777,   30,   66,   66,   96,   66,  126,  169,  223,
+ /*   210 */   223,  223,  223,  223,  223,  246,  268,  325,  333,  333,
+ /*   220 */   333,  333,  228,  245,  102,  164,  296,  296,  350,  394,
+ /*   230 */   344,  369,  356,  332,  337,  358,  360,  361,  328,  346,
+ /*   240 */   363,  364,  365,  366,  459,  462,  378,  370,  388,  389,
+ /*   250 */   403,  413,  437,  391,   64,  330,  334,  484,  489,  335,
+ /*   260 */   352,  407,  353,  415,  612,  506,  620,  622,  510,  626,
+ /*   270 */   627,  533,  535,  532,  516,  522,  557,  560,  558,  545,
+ /*   280 */   546,  594,  598,  600,  604,  608,  593,  613,  619,  623,
+ /*   290 */   699,  624,  609,  574,  610,  577,  629,  522,  630,  597,
+ /*   300 */   632,  599,  637,  628,  631,  648,  713,  633,  635,  714,
+ /*   310 */   715,  718,  719,  720,  721,  722,  723,  724,  647,  725,
+ /*   320 */   655,  649,  650,  652,  654,  621,  658,  717,  683,  729,
+ /*   330 */   596,  601,  646,  646,  646,  646,  732,  602,  603,  646,
+ /*   340 */   646,  646,  740,  741,  669,  646,  746,  747,  748,  749,
+ /*   350 */   750,  751,  752,  753,  754,  755,  756,  757,  758,  759,
+ /*   360 */   668,  684,  760,  761,  708,  766,
 };
 #define YY_REDUCE_COUNT (201)
-#define YY_REDUCE_MIN   (-230)
-#define YY_REDUCE_MAX   (492)
+#define YY_REDUCE_MIN   (-241)
+#define YY_REDUCE_MAX   (503)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -165,   15, -161,  119, -200, -194, -164,  -80,  130,  -58,
- /*    10 */   -67,  135,  140,  149,  150,  151,  156,  166,  184,  185,
- /*    20 */   186, -168, -192, -230,  -86,  -35,  176,  177,  179, -190,
- /*    30 */   -57,  158,  125,   28,  191,  226,  237,  172,  -12,  214,
- /*    40 */   233,  234,  229, -227, -213, -205,  -84,  -79,   75,   90,
- /*    50 */   123,  225,  245,  248,  250,  251,  254,  255,  256,  257,
- /*    60 */   258,  260,  262,  264,  265,  266,  269,  278,  280,  285,
- /*    70 */   282,  276,  296,  298,  299,  300,  301,  316,  302,  341,
- /*    80 */   342,  345,  277,  348,  349,  350,  305,  306,  353,  355,
- /*    90 */   361,  364,  224,  271,  292,  308,  365,  372,  373,  378,
- /*   100 */   379,  380,  381,  382,  384,  385,  386,  387,  388,  389,
- /*   110 */   390,  391,  392,  393,  395,  396,  397,  399,  401,  402,
- /*   120 */   404,  405,  406,  407,  408,  409,  410,  411,  412,  413,
- /*   130 */   414,  415,  416,  417,  418,  419,  420,  421,  422,  423,
- /*   140 */   424,  426,  427,  428,  429,  430,  431,  432,  433,  434,
- /*   150 */   435,  436,  437,  438,  369,  439,  440,  286,  287,  288,
- /*   160 */   291,  442,  443,  293,  304,  309,  303,  315,  318,  310,
- /*   170 */   319,  446,  307,  447,  448,  450,  451,  452,  456,  454,
- /*   180 */   455,  458,  461,  459,  462,  465,  468,  469,  471,  467,
- /*   190 */   470,  476,  477,  482,  485,  483,  487,  489,  491,  492,
- /*   200 */   490,  486,
+ /*     0 */  -165,    9, -161,   87, -200, -194, -164,  -67, -102,  -62,
+ /*    10 */  -146,  -36,  108,  123,  124,  162,  176,  178,  184,  185,
+ /*    20 */   193, -191, -182, -170, -218, -199, -144, -107,  -58,   13,
+ /*    30 */  -131,  -18, -192,  183,  206,  109,  -50,   84,  213,  113,
+ /*    40 */    99,  215,  217, -241,  -12,   28,   40,   47,  189,  220,
+ /*    50 */   237,  238,  239,  240,  241,  242,  243,  244,  247,  249,
+ /*    60 */   250,  251,  252,  253,  255,  256,  262,  265,  275,  276,
+ /*    70 */   282,  277,  289,  291,  292,  293,  294,  297,  267,  288,
+ /*    80 */   290,  263,  264,  285,  298,  338,  342,  343,  347,  348,
+ /*    90 */   349,  351,  354,  355,  359,  362,  367,  279,  280,  287,
+ /*   100 */   299,  371,  368,  372,  373,  283,  300,  302,  305,  310,
+ /*   110 */   316,  320,  323,  326,  329,  382,  385,  386,  387,  390,
+ /*   120 */   392,  393,  395,  396,  381,  397,  398,  399,  400,  401,
+ /*   130 */   402,  404,  405,  406,  408,  410,  412,  414,  418,  419,
+ /*   140 */   420,  421,  422,  424,  425,  427,  428,  430,  431,  432,
+ /*   150 */   434,  380,  433,  409,  435,  436,  441,  438,  442,  443,
+ /*   160 */   444,  446,  449,  450,  456,  457,  458,  460,  461,  463,
+ /*   170 */   464,  466,  465,  467,  470,  471,  472,  473,  474,  475,
+ /*   180 */   476,  477,  478,  480,  482,  481,  483,  485,  490,  486,
+ /*   190 */   491,  492,  495,  496,  497,  498,  500,  499,  502,  503,
+ /*   200 */   451,  501,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   890,  953,  940,  949, 1174, 1174, 1174,  890,  890,  890,
- /*    10 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*    20 */   890, 1081,  910, 1174,  890,  890,  890,  890,  890,  890,
- /*    30 */   890, 1096,  890,  949,  890,  890,  890,  890,  959,  949,
- /*    40 */   959,  959,  890, 1076,  890,  890,  890,  890,  890,  890,
- /*    50 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*    60 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*    70 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*    80 */   890,  890, 1083, 1089, 1086,  890,  890,  890, 1091,  890,
- /*    90 */   890,  890, 1115, 1115, 1074,  890,  890,  890,  890,  890,
- /*   100 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   110 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   120 */   890,  890,  890,  890,  890,  890,  890,  938,  890,  936,
- /*   130 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   140 */   890,  890,  890,  890,  890,  890,  921,  890,  890,  890,
- /*   150 */   890,  890,  890,  908,  912,  912,  912,  890,  890,  890,
- /*   160 */   890,  912,  912, 1122, 1126, 1108, 1120, 1116, 1103, 1101,
- /*   170 */  1099, 1107, 1130,  912,  912,  912,  957,  957,  949,  912,
- /*   180 */   912,  975,  973,  971,  963,  969,  965,  967,  961,  890,
- /*   190 */   912,  912,  947,  947,  912,  947,  912,  947,  912,  912,
- /*   200 */   997, 1014,  890, 1131, 1121,  890, 1173, 1161, 1160, 1169,
- /*   210 */  1168, 1167, 1159, 1158, 1157,  890,  890,  890, 1153, 1156,
- /*   220 */  1155, 1154,  890,  890,  890,  890, 1163, 1162,  890,  890,
- /*   230 */   890,  890,  890,  890,  890,  890,  890,  890, 1127, 1123,
- /*   240 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   250 */   890, 1133,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   260 */   890, 1022,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   270 */   890,  890,  890,  890, 1073,  890,  890,  890,  890, 1085,
- /*   280 */  1084,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   290 */   890,  890, 1117,  890, 1109,  890,  890, 1034,  890,  890,
- /*   300 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   310 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   320 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   330 */   890,  890, 1192, 1187, 1188, 1185,  890,  890,  890, 1184,
- /*   340 */  1179, 1180,  890,  890,  890, 1177,  890,  890,  890,  890,
- /*   350 */   890,  890,  890,  890,  890,  890,  890,  890,  890,  890,
- /*   360 */   981,  890,  919,  917,  890,  890,
+ /*     0 */   888,  950,  938,  946, 1171, 1171, 1171,  888,  888,  888,
+ /*    10 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*    20 */   888, 1078,  908, 1171,  888,  888,  888,  888,  888, 1093,
+ /*    30 */  1028,  956,  946,  888,  888,  888,  888,  888,  956,  888,
+ /*    40 */   888,  956,  888, 1073,  888,  888,  888,  888,  888,  888,
+ /*    50 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*    60 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*    70 */   888,  888,  888,  888,  888,  888,  888,  888, 1080,  888,
+ /*    80 */   888, 1112, 1112, 1071,  888,  888,  888,  910,  888,  888,
+ /*    90 */  1086,  910, 1083,  888, 1088,  910,  888,  888,  888,  888,
+ /*   100 */   888,  910,  888,  888,  910, 1119, 1123, 1105, 1117, 1113,
+ /*   110 */  1100, 1098, 1096, 1104, 1127,  910,  888,  888,  910,  888,
+ /*   120 */   910,  888,  888,  888,  954,  888,  888,  954,  888,  888,
+ /*   130 */   888,  946,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   140 */   888,  910,  888,  888,  888,  888,  888,  888,  910,  888,
+ /*   150 */   888,  972,  970,  968,  960,  966,  962,  964,  958,  888,
+ /*   160 */   888,  888,  888,  936,  888,  934,  888,  888,  888,  888,
+ /*   170 */   888,  910,  888,  910,  888,  888,  888,  888,  888,  888,
+ /*   180 */   888,  944,  888,  944,  910,  888,  944,  910,  888,  944,
+ /*   190 */   919,  888,  888,  888,  910,  888,  888,  910,  888,  906,
+ /*   200 */   994, 1011,  888, 1128, 1118,  888, 1170, 1158, 1157, 1166,
+ /*   210 */  1165, 1164, 1156, 1155, 1154,  888,  888,  888, 1150, 1153,
+ /*   220 */  1152, 1151,  888,  888,  888,  888, 1160, 1159,  888,  888,
+ /*   230 */   888,  888,  888,  888,  888,  888,  888,  888, 1124, 1120,
+ /*   240 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   250 */   888, 1130,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   260 */   888, 1019,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   270 */   888,  888,  888,  888, 1070,  888,  888,  888,  888, 1082,
+ /*   280 */  1081,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   290 */   888,  888, 1114,  888, 1106,  888,  888, 1031,  888,  888,
+ /*   300 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   310 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   320 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   330 */   888,  888, 1189, 1184, 1185, 1182,  888,  888,  888, 1181,
+ /*   340 */  1176, 1177,  888,  888,  888, 1174,  888,  888,  888,  888,
+ /*   350 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
+ /*   360 */   978,  888,  917,  915,  888,  888,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -1122,257 +1120,256 @@ static const char *const yyRuleName[] = {
  /*  49 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
  /*  50 */ "cmd ::= COMPACT VNODES IN LP exprlist RP",
  /*  51 */ "ids ::= ID",
- /*  52 */ "ids ::= STRING",
- /*  53 */ "ifexists ::= IF EXISTS",
- /*  54 */ "ifexists ::=",
- /*  55 */ "ifnotexists ::= IF NOT EXISTS",
- /*  56 */ "ifnotexists ::=",
- /*  57 */ "cmd ::= CREATE DNODE ids PORT ids",
- /*  58 */ "cmd ::= CREATE DNODE IPTOKEN PORT ids",
- /*  59 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
- /*  60 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
- /*  61 */ "cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
- /*  62 */ "cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
- /*  63 */ "cmd ::= CREATE USER ids PASS ids",
- /*  64 */ "bufsize ::=",
- /*  65 */ "bufsize ::= BUFSIZE INTEGER",
- /*  66 */ "pps ::=",
- /*  67 */ "pps ::= PPS INTEGER",
- /*  68 */ "tseries ::=",
- /*  69 */ "tseries ::= TSERIES INTEGER",
- /*  70 */ "dbs ::=",
- /*  71 */ "dbs ::= DBS INTEGER",
- /*  72 */ "streams ::=",
- /*  73 */ "streams ::= STREAMS INTEGER",
- /*  74 */ "storage ::=",
- /*  75 */ "storage ::= STORAGE INTEGER",
- /*  76 */ "qtime ::=",
- /*  77 */ "qtime ::= QTIME INTEGER",
- /*  78 */ "users ::=",
- /*  79 */ "users ::= USERS INTEGER",
- /*  80 */ "conns ::=",
- /*  81 */ "conns ::= CONNS INTEGER",
- /*  82 */ "state ::=",
- /*  83 */ "state ::= STATE ids",
- /*  84 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
- /*  85 */ "intitemlist ::= intitemlist COMMA intitem",
- /*  86 */ "intitemlist ::= intitem",
- /*  87 */ "intitem ::= INTEGER",
- /*  88 */ "keep ::= KEEP intitemlist",
- /*  89 */ "cache ::= CACHE INTEGER",
- /*  90 */ "replica ::= REPLICA INTEGER",
- /*  91 */ "quorum ::= QUORUM INTEGER",
- /*  92 */ "days ::= DAYS INTEGER",
- /*  93 */ "minrows ::= MINROWS INTEGER",
- /*  94 */ "maxrows ::= MAXROWS INTEGER",
- /*  95 */ "blocks ::= BLOCKS INTEGER",
- /*  96 */ "ctime ::= CTIME INTEGER",
- /*  97 */ "wal ::= WAL INTEGER",
- /*  98 */ "fsync ::= FSYNC INTEGER",
- /*  99 */ "comp ::= COMP INTEGER",
- /* 100 */ "prec ::= PRECISION STRING",
- /* 101 */ "update ::= UPDATE INTEGER",
- /* 102 */ "cachelast ::= CACHELAST INTEGER",
- /* 103 */ "vgroups ::= VGROUPS INTEGER",
- /* 104 */ "db_optr ::=",
- /* 105 */ "db_optr ::= db_optr cache",
- /* 106 */ "db_optr ::= db_optr replica",
- /* 107 */ "db_optr ::= db_optr quorum",
- /* 108 */ "db_optr ::= db_optr days",
- /* 109 */ "db_optr ::= db_optr minrows",
- /* 110 */ "db_optr ::= db_optr maxrows",
- /* 111 */ "db_optr ::= db_optr blocks",
- /* 112 */ "db_optr ::= db_optr ctime",
- /* 113 */ "db_optr ::= db_optr wal",
- /* 114 */ "db_optr ::= db_optr fsync",
- /* 115 */ "db_optr ::= db_optr comp",
- /* 116 */ "db_optr ::= db_optr prec",
- /* 117 */ "db_optr ::= db_optr keep",
- /* 118 */ "db_optr ::= db_optr update",
- /* 119 */ "db_optr ::= db_optr cachelast",
- /* 120 */ "db_optr ::= db_optr vgroups",
- /* 121 */ "alter_db_optr ::=",
- /* 122 */ "alter_db_optr ::= alter_db_optr replica",
- /* 123 */ "alter_db_optr ::= alter_db_optr quorum",
- /* 124 */ "alter_db_optr ::= alter_db_optr keep",
- /* 125 */ "alter_db_optr ::= alter_db_optr blocks",
- /* 126 */ "alter_db_optr ::= alter_db_optr comp",
- /* 127 */ "alter_db_optr ::= alter_db_optr update",
- /* 128 */ "alter_db_optr ::= alter_db_optr cachelast",
- /* 129 */ "typename ::= ids",
- /* 130 */ "typename ::= ids LP signed RP",
- /* 131 */ "typename ::= ids UNSIGNED",
- /* 132 */ "signed ::= INTEGER",
- /* 133 */ "signed ::= PLUS INTEGER",
- /* 134 */ "signed ::= MINUS INTEGER",
- /* 135 */ "cmd ::= CREATE TABLE create_table_args",
- /* 136 */ "cmd ::= CREATE TABLE create_stable_args",
- /* 137 */ "cmd ::= CREATE STABLE create_stable_args",
- /* 138 */ "cmd ::= CREATE TABLE create_table_list",
- /* 139 */ "create_table_list ::= create_from_stable",
- /* 140 */ "create_table_list ::= create_table_list create_from_stable",
- /* 141 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
- /* 142 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
- /* 143 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist1 RP",
- /* 144 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist1 RP",
- /* 145 */ "tagNamelist ::= tagNamelist COMMA ids",
- /* 146 */ "tagNamelist ::= ids",
- /* 147 */ "create_table_args ::= ifnotexists ids cpxName AS select",
- /* 148 */ "columnlist ::= columnlist COMMA column",
- /* 149 */ "columnlist ::= column",
- /* 150 */ "column ::= ids typename",
- /* 151 */ "tagitemlist1 ::= tagitemlist1 COMMA tagitem1",
- /* 152 */ "tagitemlist1 ::= tagitem1",
- /* 153 */ "tagitem1 ::= MINUS INTEGER",
- /* 154 */ "tagitem1 ::= MINUS FLOAT",
- /* 155 */ "tagitem1 ::= PLUS INTEGER",
- /* 156 */ "tagitem1 ::= PLUS FLOAT",
- /* 157 */ "tagitem1 ::= INTEGER",
- /* 158 */ "tagitem1 ::= FLOAT",
- /* 159 */ "tagitem1 ::= STRING",
- /* 160 */ "tagitem1 ::= BOOL",
- /* 161 */ "tagitem1 ::= NULL",
- /* 162 */ "tagitem1 ::= NOW",
- /* 163 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 164 */ "tagitemlist ::= tagitem",
- /* 165 */ "tagitem ::= INTEGER",
- /* 166 */ "tagitem ::= FLOAT",
- /* 167 */ "tagitem ::= STRING",
- /* 168 */ "tagitem ::= BOOL",
- /* 169 */ "tagitem ::= NULL",
- /* 170 */ "tagitem ::= NOW",
- /* 171 */ "tagitem ::= MINUS INTEGER",
- /* 172 */ "tagitem ::= MINUS FLOAT",
- /* 173 */ "tagitem ::= PLUS INTEGER",
- /* 174 */ "tagitem ::= PLUS FLOAT",
- /* 175 */ "select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt",
- /* 176 */ "select ::= LP select RP",
- /* 177 */ "union ::= select",
- /* 178 */ "union ::= union UNION ALL select",
- /* 179 */ "union ::= union UNION select",
- /* 180 */ "cmd ::= union",
- /* 181 */ "select ::= SELECT selcollist",
- /* 182 */ "sclp ::= selcollist COMMA",
- /* 183 */ "sclp ::=",
- /* 184 */ "selcollist ::= sclp distinct expr as",
- /* 185 */ "selcollist ::= sclp STAR",
- /* 186 */ "as ::= AS ids",
- /* 187 */ "as ::= ids",
- /* 188 */ "as ::=",
- /* 189 */ "distinct ::= DISTINCT",
- /* 190 */ "distinct ::=",
- /* 191 */ "from ::= FROM tablelist",
- /* 192 */ "from ::= FROM sub",
- /* 193 */ "sub ::= LP union RP",
- /* 194 */ "sub ::= LP union RP ids",
- /* 195 */ "sub ::= sub COMMA LP union RP ids",
- /* 196 */ "tablelist ::= ids cpxName",
- /* 197 */ "tablelist ::= ids cpxName ids",
- /* 198 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 199 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 200 */ "tmvar ::= VARIABLE",
- /* 201 */ "interval_option ::= intervalKey LP tmvar RP",
- /* 202 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP",
- /* 203 */ "interval_option ::=",
- /* 204 */ "intervalKey ::= INTERVAL",
- /* 205 */ "intervalKey ::= EVERY",
- /* 206 */ "session_option ::=",
- /* 207 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
- /* 208 */ "windowstate_option ::=",
- /* 209 */ "windowstate_option ::= STATE_WINDOW LP ids RP",
- /* 210 */ "fill_opt ::=",
- /* 211 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 212 */ "fill_opt ::= FILL LP ID RP",
- /* 213 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 214 */ "sliding_opt ::=",
- /* 215 */ "orderby_opt ::=",
- /* 216 */ "orderby_opt ::= ORDER BY sortlist",
- /* 217 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 218 */ "sortlist ::= item sortorder",
- /* 219 */ "item ::= ids cpxName",
- /* 220 */ "sortorder ::= ASC",
- /* 221 */ "sortorder ::= DESC",
- /* 222 */ "sortorder ::=",
- /* 223 */ "groupby_opt ::=",
- /* 224 */ "groupby_opt ::= GROUP BY grouplist",
- /* 225 */ "grouplist ::= grouplist COMMA item",
- /* 226 */ "grouplist ::= item",
- /* 227 */ "having_opt ::=",
- /* 228 */ "having_opt ::= HAVING expr",
- /* 229 */ "limit_opt ::=",
- /* 230 */ "limit_opt ::= LIMIT signed",
- /* 231 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 232 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 233 */ "slimit_opt ::=",
- /* 234 */ "slimit_opt ::= SLIMIT signed",
- /* 235 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 236 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 237 */ "where_opt ::=",
- /* 238 */ "where_opt ::= WHERE expr",
- /* 239 */ "expr ::= LP expr RP",
- /* 240 */ "expr ::= ID",
- /* 241 */ "expr ::= ID DOT ID",
- /* 242 */ "expr ::= ID DOT STAR",
- /* 243 */ "expr ::= INTEGER",
- /* 244 */ "expr ::= MINUS INTEGER",
- /* 245 */ "expr ::= PLUS INTEGER",
- /* 246 */ "expr ::= FLOAT",
- /* 247 */ "expr ::= MINUS FLOAT",
- /* 248 */ "expr ::= PLUS FLOAT",
- /* 249 */ "expr ::= STRING",
- /* 250 */ "expr ::= NOW",
- /* 251 */ "expr ::= VARIABLE",
- /* 252 */ "expr ::= PLUS VARIABLE",
- /* 253 */ "expr ::= MINUS VARIABLE",
- /* 254 */ "expr ::= BOOL",
- /* 255 */ "expr ::= NULL",
- /* 256 */ "expr ::= ID LP exprlist RP",
- /* 257 */ "expr ::= ID LP STAR RP",
- /* 258 */ "expr ::= expr IS NULL",
- /* 259 */ "expr ::= expr IS NOT NULL",
- /* 260 */ "expr ::= expr LT expr",
- /* 261 */ "expr ::= expr GT expr",
- /* 262 */ "expr ::= expr LE expr",
- /* 263 */ "expr ::= expr GE expr",
- /* 264 */ "expr ::= expr NE expr",
- /* 265 */ "expr ::= expr EQ expr",
- /* 266 */ "expr ::= expr BETWEEN expr AND expr",
- /* 267 */ "expr ::= expr AND expr",
- /* 268 */ "expr ::= expr OR expr",
- /* 269 */ "expr ::= expr PLUS expr",
- /* 270 */ "expr ::= expr MINUS expr",
- /* 271 */ "expr ::= expr STAR expr",
- /* 272 */ "expr ::= expr SLASH expr",
- /* 273 */ "expr ::= expr REM expr",
- /* 274 */ "expr ::= expr LIKE expr",
- /* 275 */ "expr ::= expr MATCH expr",
- /* 276 */ "expr ::= expr NMATCH expr",
- /* 277 */ "expr ::= expr IN LP exprlist RP",
- /* 278 */ "exprlist ::= exprlist COMMA expritem",
- /* 279 */ "exprlist ::= expritem",
- /* 280 */ "expritem ::= expr",
- /* 281 */ "expritem ::=",
- /* 282 */ "cmd ::= RESET QUERY CACHE",
- /* 283 */ "cmd ::= SYNCDB ids REPLICA",
- /* 284 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 285 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 286 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
- /* 287 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 288 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 289 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 290 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 291 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
- /* 292 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
- /* 293 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
- /* 294 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
- /* 295 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
- /* 296 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
- /* 297 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
- /* 298 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
- /* 299 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
- /* 300 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 301 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 302 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /*  52 */ "ifexists ::= IF EXISTS",
+ /*  53 */ "ifexists ::=",
+ /*  54 */ "ifnotexists ::= IF NOT EXISTS",
+ /*  55 */ "ifnotexists ::=",
+ /*  56 */ "cmd ::= CREATE DNODE ids PORT ids",
+ /*  57 */ "cmd ::= CREATE DNODE IPTOKEN PORT ids",
+ /*  58 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
+ /*  59 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
+ /*  60 */ "cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
+ /*  61 */ "cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize",
+ /*  62 */ "cmd ::= CREATE USER ids PASS ids",
+ /*  63 */ "bufsize ::=",
+ /*  64 */ "bufsize ::= BUFSIZE INTEGER",
+ /*  65 */ "pps ::=",
+ /*  66 */ "pps ::= PPS INTEGER",
+ /*  67 */ "tseries ::=",
+ /*  68 */ "tseries ::= TSERIES INTEGER",
+ /*  69 */ "dbs ::=",
+ /*  70 */ "dbs ::= DBS INTEGER",
+ /*  71 */ "streams ::=",
+ /*  72 */ "streams ::= STREAMS INTEGER",
+ /*  73 */ "storage ::=",
+ /*  74 */ "storage ::= STORAGE INTEGER",
+ /*  75 */ "qtime ::=",
+ /*  76 */ "qtime ::= QTIME INTEGER",
+ /*  77 */ "users ::=",
+ /*  78 */ "users ::= USERS INTEGER",
+ /*  79 */ "conns ::=",
+ /*  80 */ "conns ::= CONNS INTEGER",
+ /*  81 */ "state ::=",
+ /*  82 */ "state ::= STATE ids",
+ /*  83 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
+ /*  84 */ "intitemlist ::= intitemlist COMMA intitem",
+ /*  85 */ "intitemlist ::= intitem",
+ /*  86 */ "intitem ::= INTEGER",
+ /*  87 */ "keep ::= KEEP intitemlist",
+ /*  88 */ "cache ::= CACHE INTEGER",
+ /*  89 */ "replica ::= REPLICA INTEGER",
+ /*  90 */ "quorum ::= QUORUM INTEGER",
+ /*  91 */ "days ::= DAYS INTEGER",
+ /*  92 */ "minrows ::= MINROWS INTEGER",
+ /*  93 */ "maxrows ::= MAXROWS INTEGER",
+ /*  94 */ "blocks ::= BLOCKS INTEGER",
+ /*  95 */ "ctime ::= CTIME INTEGER",
+ /*  96 */ "wal ::= WAL INTEGER",
+ /*  97 */ "fsync ::= FSYNC INTEGER",
+ /*  98 */ "comp ::= COMP INTEGER",
+ /*  99 */ "prec ::= PRECISION STRING",
+ /* 100 */ "update ::= UPDATE INTEGER",
+ /* 101 */ "cachelast ::= CACHELAST INTEGER",
+ /* 102 */ "vgroups ::= VGROUPS INTEGER",
+ /* 103 */ "db_optr ::=",
+ /* 104 */ "db_optr ::= db_optr cache",
+ /* 105 */ "db_optr ::= db_optr replica",
+ /* 106 */ "db_optr ::= db_optr quorum",
+ /* 107 */ "db_optr ::= db_optr days",
+ /* 108 */ "db_optr ::= db_optr minrows",
+ /* 109 */ "db_optr ::= db_optr maxrows",
+ /* 110 */ "db_optr ::= db_optr blocks",
+ /* 111 */ "db_optr ::= db_optr ctime",
+ /* 112 */ "db_optr ::= db_optr wal",
+ /* 113 */ "db_optr ::= db_optr fsync",
+ /* 114 */ "db_optr ::= db_optr comp",
+ /* 115 */ "db_optr ::= db_optr prec",
+ /* 116 */ "db_optr ::= db_optr keep",
+ /* 117 */ "db_optr ::= db_optr update",
+ /* 118 */ "db_optr ::= db_optr cachelast",
+ /* 119 */ "db_optr ::= db_optr vgroups",
+ /* 120 */ "alter_db_optr ::=",
+ /* 121 */ "alter_db_optr ::= alter_db_optr replica",
+ /* 122 */ "alter_db_optr ::= alter_db_optr quorum",
+ /* 123 */ "alter_db_optr ::= alter_db_optr keep",
+ /* 124 */ "alter_db_optr ::= alter_db_optr blocks",
+ /* 125 */ "alter_db_optr ::= alter_db_optr comp",
+ /* 126 */ "alter_db_optr ::= alter_db_optr update",
+ /* 127 */ "alter_db_optr ::= alter_db_optr cachelast",
+ /* 128 */ "typename ::= ids",
+ /* 129 */ "typename ::= ids LP signed RP",
+ /* 130 */ "typename ::= ids UNSIGNED",
+ /* 131 */ "signed ::= INTEGER",
+ /* 132 */ "signed ::= PLUS INTEGER",
+ /* 133 */ "signed ::= MINUS INTEGER",
+ /* 134 */ "cmd ::= CREATE TABLE create_table_args",
+ /* 135 */ "cmd ::= CREATE TABLE create_stable_args",
+ /* 136 */ "cmd ::= CREATE STABLE create_stable_args",
+ /* 137 */ "cmd ::= CREATE TABLE create_table_list",
+ /* 138 */ "create_table_list ::= create_from_stable",
+ /* 139 */ "create_table_list ::= create_table_list create_from_stable",
+ /* 140 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
+ /* 141 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
+ /* 142 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist1 RP",
+ /* 143 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist1 RP",
+ /* 144 */ "tagNamelist ::= tagNamelist COMMA ids",
+ /* 145 */ "tagNamelist ::= ids",
+ /* 146 */ "create_table_args ::= ifnotexists ids cpxName AS select",
+ /* 147 */ "columnlist ::= columnlist COMMA column",
+ /* 148 */ "columnlist ::= column",
+ /* 149 */ "column ::= ids typename",
+ /* 150 */ "tagitemlist1 ::= tagitemlist1 COMMA tagitem1",
+ /* 151 */ "tagitemlist1 ::= tagitem1",
+ /* 152 */ "tagitem1 ::= MINUS INTEGER",
+ /* 153 */ "tagitem1 ::= MINUS FLOAT",
+ /* 154 */ "tagitem1 ::= PLUS INTEGER",
+ /* 155 */ "tagitem1 ::= PLUS FLOAT",
+ /* 156 */ "tagitem1 ::= INTEGER",
+ /* 157 */ "tagitem1 ::= FLOAT",
+ /* 158 */ "tagitem1 ::= STRING",
+ /* 159 */ "tagitem1 ::= BOOL",
+ /* 160 */ "tagitem1 ::= NULL",
+ /* 161 */ "tagitem1 ::= NOW",
+ /* 162 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 163 */ "tagitemlist ::= tagitem",
+ /* 164 */ "tagitem ::= INTEGER",
+ /* 165 */ "tagitem ::= FLOAT",
+ /* 166 */ "tagitem ::= STRING",
+ /* 167 */ "tagitem ::= BOOL",
+ /* 168 */ "tagitem ::= NULL",
+ /* 169 */ "tagitem ::= NOW",
+ /* 170 */ "tagitem ::= MINUS INTEGER",
+ /* 171 */ "tagitem ::= MINUS FLOAT",
+ /* 172 */ "tagitem ::= PLUS INTEGER",
+ /* 173 */ "tagitem ::= PLUS FLOAT",
+ /* 174 */ "select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt",
+ /* 175 */ "select ::= LP select RP",
+ /* 176 */ "union ::= select",
+ /* 177 */ "union ::= union UNION ALL select",
+ /* 178 */ "union ::= union UNION select",
+ /* 179 */ "cmd ::= union",
+ /* 180 */ "select ::= SELECT selcollist",
+ /* 181 */ "sclp ::= selcollist COMMA",
+ /* 182 */ "sclp ::=",
+ /* 183 */ "selcollist ::= sclp distinct expr as",
+ /* 184 */ "selcollist ::= sclp STAR",
+ /* 185 */ "as ::= AS ids",
+ /* 186 */ "as ::= ids",
+ /* 187 */ "as ::=",
+ /* 188 */ "distinct ::= DISTINCT",
+ /* 189 */ "distinct ::=",
+ /* 190 */ "from ::= FROM tablelist",
+ /* 191 */ "from ::= FROM sub",
+ /* 192 */ "sub ::= LP union RP",
+ /* 193 */ "sub ::= LP union RP ids",
+ /* 194 */ "sub ::= sub COMMA LP union RP ids",
+ /* 195 */ "tablelist ::= ids cpxName",
+ /* 196 */ "tablelist ::= ids cpxName ids",
+ /* 197 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 198 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 199 */ "tmvar ::= VARIABLE",
+ /* 200 */ "interval_option ::= intervalKey LP tmvar RP",
+ /* 201 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP",
+ /* 202 */ "interval_option ::=",
+ /* 203 */ "intervalKey ::= INTERVAL",
+ /* 204 */ "intervalKey ::= EVERY",
+ /* 205 */ "session_option ::=",
+ /* 206 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
+ /* 207 */ "windowstate_option ::=",
+ /* 208 */ "windowstate_option ::= STATE_WINDOW LP ids RP",
+ /* 209 */ "fill_opt ::=",
+ /* 210 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 211 */ "fill_opt ::= FILL LP ID RP",
+ /* 212 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 213 */ "sliding_opt ::=",
+ /* 214 */ "orderby_opt ::=",
+ /* 215 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 216 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 217 */ "sortlist ::= item sortorder",
+ /* 218 */ "item ::= ids cpxName",
+ /* 219 */ "sortorder ::= ASC",
+ /* 220 */ "sortorder ::= DESC",
+ /* 221 */ "sortorder ::=",
+ /* 222 */ "groupby_opt ::=",
+ /* 223 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 224 */ "grouplist ::= grouplist COMMA item",
+ /* 225 */ "grouplist ::= item",
+ /* 226 */ "having_opt ::=",
+ /* 227 */ "having_opt ::= HAVING expr",
+ /* 228 */ "limit_opt ::=",
+ /* 229 */ "limit_opt ::= LIMIT signed",
+ /* 230 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 231 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 232 */ "slimit_opt ::=",
+ /* 233 */ "slimit_opt ::= SLIMIT signed",
+ /* 234 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 235 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 236 */ "where_opt ::=",
+ /* 237 */ "where_opt ::= WHERE expr",
+ /* 238 */ "expr ::= LP expr RP",
+ /* 239 */ "expr ::= ID",
+ /* 240 */ "expr ::= ID DOT ID",
+ /* 241 */ "expr ::= ID DOT STAR",
+ /* 242 */ "expr ::= INTEGER",
+ /* 243 */ "expr ::= MINUS INTEGER",
+ /* 244 */ "expr ::= PLUS INTEGER",
+ /* 245 */ "expr ::= FLOAT",
+ /* 246 */ "expr ::= MINUS FLOAT",
+ /* 247 */ "expr ::= PLUS FLOAT",
+ /* 248 */ "expr ::= STRING",
+ /* 249 */ "expr ::= NOW",
+ /* 250 */ "expr ::= VARIABLE",
+ /* 251 */ "expr ::= PLUS VARIABLE",
+ /* 252 */ "expr ::= MINUS VARIABLE",
+ /* 253 */ "expr ::= BOOL",
+ /* 254 */ "expr ::= NULL",
+ /* 255 */ "expr ::= ID LP exprlist RP",
+ /* 256 */ "expr ::= ID LP STAR RP",
+ /* 257 */ "expr ::= expr IS NULL",
+ /* 258 */ "expr ::= expr IS NOT NULL",
+ /* 259 */ "expr ::= expr LT expr",
+ /* 260 */ "expr ::= expr GT expr",
+ /* 261 */ "expr ::= expr LE expr",
+ /* 262 */ "expr ::= expr GE expr",
+ /* 263 */ "expr ::= expr NE expr",
+ /* 264 */ "expr ::= expr EQ expr",
+ /* 265 */ "expr ::= expr BETWEEN expr AND expr",
+ /* 266 */ "expr ::= expr AND expr",
+ /* 267 */ "expr ::= expr OR expr",
+ /* 268 */ "expr ::= expr PLUS expr",
+ /* 269 */ "expr ::= expr MINUS expr",
+ /* 270 */ "expr ::= expr STAR expr",
+ /* 271 */ "expr ::= expr SLASH expr",
+ /* 272 */ "expr ::= expr REM expr",
+ /* 273 */ "expr ::= expr LIKE expr",
+ /* 274 */ "expr ::= expr MATCH expr",
+ /* 275 */ "expr ::= expr NMATCH expr",
+ /* 276 */ "expr ::= expr IN LP exprlist RP",
+ /* 277 */ "exprlist ::= exprlist COMMA expritem",
+ /* 278 */ "exprlist ::= expritem",
+ /* 279 */ "expritem ::= expr",
+ /* 280 */ "expritem ::=",
+ /* 281 */ "cmd ::= RESET QUERY CACHE",
+ /* 282 */ "cmd ::= SYNCDB ids REPLICA",
+ /* 283 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 284 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 285 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 286 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 287 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 288 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 289 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 290 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
+ /* 291 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
+ /* 292 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
+ /* 293 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 294 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
+ /* 295 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
+ /* 296 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
+ /* 297 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 298 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
+ /* 299 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 300 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 301 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1893,257 +1890,256 @@ static const struct {
   {  193,   -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
   {  193,   -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
   {  194,   -1 }, /* (51) ids ::= ID */
-  {  194,   -1 }, /* (52) ids ::= STRING */
-  {  197,   -2 }, /* (53) ifexists ::= IF EXISTS */
-  {  197,    0 }, /* (54) ifexists ::= */
-  {  201,   -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
-  {  201,    0 }, /* (56) ifnotexists ::= */
-  {  193,   -5 }, /* (57) cmd ::= CREATE DNODE ids PORT ids */
-  {  193,   -5 }, /* (58) cmd ::= CREATE DNODE IPTOKEN PORT ids */
-  {  193,   -6 }, /* (59) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  193,   -5 }, /* (60) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  193,   -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-  {  193,   -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-  {  193,   -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
-  {  204,    0 }, /* (64) bufsize ::= */
-  {  204,   -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
-  {  205,    0 }, /* (66) pps ::= */
-  {  205,   -2 }, /* (67) pps ::= PPS INTEGER */
-  {  206,    0 }, /* (68) tseries ::= */
-  {  206,   -2 }, /* (69) tseries ::= TSERIES INTEGER */
-  {  207,    0 }, /* (70) dbs ::= */
-  {  207,   -2 }, /* (71) dbs ::= DBS INTEGER */
-  {  208,    0 }, /* (72) streams ::= */
-  {  208,   -2 }, /* (73) streams ::= STREAMS INTEGER */
-  {  209,    0 }, /* (74) storage ::= */
-  {  209,   -2 }, /* (75) storage ::= STORAGE INTEGER */
-  {  210,    0 }, /* (76) qtime ::= */
-  {  210,   -2 }, /* (77) qtime ::= QTIME INTEGER */
-  {  211,    0 }, /* (78) users ::= */
-  {  211,   -2 }, /* (79) users ::= USERS INTEGER */
-  {  212,    0 }, /* (80) conns ::= */
-  {  212,   -2 }, /* (81) conns ::= CONNS INTEGER */
-  {  213,    0 }, /* (82) state ::= */
-  {  213,   -2 }, /* (83) state ::= STATE ids */
-  {  199,   -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  214,   -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
-  {  214,   -1 }, /* (86) intitemlist ::= intitem */
-  {  215,   -1 }, /* (87) intitem ::= INTEGER */
-  {  216,   -2 }, /* (88) keep ::= KEEP intitemlist */
-  {  217,   -2 }, /* (89) cache ::= CACHE INTEGER */
-  {  218,   -2 }, /* (90) replica ::= REPLICA INTEGER */
-  {  219,   -2 }, /* (91) quorum ::= QUORUM INTEGER */
-  {  220,   -2 }, /* (92) days ::= DAYS INTEGER */
-  {  221,   -2 }, /* (93) minrows ::= MINROWS INTEGER */
-  {  222,   -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
-  {  223,   -2 }, /* (95) blocks ::= BLOCKS INTEGER */
-  {  224,   -2 }, /* (96) ctime ::= CTIME INTEGER */
-  {  225,   -2 }, /* (97) wal ::= WAL INTEGER */
-  {  226,   -2 }, /* (98) fsync ::= FSYNC INTEGER */
-  {  227,   -2 }, /* (99) comp ::= COMP INTEGER */
-  {  228,   -2 }, /* (100) prec ::= PRECISION STRING */
-  {  229,   -2 }, /* (101) update ::= UPDATE INTEGER */
-  {  230,   -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
-  {  231,   -2 }, /* (103) vgroups ::= VGROUPS INTEGER */
-  {  202,    0 }, /* (104) db_optr ::= */
-  {  202,   -2 }, /* (105) db_optr ::= db_optr cache */
-  {  202,   -2 }, /* (106) db_optr ::= db_optr replica */
-  {  202,   -2 }, /* (107) db_optr ::= db_optr quorum */
-  {  202,   -2 }, /* (108) db_optr ::= db_optr days */
-  {  202,   -2 }, /* (109) db_optr ::= db_optr minrows */
-  {  202,   -2 }, /* (110) db_optr ::= db_optr maxrows */
-  {  202,   -2 }, /* (111) db_optr ::= db_optr blocks */
-  {  202,   -2 }, /* (112) db_optr ::= db_optr ctime */
-  {  202,   -2 }, /* (113) db_optr ::= db_optr wal */
-  {  202,   -2 }, /* (114) db_optr ::= db_optr fsync */
-  {  202,   -2 }, /* (115) db_optr ::= db_optr comp */
-  {  202,   -2 }, /* (116) db_optr ::= db_optr prec */
-  {  202,   -2 }, /* (117) db_optr ::= db_optr keep */
-  {  202,   -2 }, /* (118) db_optr ::= db_optr update */
-  {  202,   -2 }, /* (119) db_optr ::= db_optr cachelast */
-  {  202,   -2 }, /* (120) db_optr ::= db_optr vgroups */
-  {  198,    0 }, /* (121) alter_db_optr ::= */
-  {  198,   -2 }, /* (122) alter_db_optr ::= alter_db_optr replica */
-  {  198,   -2 }, /* (123) alter_db_optr ::= alter_db_optr quorum */
-  {  198,   -2 }, /* (124) alter_db_optr ::= alter_db_optr keep */
-  {  198,   -2 }, /* (125) alter_db_optr ::= alter_db_optr blocks */
-  {  198,   -2 }, /* (126) alter_db_optr ::= alter_db_optr comp */
-  {  198,   -2 }, /* (127) alter_db_optr ::= alter_db_optr update */
-  {  198,   -2 }, /* (128) alter_db_optr ::= alter_db_optr cachelast */
-  {  203,   -1 }, /* (129) typename ::= ids */
-  {  203,   -4 }, /* (130) typename ::= ids LP signed RP */
-  {  203,   -2 }, /* (131) typename ::= ids UNSIGNED */
-  {  232,   -1 }, /* (132) signed ::= INTEGER */
-  {  232,   -2 }, /* (133) signed ::= PLUS INTEGER */
-  {  232,   -2 }, /* (134) signed ::= MINUS INTEGER */
-  {  193,   -3 }, /* (135) cmd ::= CREATE TABLE create_table_args */
-  {  193,   -3 }, /* (136) cmd ::= CREATE TABLE create_stable_args */
-  {  193,   -3 }, /* (137) cmd ::= CREATE STABLE create_stable_args */
-  {  193,   -3 }, /* (138) cmd ::= CREATE TABLE create_table_list */
-  {  235,   -1 }, /* (139) create_table_list ::= create_from_stable */
-  {  235,   -2 }, /* (140) create_table_list ::= create_table_list create_from_stable */
-  {  233,   -6 }, /* (141) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-  {  234,  -10 }, /* (142) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-  {  236,  -10 }, /* (143) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist1 RP */
-  {  236,  -13 }, /* (144) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist1 RP */
-  {  239,   -3 }, /* (145) tagNamelist ::= tagNamelist COMMA ids */
-  {  239,   -1 }, /* (146) tagNamelist ::= ids */
-  {  233,   -5 }, /* (147) create_table_args ::= ifnotexists ids cpxName AS select */
-  {  237,   -3 }, /* (148) columnlist ::= columnlist COMMA column */
-  {  237,   -1 }, /* (149) columnlist ::= column */
-  {  241,   -2 }, /* (150) column ::= ids typename */
-  {  238,   -3 }, /* (151) tagitemlist1 ::= tagitemlist1 COMMA tagitem1 */
-  {  238,   -1 }, /* (152) tagitemlist1 ::= tagitem1 */
-  {  242,   -2 }, /* (153) tagitem1 ::= MINUS INTEGER */
-  {  242,   -2 }, /* (154) tagitem1 ::= MINUS FLOAT */
-  {  242,   -2 }, /* (155) tagitem1 ::= PLUS INTEGER */
-  {  242,   -2 }, /* (156) tagitem1 ::= PLUS FLOAT */
-  {  242,   -1 }, /* (157) tagitem1 ::= INTEGER */
-  {  242,   -1 }, /* (158) tagitem1 ::= FLOAT */
-  {  242,   -1 }, /* (159) tagitem1 ::= STRING */
-  {  242,   -1 }, /* (160) tagitem1 ::= BOOL */
-  {  242,   -1 }, /* (161) tagitem1 ::= NULL */
-  {  242,   -1 }, /* (162) tagitem1 ::= NOW */
-  {  243,   -3 }, /* (163) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  243,   -1 }, /* (164) tagitemlist ::= tagitem */
-  {  244,   -1 }, /* (165) tagitem ::= INTEGER */
-  {  244,   -1 }, /* (166) tagitem ::= FLOAT */
-  {  244,   -1 }, /* (167) tagitem ::= STRING */
-  {  244,   -1 }, /* (168) tagitem ::= BOOL */
-  {  244,   -1 }, /* (169) tagitem ::= NULL */
-  {  244,   -1 }, /* (170) tagitem ::= NOW */
-  {  244,   -2 }, /* (171) tagitem ::= MINUS INTEGER */
-  {  244,   -2 }, /* (172) tagitem ::= MINUS FLOAT */
-  {  244,   -2 }, /* (173) tagitem ::= PLUS INTEGER */
-  {  244,   -2 }, /* (174) tagitem ::= PLUS FLOAT */
-  {  240,  -14 }, /* (175) select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
-  {  240,   -3 }, /* (176) select ::= LP select RP */
-  {  258,   -1 }, /* (177) union ::= select */
-  {  258,   -4 }, /* (178) union ::= union UNION ALL select */
-  {  258,   -3 }, /* (179) union ::= union UNION select */
-  {  193,   -1 }, /* (180) cmd ::= union */
-  {  240,   -2 }, /* (181) select ::= SELECT selcollist */
-  {  259,   -2 }, /* (182) sclp ::= selcollist COMMA */
-  {  259,    0 }, /* (183) sclp ::= */
-  {  245,   -4 }, /* (184) selcollist ::= sclp distinct expr as */
-  {  245,   -2 }, /* (185) selcollist ::= sclp STAR */
-  {  262,   -2 }, /* (186) as ::= AS ids */
-  {  262,   -1 }, /* (187) as ::= ids */
-  {  262,    0 }, /* (188) as ::= */
-  {  260,   -1 }, /* (189) distinct ::= DISTINCT */
-  {  260,    0 }, /* (190) distinct ::= */
-  {  246,   -2 }, /* (191) from ::= FROM tablelist */
-  {  246,   -2 }, /* (192) from ::= FROM sub */
-  {  264,   -3 }, /* (193) sub ::= LP union RP */
-  {  264,   -4 }, /* (194) sub ::= LP union RP ids */
-  {  264,   -6 }, /* (195) sub ::= sub COMMA LP union RP ids */
-  {  263,   -2 }, /* (196) tablelist ::= ids cpxName */
-  {  263,   -3 }, /* (197) tablelist ::= ids cpxName ids */
-  {  263,   -4 }, /* (198) tablelist ::= tablelist COMMA ids cpxName */
-  {  263,   -5 }, /* (199) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  265,   -1 }, /* (200) tmvar ::= VARIABLE */
-  {  248,   -4 }, /* (201) interval_option ::= intervalKey LP tmvar RP */
-  {  248,   -6 }, /* (202) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
-  {  248,    0 }, /* (203) interval_option ::= */
-  {  266,   -1 }, /* (204) intervalKey ::= INTERVAL */
-  {  266,   -1 }, /* (205) intervalKey ::= EVERY */
-  {  250,    0 }, /* (206) session_option ::= */
-  {  250,   -7 }, /* (207) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
-  {  251,    0 }, /* (208) windowstate_option ::= */
-  {  251,   -4 }, /* (209) windowstate_option ::= STATE_WINDOW LP ids RP */
-  {  252,    0 }, /* (210) fill_opt ::= */
-  {  252,   -6 }, /* (211) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  252,   -4 }, /* (212) fill_opt ::= FILL LP ID RP */
-  {  249,   -4 }, /* (213) sliding_opt ::= SLIDING LP tmvar RP */
-  {  249,    0 }, /* (214) sliding_opt ::= */
-  {  255,    0 }, /* (215) orderby_opt ::= */
-  {  255,   -3 }, /* (216) orderby_opt ::= ORDER BY sortlist */
-  {  267,   -4 }, /* (217) sortlist ::= sortlist COMMA item sortorder */
-  {  267,   -2 }, /* (218) sortlist ::= item sortorder */
-  {  269,   -2 }, /* (219) item ::= ids cpxName */
-  {  270,   -1 }, /* (220) sortorder ::= ASC */
-  {  270,   -1 }, /* (221) sortorder ::= DESC */
-  {  270,    0 }, /* (222) sortorder ::= */
-  {  253,    0 }, /* (223) groupby_opt ::= */
-  {  253,   -3 }, /* (224) groupby_opt ::= GROUP BY grouplist */
-  {  271,   -3 }, /* (225) grouplist ::= grouplist COMMA item */
-  {  271,   -1 }, /* (226) grouplist ::= item */
-  {  254,    0 }, /* (227) having_opt ::= */
-  {  254,   -2 }, /* (228) having_opt ::= HAVING expr */
-  {  257,    0 }, /* (229) limit_opt ::= */
-  {  257,   -2 }, /* (230) limit_opt ::= LIMIT signed */
-  {  257,   -4 }, /* (231) limit_opt ::= LIMIT signed OFFSET signed */
-  {  257,   -4 }, /* (232) limit_opt ::= LIMIT signed COMMA signed */
-  {  256,    0 }, /* (233) slimit_opt ::= */
-  {  256,   -2 }, /* (234) slimit_opt ::= SLIMIT signed */
-  {  256,   -4 }, /* (235) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  256,   -4 }, /* (236) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  247,    0 }, /* (237) where_opt ::= */
-  {  247,   -2 }, /* (238) where_opt ::= WHERE expr */
-  {  261,   -3 }, /* (239) expr ::= LP expr RP */
-  {  261,   -1 }, /* (240) expr ::= ID */
-  {  261,   -3 }, /* (241) expr ::= ID DOT ID */
-  {  261,   -3 }, /* (242) expr ::= ID DOT STAR */
-  {  261,   -1 }, /* (243) expr ::= INTEGER */
-  {  261,   -2 }, /* (244) expr ::= MINUS INTEGER */
-  {  261,   -2 }, /* (245) expr ::= PLUS INTEGER */
-  {  261,   -1 }, /* (246) expr ::= FLOAT */
-  {  261,   -2 }, /* (247) expr ::= MINUS FLOAT */
-  {  261,   -2 }, /* (248) expr ::= PLUS FLOAT */
-  {  261,   -1 }, /* (249) expr ::= STRING */
-  {  261,   -1 }, /* (250) expr ::= NOW */
-  {  261,   -1 }, /* (251) expr ::= VARIABLE */
-  {  261,   -2 }, /* (252) expr ::= PLUS VARIABLE */
-  {  261,   -2 }, /* (253) expr ::= MINUS VARIABLE */
-  {  261,   -1 }, /* (254) expr ::= BOOL */
-  {  261,   -1 }, /* (255) expr ::= NULL */
-  {  261,   -4 }, /* (256) expr ::= ID LP exprlist RP */
-  {  261,   -4 }, /* (257) expr ::= ID LP STAR RP */
-  {  261,   -3 }, /* (258) expr ::= expr IS NULL */
-  {  261,   -4 }, /* (259) expr ::= expr IS NOT NULL */
-  {  261,   -3 }, /* (260) expr ::= expr LT expr */
-  {  261,   -3 }, /* (261) expr ::= expr GT expr */
-  {  261,   -3 }, /* (262) expr ::= expr LE expr */
-  {  261,   -3 }, /* (263) expr ::= expr GE expr */
-  {  261,   -3 }, /* (264) expr ::= expr NE expr */
-  {  261,   -3 }, /* (265) expr ::= expr EQ expr */
-  {  261,   -5 }, /* (266) expr ::= expr BETWEEN expr AND expr */
-  {  261,   -3 }, /* (267) expr ::= expr AND expr */
-  {  261,   -3 }, /* (268) expr ::= expr OR expr */
-  {  261,   -3 }, /* (269) expr ::= expr PLUS expr */
-  {  261,   -3 }, /* (270) expr ::= expr MINUS expr */
-  {  261,   -3 }, /* (271) expr ::= expr STAR expr */
-  {  261,   -3 }, /* (272) expr ::= expr SLASH expr */
-  {  261,   -3 }, /* (273) expr ::= expr REM expr */
-  {  261,   -3 }, /* (274) expr ::= expr LIKE expr */
-  {  261,   -3 }, /* (275) expr ::= expr MATCH expr */
-  {  261,   -3 }, /* (276) expr ::= expr NMATCH expr */
-  {  261,   -5 }, /* (277) expr ::= expr IN LP exprlist RP */
-  {  200,   -3 }, /* (278) exprlist ::= exprlist COMMA expritem */
-  {  200,   -1 }, /* (279) exprlist ::= expritem */
-  {  272,   -1 }, /* (280) expritem ::= expr */
-  {  272,    0 }, /* (281) expritem ::= */
-  {  193,   -3 }, /* (282) cmd ::= RESET QUERY CACHE */
-  {  193,   -3 }, /* (283) cmd ::= SYNCDB ids REPLICA */
-  {  193,   -7 }, /* (284) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  193,   -7 }, /* (285) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  193,   -7 }, /* (286) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
-  {  193,   -7 }, /* (287) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  193,   -7 }, /* (288) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  193,   -8 }, /* (289) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  193,   -9 }, /* (290) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  193,   -7 }, /* (291) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
-  {  193,   -7 }, /* (292) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
-  {  193,   -7 }, /* (293) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
-  {  193,   -7 }, /* (294) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
-  {  193,   -7 }, /* (295) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
-  {  193,   -7 }, /* (296) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
-  {  193,   -8 }, /* (297) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
-  {  193,   -9 }, /* (298) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
-  {  193,   -7 }, /* (299) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
-  {  193,   -3 }, /* (300) cmd ::= KILL CONNECTION INTEGER */
-  {  193,   -5 }, /* (301) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  193,   -5 }, /* (302) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  197,   -2 }, /* (52) ifexists ::= IF EXISTS */
+  {  197,    0 }, /* (53) ifexists ::= */
+  {  201,   -3 }, /* (54) ifnotexists ::= IF NOT EXISTS */
+  {  201,    0 }, /* (55) ifnotexists ::= */
+  {  193,   -5 }, /* (56) cmd ::= CREATE DNODE ids PORT ids */
+  {  193,   -5 }, /* (57) cmd ::= CREATE DNODE IPTOKEN PORT ids */
+  {  193,   -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  193,   -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  193,   -8 }, /* (60) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  193,   -9 }, /* (61) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  193,   -5 }, /* (62) cmd ::= CREATE USER ids PASS ids */
+  {  204,    0 }, /* (63) bufsize ::= */
+  {  204,   -2 }, /* (64) bufsize ::= BUFSIZE INTEGER */
+  {  205,    0 }, /* (65) pps ::= */
+  {  205,   -2 }, /* (66) pps ::= PPS INTEGER */
+  {  206,    0 }, /* (67) tseries ::= */
+  {  206,   -2 }, /* (68) tseries ::= TSERIES INTEGER */
+  {  207,    0 }, /* (69) dbs ::= */
+  {  207,   -2 }, /* (70) dbs ::= DBS INTEGER */
+  {  208,    0 }, /* (71) streams ::= */
+  {  208,   -2 }, /* (72) streams ::= STREAMS INTEGER */
+  {  209,    0 }, /* (73) storage ::= */
+  {  209,   -2 }, /* (74) storage ::= STORAGE INTEGER */
+  {  210,    0 }, /* (75) qtime ::= */
+  {  210,   -2 }, /* (76) qtime ::= QTIME INTEGER */
+  {  211,    0 }, /* (77) users ::= */
+  {  211,   -2 }, /* (78) users ::= USERS INTEGER */
+  {  212,    0 }, /* (79) conns ::= */
+  {  212,   -2 }, /* (80) conns ::= CONNS INTEGER */
+  {  213,    0 }, /* (81) state ::= */
+  {  213,   -2 }, /* (82) state ::= STATE ids */
+  {  199,   -9 }, /* (83) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  214,   -3 }, /* (84) intitemlist ::= intitemlist COMMA intitem */
+  {  214,   -1 }, /* (85) intitemlist ::= intitem */
+  {  215,   -1 }, /* (86) intitem ::= INTEGER */
+  {  216,   -2 }, /* (87) keep ::= KEEP intitemlist */
+  {  217,   -2 }, /* (88) cache ::= CACHE INTEGER */
+  {  218,   -2 }, /* (89) replica ::= REPLICA INTEGER */
+  {  219,   -2 }, /* (90) quorum ::= QUORUM INTEGER */
+  {  220,   -2 }, /* (91) days ::= DAYS INTEGER */
+  {  221,   -2 }, /* (92) minrows ::= MINROWS INTEGER */
+  {  222,   -2 }, /* (93) maxrows ::= MAXROWS INTEGER */
+  {  223,   -2 }, /* (94) blocks ::= BLOCKS INTEGER */
+  {  224,   -2 }, /* (95) ctime ::= CTIME INTEGER */
+  {  225,   -2 }, /* (96) wal ::= WAL INTEGER */
+  {  226,   -2 }, /* (97) fsync ::= FSYNC INTEGER */
+  {  227,   -2 }, /* (98) comp ::= COMP INTEGER */
+  {  228,   -2 }, /* (99) prec ::= PRECISION STRING */
+  {  229,   -2 }, /* (100) update ::= UPDATE INTEGER */
+  {  230,   -2 }, /* (101) cachelast ::= CACHELAST INTEGER */
+  {  231,   -2 }, /* (102) vgroups ::= VGROUPS INTEGER */
+  {  202,    0 }, /* (103) db_optr ::= */
+  {  202,   -2 }, /* (104) db_optr ::= db_optr cache */
+  {  202,   -2 }, /* (105) db_optr ::= db_optr replica */
+  {  202,   -2 }, /* (106) db_optr ::= db_optr quorum */
+  {  202,   -2 }, /* (107) db_optr ::= db_optr days */
+  {  202,   -2 }, /* (108) db_optr ::= db_optr minrows */
+  {  202,   -2 }, /* (109) db_optr ::= db_optr maxrows */
+  {  202,   -2 }, /* (110) db_optr ::= db_optr blocks */
+  {  202,   -2 }, /* (111) db_optr ::= db_optr ctime */
+  {  202,   -2 }, /* (112) db_optr ::= db_optr wal */
+  {  202,   -2 }, /* (113) db_optr ::= db_optr fsync */
+  {  202,   -2 }, /* (114) db_optr ::= db_optr comp */
+  {  202,   -2 }, /* (115) db_optr ::= db_optr prec */
+  {  202,   -2 }, /* (116) db_optr ::= db_optr keep */
+  {  202,   -2 }, /* (117) db_optr ::= db_optr update */
+  {  202,   -2 }, /* (118) db_optr ::= db_optr cachelast */
+  {  202,   -2 }, /* (119) db_optr ::= db_optr vgroups */
+  {  198,    0 }, /* (120) alter_db_optr ::= */
+  {  198,   -2 }, /* (121) alter_db_optr ::= alter_db_optr replica */
+  {  198,   -2 }, /* (122) alter_db_optr ::= alter_db_optr quorum */
+  {  198,   -2 }, /* (123) alter_db_optr ::= alter_db_optr keep */
+  {  198,   -2 }, /* (124) alter_db_optr ::= alter_db_optr blocks */
+  {  198,   -2 }, /* (125) alter_db_optr ::= alter_db_optr comp */
+  {  198,   -2 }, /* (126) alter_db_optr ::= alter_db_optr update */
+  {  198,   -2 }, /* (127) alter_db_optr ::= alter_db_optr cachelast */
+  {  203,   -1 }, /* (128) typename ::= ids */
+  {  203,   -4 }, /* (129) typename ::= ids LP signed RP */
+  {  203,   -2 }, /* (130) typename ::= ids UNSIGNED */
+  {  232,   -1 }, /* (131) signed ::= INTEGER */
+  {  232,   -2 }, /* (132) signed ::= PLUS INTEGER */
+  {  232,   -2 }, /* (133) signed ::= MINUS INTEGER */
+  {  193,   -3 }, /* (134) cmd ::= CREATE TABLE create_table_args */
+  {  193,   -3 }, /* (135) cmd ::= CREATE TABLE create_stable_args */
+  {  193,   -3 }, /* (136) cmd ::= CREATE STABLE create_stable_args */
+  {  193,   -3 }, /* (137) cmd ::= CREATE TABLE create_table_list */
+  {  235,   -1 }, /* (138) create_table_list ::= create_from_stable */
+  {  235,   -2 }, /* (139) create_table_list ::= create_table_list create_from_stable */
+  {  233,   -6 }, /* (140) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  {  234,  -10 }, /* (141) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  {  236,  -10 }, /* (142) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist1 RP */
+  {  236,  -13 }, /* (143) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist1 RP */
+  {  239,   -3 }, /* (144) tagNamelist ::= tagNamelist COMMA ids */
+  {  239,   -1 }, /* (145) tagNamelist ::= ids */
+  {  233,   -5 }, /* (146) create_table_args ::= ifnotexists ids cpxName AS select */
+  {  237,   -3 }, /* (147) columnlist ::= columnlist COMMA column */
+  {  237,   -1 }, /* (148) columnlist ::= column */
+  {  241,   -2 }, /* (149) column ::= ids typename */
+  {  238,   -3 }, /* (150) tagitemlist1 ::= tagitemlist1 COMMA tagitem1 */
+  {  238,   -1 }, /* (151) tagitemlist1 ::= tagitem1 */
+  {  242,   -2 }, /* (152) tagitem1 ::= MINUS INTEGER */
+  {  242,   -2 }, /* (153) tagitem1 ::= MINUS FLOAT */
+  {  242,   -2 }, /* (154) tagitem1 ::= PLUS INTEGER */
+  {  242,   -2 }, /* (155) tagitem1 ::= PLUS FLOAT */
+  {  242,   -1 }, /* (156) tagitem1 ::= INTEGER */
+  {  242,   -1 }, /* (157) tagitem1 ::= FLOAT */
+  {  242,   -1 }, /* (158) tagitem1 ::= STRING */
+  {  242,   -1 }, /* (159) tagitem1 ::= BOOL */
+  {  242,   -1 }, /* (160) tagitem1 ::= NULL */
+  {  242,   -1 }, /* (161) tagitem1 ::= NOW */
+  {  243,   -3 }, /* (162) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  243,   -1 }, /* (163) tagitemlist ::= tagitem */
+  {  244,   -1 }, /* (164) tagitem ::= INTEGER */
+  {  244,   -1 }, /* (165) tagitem ::= FLOAT */
+  {  244,   -1 }, /* (166) tagitem ::= STRING */
+  {  244,   -1 }, /* (167) tagitem ::= BOOL */
+  {  244,   -1 }, /* (168) tagitem ::= NULL */
+  {  244,   -1 }, /* (169) tagitem ::= NOW */
+  {  244,   -2 }, /* (170) tagitem ::= MINUS INTEGER */
+  {  244,   -2 }, /* (171) tagitem ::= MINUS FLOAT */
+  {  244,   -2 }, /* (172) tagitem ::= PLUS INTEGER */
+  {  244,   -2 }, /* (173) tagitem ::= PLUS FLOAT */
+  {  240,  -14 }, /* (174) select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+  {  240,   -3 }, /* (175) select ::= LP select RP */
+  {  258,   -1 }, /* (176) union ::= select */
+  {  258,   -4 }, /* (177) union ::= union UNION ALL select */
+  {  258,   -3 }, /* (178) union ::= union UNION select */
+  {  193,   -1 }, /* (179) cmd ::= union */
+  {  240,   -2 }, /* (180) select ::= SELECT selcollist */
+  {  259,   -2 }, /* (181) sclp ::= selcollist COMMA */
+  {  259,    0 }, /* (182) sclp ::= */
+  {  245,   -4 }, /* (183) selcollist ::= sclp distinct expr as */
+  {  245,   -2 }, /* (184) selcollist ::= sclp STAR */
+  {  262,   -2 }, /* (185) as ::= AS ids */
+  {  262,   -1 }, /* (186) as ::= ids */
+  {  262,    0 }, /* (187) as ::= */
+  {  260,   -1 }, /* (188) distinct ::= DISTINCT */
+  {  260,    0 }, /* (189) distinct ::= */
+  {  246,   -2 }, /* (190) from ::= FROM tablelist */
+  {  246,   -2 }, /* (191) from ::= FROM sub */
+  {  264,   -3 }, /* (192) sub ::= LP union RP */
+  {  264,   -4 }, /* (193) sub ::= LP union RP ids */
+  {  264,   -6 }, /* (194) sub ::= sub COMMA LP union RP ids */
+  {  263,   -2 }, /* (195) tablelist ::= ids cpxName */
+  {  263,   -3 }, /* (196) tablelist ::= ids cpxName ids */
+  {  263,   -4 }, /* (197) tablelist ::= tablelist COMMA ids cpxName */
+  {  263,   -5 }, /* (198) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  265,   -1 }, /* (199) tmvar ::= VARIABLE */
+  {  248,   -4 }, /* (200) interval_option ::= intervalKey LP tmvar RP */
+  {  248,   -6 }, /* (201) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
+  {  248,    0 }, /* (202) interval_option ::= */
+  {  266,   -1 }, /* (203) intervalKey ::= INTERVAL */
+  {  266,   -1 }, /* (204) intervalKey ::= EVERY */
+  {  250,    0 }, /* (205) session_option ::= */
+  {  250,   -7 }, /* (206) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+  {  251,    0 }, /* (207) windowstate_option ::= */
+  {  251,   -4 }, /* (208) windowstate_option ::= STATE_WINDOW LP ids RP */
+  {  252,    0 }, /* (209) fill_opt ::= */
+  {  252,   -6 }, /* (210) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  252,   -4 }, /* (211) fill_opt ::= FILL LP ID RP */
+  {  249,   -4 }, /* (212) sliding_opt ::= SLIDING LP tmvar RP */
+  {  249,    0 }, /* (213) sliding_opt ::= */
+  {  255,    0 }, /* (214) orderby_opt ::= */
+  {  255,   -3 }, /* (215) orderby_opt ::= ORDER BY sortlist */
+  {  267,   -4 }, /* (216) sortlist ::= sortlist COMMA item sortorder */
+  {  267,   -2 }, /* (217) sortlist ::= item sortorder */
+  {  269,   -2 }, /* (218) item ::= ids cpxName */
+  {  270,   -1 }, /* (219) sortorder ::= ASC */
+  {  270,   -1 }, /* (220) sortorder ::= DESC */
+  {  270,    0 }, /* (221) sortorder ::= */
+  {  253,    0 }, /* (222) groupby_opt ::= */
+  {  253,   -3 }, /* (223) groupby_opt ::= GROUP BY grouplist */
+  {  271,   -3 }, /* (224) grouplist ::= grouplist COMMA item */
+  {  271,   -1 }, /* (225) grouplist ::= item */
+  {  254,    0 }, /* (226) having_opt ::= */
+  {  254,   -2 }, /* (227) having_opt ::= HAVING expr */
+  {  257,    0 }, /* (228) limit_opt ::= */
+  {  257,   -2 }, /* (229) limit_opt ::= LIMIT signed */
+  {  257,   -4 }, /* (230) limit_opt ::= LIMIT signed OFFSET signed */
+  {  257,   -4 }, /* (231) limit_opt ::= LIMIT signed COMMA signed */
+  {  256,    0 }, /* (232) slimit_opt ::= */
+  {  256,   -2 }, /* (233) slimit_opt ::= SLIMIT signed */
+  {  256,   -4 }, /* (234) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  256,   -4 }, /* (235) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  247,    0 }, /* (236) where_opt ::= */
+  {  247,   -2 }, /* (237) where_opt ::= WHERE expr */
+  {  261,   -3 }, /* (238) expr ::= LP expr RP */
+  {  261,   -1 }, /* (239) expr ::= ID */
+  {  261,   -3 }, /* (240) expr ::= ID DOT ID */
+  {  261,   -3 }, /* (241) expr ::= ID DOT STAR */
+  {  261,   -1 }, /* (242) expr ::= INTEGER */
+  {  261,   -2 }, /* (243) expr ::= MINUS INTEGER */
+  {  261,   -2 }, /* (244) expr ::= PLUS INTEGER */
+  {  261,   -1 }, /* (245) expr ::= FLOAT */
+  {  261,   -2 }, /* (246) expr ::= MINUS FLOAT */
+  {  261,   -2 }, /* (247) expr ::= PLUS FLOAT */
+  {  261,   -1 }, /* (248) expr ::= STRING */
+  {  261,   -1 }, /* (249) expr ::= NOW */
+  {  261,   -1 }, /* (250) expr ::= VARIABLE */
+  {  261,   -2 }, /* (251) expr ::= PLUS VARIABLE */
+  {  261,   -2 }, /* (252) expr ::= MINUS VARIABLE */
+  {  261,   -1 }, /* (253) expr ::= BOOL */
+  {  261,   -1 }, /* (254) expr ::= NULL */
+  {  261,   -4 }, /* (255) expr ::= ID LP exprlist RP */
+  {  261,   -4 }, /* (256) expr ::= ID LP STAR RP */
+  {  261,   -3 }, /* (257) expr ::= expr IS NULL */
+  {  261,   -4 }, /* (258) expr ::= expr IS NOT NULL */
+  {  261,   -3 }, /* (259) expr ::= expr LT expr */
+  {  261,   -3 }, /* (260) expr ::= expr GT expr */
+  {  261,   -3 }, /* (261) expr ::= expr LE expr */
+  {  261,   -3 }, /* (262) expr ::= expr GE expr */
+  {  261,   -3 }, /* (263) expr ::= expr NE expr */
+  {  261,   -3 }, /* (264) expr ::= expr EQ expr */
+  {  261,   -5 }, /* (265) expr ::= expr BETWEEN expr AND expr */
+  {  261,   -3 }, /* (266) expr ::= expr AND expr */
+  {  261,   -3 }, /* (267) expr ::= expr OR expr */
+  {  261,   -3 }, /* (268) expr ::= expr PLUS expr */
+  {  261,   -3 }, /* (269) expr ::= expr MINUS expr */
+  {  261,   -3 }, /* (270) expr ::= expr STAR expr */
+  {  261,   -3 }, /* (271) expr ::= expr SLASH expr */
+  {  261,   -3 }, /* (272) expr ::= expr REM expr */
+  {  261,   -3 }, /* (273) expr ::= expr LIKE expr */
+  {  261,   -3 }, /* (274) expr ::= expr MATCH expr */
+  {  261,   -3 }, /* (275) expr ::= expr NMATCH expr */
+  {  261,   -5 }, /* (276) expr ::= expr IN LP exprlist RP */
+  {  200,   -3 }, /* (277) exprlist ::= exprlist COMMA expritem */
+  {  200,   -1 }, /* (278) exprlist ::= expritem */
+  {  272,   -1 }, /* (279) expritem ::= expr */
+  {  272,    0 }, /* (280) expritem ::= */
+  {  193,   -3 }, /* (281) cmd ::= RESET QUERY CACHE */
+  {  193,   -3 }, /* (282) cmd ::= SYNCDB ids REPLICA */
+  {  193,   -7 }, /* (283) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  193,   -7 }, /* (284) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  193,   -7 }, /* (285) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+  {  193,   -7 }, /* (286) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  193,   -7 }, /* (287) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  193,   -8 }, /* (288) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  193,   -9 }, /* (289) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  193,   -7 }, /* (290) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+  {  193,   -7 }, /* (291) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+  {  193,   -7 }, /* (292) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+  {  193,   -7 }, /* (293) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+  {  193,   -7 }, /* (294) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+  {  193,   -7 }, /* (295) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+  {  193,   -8 }, /* (296) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+  {  193,   -9 }, /* (297) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+  {  193,   -7 }, /* (298) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+  {  193,   -3 }, /* (299) cmd ::= KILL CONNECTION INTEGER */
+  {  193,   -5 }, /* (300) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  193,   -5 }, /* (301) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2224,9 +2220,9 @@ static void yy_reduce(
 /********** Begin reduce actions **********************************************/
         YYMINORTYPE yylhsminor;
       case 0: /* program ::= cmd */
-      case 135: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==135);
-      case 136: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==136);
-      case 137: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==137);
+      case 134: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==134);
+      case 135: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==135);
+      case 136: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==136);
 {}
         break;
       case 1: /* cmd ::= SHOW DATABASES */
@@ -2414,65 +2410,64 @@ static void yy_reduce(
 { setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy165);}
         break;
       case 51: /* ids ::= ID */
-      case 52: /* ids ::= STRING */ yytestcase(yyruleno==52);
 {yylhsminor.yy0 = yymsp[0].minor.yy0; }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 53: /* ifexists ::= IF EXISTS */
+      case 52: /* ifexists ::= IF EXISTS */
 { yymsp[-1].minor.yy0.n = 1;}
         break;
-      case 54: /* ifexists ::= */
-      case 56: /* ifnotexists ::= */ yytestcase(yyruleno==56);
-      case 190: /* distinct ::= */ yytestcase(yyruleno==190);
+      case 53: /* ifexists ::= */
+      case 55: /* ifnotexists ::= */ yytestcase(yyruleno==55);
+      case 189: /* distinct ::= */ yytestcase(yyruleno==189);
 { yymsp[1].minor.yy0.n = 0;}
         break;
-      case 55: /* ifnotexists ::= IF NOT EXISTS */
+      case 54: /* ifnotexists ::= IF NOT EXISTS */
 { yymsp[-2].minor.yy0.n = 1;}
         break;
-      case 57: /* cmd ::= CREATE DNODE ids PORT ids */
-      case 58: /* cmd ::= CREATE DNODE IPTOKEN PORT ids */ yytestcase(yyruleno==58);
+      case 56: /* cmd ::= CREATE DNODE ids PORT ids */
+      case 57: /* cmd ::= CREATE DNODE IPTOKEN PORT ids */ yytestcase(yyruleno==57);
 { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 2, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 59: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+      case 58: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
 { setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy211);}
         break;
-      case 60: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+      case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
 { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy16, &yymsp[-2].minor.yy0);}
         break;
-      case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+      case 60: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
 { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy106, &yymsp[0].minor.yy0, 1);}
         break;
-      case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+      case 61: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
 { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy106, &yymsp[0].minor.yy0, 2);}
         break;
-      case 63: /* cmd ::= CREATE USER ids PASS ids */
+      case 62: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 64: /* bufsize ::= */
-      case 66: /* pps ::= */ yytestcase(yyruleno==66);
-      case 68: /* tseries ::= */ yytestcase(yyruleno==68);
-      case 70: /* dbs ::= */ yytestcase(yyruleno==70);
-      case 72: /* streams ::= */ yytestcase(yyruleno==72);
-      case 74: /* storage ::= */ yytestcase(yyruleno==74);
-      case 76: /* qtime ::= */ yytestcase(yyruleno==76);
-      case 78: /* users ::= */ yytestcase(yyruleno==78);
-      case 80: /* conns ::= */ yytestcase(yyruleno==80);
-      case 82: /* state ::= */ yytestcase(yyruleno==82);
+      case 63: /* bufsize ::= */
+      case 65: /* pps ::= */ yytestcase(yyruleno==65);
+      case 67: /* tseries ::= */ yytestcase(yyruleno==67);
+      case 69: /* dbs ::= */ yytestcase(yyruleno==69);
+      case 71: /* streams ::= */ yytestcase(yyruleno==71);
+      case 73: /* storage ::= */ yytestcase(yyruleno==73);
+      case 75: /* qtime ::= */ yytestcase(yyruleno==75);
+      case 77: /* users ::= */ yytestcase(yyruleno==77);
+      case 79: /* conns ::= */ yytestcase(yyruleno==79);
+      case 81: /* state ::= */ yytestcase(yyruleno==81);
 { yymsp[1].minor.yy0.n = 0;   }
         break;
-      case 65: /* bufsize ::= BUFSIZE INTEGER */
-      case 67: /* pps ::= PPS INTEGER */ yytestcase(yyruleno==67);
-      case 69: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==69);
-      case 71: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==71);
-      case 73: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==73);
-      case 75: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==75);
-      case 77: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==77);
-      case 79: /* users ::= USERS INTEGER */ yytestcase(yyruleno==79);
-      case 81: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==81);
-      case 83: /* state ::= STATE ids */ yytestcase(yyruleno==83);
+      case 64: /* bufsize ::= BUFSIZE INTEGER */
+      case 66: /* pps ::= PPS INTEGER */ yytestcase(yyruleno==66);
+      case 68: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==68);
+      case 70: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==70);
+      case 72: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==72);
+      case 74: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==74);
+      case 76: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==76);
+      case 78: /* users ::= USERS INTEGER */ yytestcase(yyruleno==78);
+      case 80: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==80);
+      case 82: /* state ::= STATE ids */ yytestcase(yyruleno==82);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;     }
         break;
-      case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+      case 83: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
     yylhsminor.yy211.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
     yylhsminor.yy211.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
@@ -2486,129 +2481,129 @@ static void yy_reduce(
 }
   yymsp[-8].minor.yy211 = yylhsminor.yy211;
         break;
-      case 85: /* intitemlist ::= intitemlist COMMA intitem */
-      case 163: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==163);
+      case 84: /* intitemlist ::= intitemlist COMMA intitem */
+      case 162: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==162);
 { yylhsminor.yy165 = tListItemAppend(yymsp[-2].minor.yy165, &yymsp[0].minor.yy425, -1);    }
   yymsp[-2].minor.yy165 = yylhsminor.yy165;
         break;
-      case 86: /* intitemlist ::= intitem */
-      case 164: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==164);
+      case 85: /* intitemlist ::= intitem */
+      case 163: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==163);
 { yylhsminor.yy165 = tListItemAppend(NULL, &yymsp[0].minor.yy425, -1); }
   yymsp[0].minor.yy165 = yylhsminor.yy165;
         break;
-      case 87: /* intitem ::= INTEGER */
-      case 165: /* tagitem ::= INTEGER */ yytestcase(yyruleno==165);
-      case 166: /* tagitem ::= FLOAT */ yytestcase(yyruleno==166);
-      case 167: /* tagitem ::= STRING */ yytestcase(yyruleno==167);
-      case 168: /* tagitem ::= BOOL */ yytestcase(yyruleno==168);
+      case 86: /* intitem ::= INTEGER */
+      case 164: /* tagitem ::= INTEGER */ yytestcase(yyruleno==164);
+      case 165: /* tagitem ::= FLOAT */ yytestcase(yyruleno==165);
+      case 166: /* tagitem ::= STRING */ yytestcase(yyruleno==166);
+      case 167: /* tagitem ::= BOOL */ yytestcase(yyruleno==167);
 { toTSDBType(yymsp[0].minor.yy0.type); taosVariantCreate(&yylhsminor.yy425, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type); }
   yymsp[0].minor.yy425 = yylhsminor.yy425;
         break;
-      case 88: /* keep ::= KEEP intitemlist */
+      case 87: /* keep ::= KEEP intitemlist */
 { yymsp[-1].minor.yy165 = yymsp[0].minor.yy165; }
         break;
-      case 89: /* cache ::= CACHE INTEGER */
-      case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90);
-      case 91: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==91);
-      case 92: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==92);
-      case 93: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==93);
-      case 94: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==94);
-      case 95: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==95);
-      case 96: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==96);
-      case 97: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==97);
-      case 98: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==98);
-      case 99: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==99);
-      case 100: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==100);
-      case 101: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==101);
-      case 102: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==102);
-      case 103: /* vgroups ::= VGROUPS INTEGER */ yytestcase(yyruleno==103);
+      case 88: /* cache ::= CACHE INTEGER */
+      case 89: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==89);
+      case 90: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==90);
+      case 91: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==91);
+      case 92: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==92);
+      case 93: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==93);
+      case 94: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==94);
+      case 95: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==95);
+      case 96: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==96);
+      case 97: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==97);
+      case 98: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==98);
+      case 99: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==99);
+      case 100: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==100);
+      case 101: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==101);
+      case 102: /* vgroups ::= VGROUPS INTEGER */ yytestcase(yyruleno==102);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
-      case 104: /* db_optr ::= */
+      case 103: /* db_optr ::= */
 {setDefaultCreateDbOption(&yymsp[1].minor.yy16);}
         break;
-      case 105: /* db_optr ::= db_optr cache */
+      case 104: /* db_optr ::= db_optr cache */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 106: /* db_optr ::= db_optr replica */
-      case 122: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==122);
+      case 105: /* db_optr ::= db_optr replica */
+      case 121: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==121);
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 107: /* db_optr ::= db_optr quorum */
-      case 123: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==123);
+      case 106: /* db_optr ::= db_optr quorum */
+      case 122: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==122);
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 108: /* db_optr ::= db_optr days */
+      case 107: /* db_optr ::= db_optr days */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 109: /* db_optr ::= db_optr minrows */
+      case 108: /* db_optr ::= db_optr minrows */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 110: /* db_optr ::= db_optr maxrows */
+      case 109: /* db_optr ::= db_optr maxrows */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 111: /* db_optr ::= db_optr blocks */
-      case 125: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==125);
+      case 110: /* db_optr ::= db_optr blocks */
+      case 124: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==124);
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 112: /* db_optr ::= db_optr ctime */
+      case 111: /* db_optr ::= db_optr ctime */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 113: /* db_optr ::= db_optr wal */
+      case 112: /* db_optr ::= db_optr wal */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 114: /* db_optr ::= db_optr fsync */
+      case 113: /* db_optr ::= db_optr fsync */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 115: /* db_optr ::= db_optr comp */
-      case 126: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==126);
+      case 114: /* db_optr ::= db_optr comp */
+      case 125: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==125);
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 116: /* db_optr ::= db_optr prec */
+      case 115: /* db_optr ::= db_optr prec */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.precision = yymsp[0].minor.yy0; }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 117: /* db_optr ::= db_optr keep */
-      case 124: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==124);
+      case 116: /* db_optr ::= db_optr keep */
+      case 123: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==123);
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.keep = yymsp[0].minor.yy165; }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 118: /* db_optr ::= db_optr update */
-      case 127: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==127);
+      case 117: /* db_optr ::= db_optr update */
+      case 126: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==126);
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 119: /* db_optr ::= db_optr cachelast */
-      case 128: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==128);
+      case 118: /* db_optr ::= db_optr cachelast */
+      case 127: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==127);
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 120: /* db_optr ::= db_optr vgroups */
+      case 119: /* db_optr ::= db_optr vgroups */
 { yylhsminor.yy16 = yymsp[-1].minor.yy16; yylhsminor.yy16.numOfVgroups = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy16 = yylhsminor.yy16;
         break;
-      case 121: /* alter_db_optr ::= */
+      case 120: /* alter_db_optr ::= */
 { setDefaultCreateDbOption(&yymsp[1].minor.yy16);}
         break;
-      case 129: /* typename ::= ids */
+      case 128: /* typename ::= ids */
 { 
   yymsp[0].minor.yy0.type = 0;
   tSetColumnType (&yylhsminor.yy106, &yymsp[0].minor.yy0);
 }
   yymsp[0].minor.yy106 = yylhsminor.yy106;
         break;
-      case 130: /* typename ::= ids LP signed RP */
+      case 129: /* typename ::= ids LP signed RP */
 {
   if (yymsp[-1].minor.yy207 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
@@ -2620,7 +2615,7 @@ static void yy_reduce(
 }
   yymsp[-3].minor.yy106 = yylhsminor.yy106;
         break;
-      case 131: /* typename ::= ids UNSIGNED */
+      case 130: /* typename ::= ids UNSIGNED */
 {
   yymsp[-1].minor.yy0.type = 0;
   yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z);
@@ -2628,20 +2623,20 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy106 = yylhsminor.yy106;
         break;
-      case 132: /* signed ::= INTEGER */
+      case 131: /* signed ::= INTEGER */
 { yylhsminor.yy207 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[0].minor.yy207 = yylhsminor.yy207;
         break;
-      case 133: /* signed ::= PLUS INTEGER */
+      case 132: /* signed ::= PLUS INTEGER */
 { yymsp[-1].minor.yy207 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
-      case 134: /* signed ::= MINUS INTEGER */
+      case 133: /* signed ::= MINUS INTEGER */
 { yymsp[-1].minor.yy207 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
-      case 138: /* cmd ::= CREATE TABLE create_table_list */
+      case 137: /* cmd ::= CREATE TABLE create_table_list */
 { pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy326;}
         break;
-      case 139: /* create_table_list ::= create_from_stable */
+      case 138: /* create_table_list ::= create_from_stable */
 {
   SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql));
   pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
@@ -2652,14 +2647,14 @@ static void yy_reduce(
 }
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 140: /* create_table_list ::= create_table_list create_from_stable */
+      case 139: /* create_table_list ::= create_table_list create_from_stable */
 {
   taosArrayPush(yymsp[-1].minor.yy326->childTableInfo, &yymsp[0].minor.yy150);
   yylhsminor.yy326 = yymsp[-1].minor.yy326;
 }
   yymsp[-1].minor.yy326 = yylhsminor.yy326;
         break;
-      case 141: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+      case 140: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
   yylhsminor.yy326 = tSetCreateTableInfo(yymsp[-1].minor.yy165, NULL, NULL, TSQL_CREATE_TABLE);
   setSqlInfo(pInfo, yylhsminor.yy326, NULL, TSDB_SQL_CREATE_TABLE);
@@ -2669,17 +2664,17 @@ static void yy_reduce(
 }
   yymsp[-5].minor.yy326 = yylhsminor.yy326;
         break;
-      case 142: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+      case 141: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
 {
   yylhsminor.yy326 = tSetCreateTableInfo(yymsp[-5].minor.yy165, yymsp[-1].minor.yy165, NULL, TSQL_CREATE_STABLE);
-  setSqlInfo(pInfo, yylhsminor.yy326, NULL, TSDB_SQL_CREATE_TABLE);
+  setSqlInfo(pInfo, yylhsminor.yy326, NULL, TSDB_SQL_CREATE_STABLE);
 
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
   yymsp[-9].minor.yy326 = yylhsminor.yy326;
         break;
-      case 143: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist1 RP */
+      case 142: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist1 RP */
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
@@ -2687,7 +2682,7 @@ static void yy_reduce(
 }
   yymsp[-9].minor.yy150 = yylhsminor.yy150;
         break;
-      case 144: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist1 RP */
+      case 143: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist1 RP */
 {
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n;
@@ -2695,15 +2690,15 @@ static void yy_reduce(
 }
   yymsp[-12].minor.yy150 = yylhsminor.yy150;
         break;
-      case 145: /* tagNamelist ::= tagNamelist COMMA ids */
+      case 144: /* tagNamelist ::= tagNamelist COMMA ids */
 {taosArrayPush(yymsp[-2].minor.yy165, &yymsp[0].minor.yy0); yylhsminor.yy165 = yymsp[-2].minor.yy165;  }
   yymsp[-2].minor.yy165 = yylhsminor.yy165;
         break;
-      case 146: /* tagNamelist ::= ids */
+      case 145: /* tagNamelist ::= ids */
 {yylhsminor.yy165 = taosArrayInit(4, sizeof(SToken)); taosArrayPush(yylhsminor.yy165, &yymsp[0].minor.yy0);}
   yymsp[0].minor.yy165 = yylhsminor.yy165;
         break;
-      case 147: /* create_table_args ::= ifnotexists ids cpxName AS select */
+      case 146: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
   yylhsminor.yy326 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy278, TSQL_CREATE_STREAM);
   setSqlInfo(pInfo, yylhsminor.yy326, NULL, TSDB_SQL_CREATE_TABLE);
@@ -2713,56 +2708,56 @@ static void yy_reduce(
 }
   yymsp[-4].minor.yy326 = yylhsminor.yy326;
         break;
-      case 148: /* columnlist ::= columnlist COMMA column */
+      case 147: /* columnlist ::= columnlist COMMA column */
 {taosArrayPush(yymsp[-2].minor.yy165, &yymsp[0].minor.yy106); yylhsminor.yy165 = yymsp[-2].minor.yy165;  }
   yymsp[-2].minor.yy165 = yylhsminor.yy165;
         break;
-      case 149: /* columnlist ::= column */
+      case 148: /* columnlist ::= column */
 {yylhsminor.yy165 = taosArrayInit(4, sizeof(SField)); taosArrayPush(yylhsminor.yy165, &yymsp[0].minor.yy106);}
   yymsp[0].minor.yy165 = yylhsminor.yy165;
         break;
-      case 150: /* column ::= ids typename */
+      case 149: /* column ::= ids typename */
 {
   tSetColumnInfo(&yylhsminor.yy106, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy106);
 }
   yymsp[-1].minor.yy106 = yylhsminor.yy106;
         break;
-      case 151: /* tagitemlist1 ::= tagitemlist1 COMMA tagitem1 */
+      case 150: /* tagitemlist1 ::= tagitemlist1 COMMA tagitem1 */
 { taosArrayPush(yymsp[-2].minor.yy165, &yymsp[0].minor.yy0); yylhsminor.yy165 = yymsp[-2].minor.yy165;}
   yymsp[-2].minor.yy165 = yylhsminor.yy165;
         break;
-      case 152: /* tagitemlist1 ::= tagitem1 */
+      case 151: /* tagitemlist1 ::= tagitem1 */
 { yylhsminor.yy165 = taosArrayInit(4, sizeof(SToken)); taosArrayPush(yylhsminor.yy165, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy165 = yylhsminor.yy165;
         break;
-      case 153: /* tagitem1 ::= MINUS INTEGER */
-      case 154: /* tagitem1 ::= MINUS FLOAT */ yytestcase(yyruleno==154);
-      case 155: /* tagitem1 ::= PLUS INTEGER */ yytestcase(yyruleno==155);
-      case 156: /* tagitem1 ::= PLUS FLOAT */ yytestcase(yyruleno==156);
+      case 152: /* tagitem1 ::= MINUS INTEGER */
+      case 153: /* tagitem1 ::= MINUS FLOAT */ yytestcase(yyruleno==153);
+      case 154: /* tagitem1 ::= PLUS INTEGER */ yytestcase(yyruleno==154);
+      case 155: /* tagitem1 ::= PLUS FLOAT */ yytestcase(yyruleno==155);
 { yylhsminor.yy0.n = yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n; yylhsminor.yy0.type = yymsp[0].minor.yy0.type; }
   yymsp[-1].minor.yy0 = yylhsminor.yy0;
         break;
-      case 157: /* tagitem1 ::= INTEGER */
-      case 158: /* tagitem1 ::= FLOAT */ yytestcase(yyruleno==158);
-      case 159: /* tagitem1 ::= STRING */ yytestcase(yyruleno==159);
-      case 160: /* tagitem1 ::= BOOL */ yytestcase(yyruleno==160);
-      case 161: /* tagitem1 ::= NULL */ yytestcase(yyruleno==161);
-      case 162: /* tagitem1 ::= NOW */ yytestcase(yyruleno==162);
+      case 156: /* tagitem1 ::= INTEGER */
+      case 157: /* tagitem1 ::= FLOAT */ yytestcase(yyruleno==157);
+      case 158: /* tagitem1 ::= STRING */ yytestcase(yyruleno==158);
+      case 159: /* tagitem1 ::= BOOL */ yytestcase(yyruleno==159);
+      case 160: /* tagitem1 ::= NULL */ yytestcase(yyruleno==160);
+      case 161: /* tagitem1 ::= NOW */ yytestcase(yyruleno==161);
 { yylhsminor.yy0 = yymsp[0].minor.yy0; }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 169: /* tagitem ::= NULL */
+      case 168: /* tagitem ::= NULL */
 { yymsp[0].minor.yy0.type = 0; taosVariantCreate(&yylhsminor.yy425, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type); }
   yymsp[0].minor.yy425 = yylhsminor.yy425;
         break;
-      case 170: /* tagitem ::= NOW */
+      case 169: /* tagitem ::= NOW */
 { yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; taosVariantCreate(&yylhsminor.yy425, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.type);}
   yymsp[0].minor.yy425 = yylhsminor.yy425;
         break;
-      case 171: /* tagitem ::= MINUS INTEGER */
-      case 172: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==172);
-      case 173: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==173);
-      case 174: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==174);
+      case 170: /* tagitem ::= MINUS INTEGER */
+      case 171: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==171);
+      case 172: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==172);
+      case 173: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==173);
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
@@ -2771,154 +2766,154 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy425 = yylhsminor.yy425;
         break;
-      case 175: /* select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+      case 174: /* select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
 {
   yylhsminor.yy278 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy165, yymsp[-11].minor.yy10, yymsp[-10].minor.yy202, yymsp[-4].minor.yy165, yymsp[-2].minor.yy165, &yymsp[-9].minor.yy532, &yymsp[-7].minor.yy97, &yymsp[-6].minor.yy6, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy165, &yymsp[0].minor.yy367, &yymsp[-1].minor.yy367, yymsp[-3].minor.yy202);
 }
   yymsp[-13].minor.yy278 = yylhsminor.yy278;
         break;
-      case 176: /* select ::= LP select RP */
+      case 175: /* select ::= LP select RP */
 {yymsp[-2].minor.yy278 = yymsp[-1].minor.yy278;}
         break;
-      case 177: /* union ::= select */
+      case 176: /* union ::= select */
 { yylhsminor.yy503 = setSubclause(NULL, yymsp[0].minor.yy278); }
   yymsp[0].minor.yy503 = yylhsminor.yy503;
         break;
-      case 178: /* union ::= union UNION ALL select */
+      case 177: /* union ::= union UNION ALL select */
 { yylhsminor.yy503 = appendSelectClause(yymsp[-3].minor.yy503, SQL_TYPE_UNIONALL, yymsp[0].minor.yy278);  }
   yymsp[-3].minor.yy503 = yylhsminor.yy503;
         break;
-      case 179: /* union ::= union UNION select */
+      case 178: /* union ::= union UNION select */
 { yylhsminor.yy503 = appendSelectClause(yymsp[-2].minor.yy503, SQL_TYPE_UNION, yymsp[0].minor.yy278);  }
   yymsp[-2].minor.yy503 = yylhsminor.yy503;
         break;
-      case 180: /* cmd ::= union */
+      case 179: /* cmd ::= union */
 { setSqlInfo(pInfo, yymsp[0].minor.yy503, NULL, TSDB_SQL_SELECT); }
         break;
-      case 181: /* select ::= SELECT selcollist */
+      case 180: /* select ::= SELECT selcollist */
 {
   yylhsminor.yy278 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy165, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
   yymsp[-1].minor.yy278 = yylhsminor.yy278;
         break;
-      case 182: /* sclp ::= selcollist COMMA */
+      case 181: /* sclp ::= selcollist COMMA */
 {yylhsminor.yy165 = yymsp[-1].minor.yy165;}
   yymsp[-1].minor.yy165 = yylhsminor.yy165;
         break;
-      case 183: /* sclp ::= */
-      case 215: /* orderby_opt ::= */ yytestcase(yyruleno==215);
+      case 182: /* sclp ::= */
+      case 214: /* orderby_opt ::= */ yytestcase(yyruleno==214);
 {yymsp[1].minor.yy165 = 0;}
         break;
-      case 184: /* selcollist ::= sclp distinct expr as */
+      case 183: /* selcollist ::= sclp distinct expr as */
 {
    yylhsminor.yy165 = tSqlExprListAppend(yymsp[-3].minor.yy165, yymsp[-1].minor.yy202,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
   yymsp[-3].minor.yy165 = yylhsminor.yy165;
         break;
-      case 185: /* selcollist ::= sclp STAR */
+      case 184: /* selcollist ::= sclp STAR */
 {
    tSqlExpr *pNode = tSqlExprCreateIdValue(NULL, TK_ALL);
    yylhsminor.yy165 = tSqlExprListAppend(yymsp[-1].minor.yy165, pNode, 0, 0);
 }
   yymsp[-1].minor.yy165 = yylhsminor.yy165;
         break;
-      case 186: /* as ::= AS ids */
+      case 185: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 187: /* as ::= ids */
+      case 186: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 188: /* as ::= */
+      case 187: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 189: /* distinct ::= DISTINCT */
+      case 188: /* distinct ::= DISTINCT */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;  }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 191: /* from ::= FROM tablelist */
-      case 192: /* from ::= FROM sub */ yytestcase(yyruleno==192);
+      case 190: /* from ::= FROM tablelist */
+      case 191: /* from ::= FROM sub */ yytestcase(yyruleno==191);
 {yymsp[-1].minor.yy10 = yymsp[0].minor.yy10;}
         break;
-      case 193: /* sub ::= LP union RP */
+      case 192: /* sub ::= LP union RP */
 {yymsp[-2].minor.yy10 = addSubquery(NULL, yymsp[-1].minor.yy503, NULL);}
         break;
-      case 194: /* sub ::= LP union RP ids */
+      case 193: /* sub ::= LP union RP ids */
 {yymsp[-3].minor.yy10 = addSubquery(NULL, yymsp[-2].minor.yy503, &yymsp[0].minor.yy0);}
         break;
-      case 195: /* sub ::= sub COMMA LP union RP ids */
+      case 194: /* sub ::= sub COMMA LP union RP ids */
 {yylhsminor.yy10 = addSubquery(yymsp[-5].minor.yy10, yymsp[-2].minor.yy503, &yymsp[0].minor.yy0);}
   yymsp[-5].minor.yy10 = yylhsminor.yy10;
         break;
-      case 196: /* tablelist ::= ids cpxName */
+      case 195: /* tablelist ::= ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
   yylhsminor.yy10 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
 }
   yymsp[-1].minor.yy10 = yylhsminor.yy10;
         break;
-      case 197: /* tablelist ::= ids cpxName ids */
+      case 196: /* tablelist ::= ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
   yylhsminor.yy10 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
   yymsp[-2].minor.yy10 = yylhsminor.yy10;
         break;
-      case 198: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 197: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
   yylhsminor.yy10 = setTableNameList(yymsp[-3].minor.yy10, &yymsp[-1].minor.yy0, NULL);
 }
   yymsp[-3].minor.yy10 = yylhsminor.yy10;
         break;
-      case 199: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 198: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
   yylhsminor.yy10 = setTableNameList(yymsp[-4].minor.yy10, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
   yymsp[-4].minor.yy10 = yylhsminor.yy10;
         break;
-      case 200: /* tmvar ::= VARIABLE */
+      case 199: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 201: /* interval_option ::= intervalKey LP tmvar RP */
+      case 200: /* interval_option ::= intervalKey LP tmvar RP */
 {yylhsminor.yy532.interval = yymsp[-1].minor.yy0; yylhsminor.yy532.offset.n = 0; yylhsminor.yy532.token = yymsp[-3].minor.yy46;}
   yymsp[-3].minor.yy532 = yylhsminor.yy532;
         break;
-      case 202: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
+      case 201: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
 {yylhsminor.yy532.interval = yymsp[-3].minor.yy0; yylhsminor.yy532.offset = yymsp[-1].minor.yy0;   yylhsminor.yy532.token = yymsp[-5].minor.yy46;}
   yymsp[-5].minor.yy532 = yylhsminor.yy532;
         break;
-      case 203: /* interval_option ::= */
+      case 202: /* interval_option ::= */
 {memset(&yymsp[1].minor.yy532, 0, sizeof(yymsp[1].minor.yy532));}
         break;
-      case 204: /* intervalKey ::= INTERVAL */
+      case 203: /* intervalKey ::= INTERVAL */
 {yymsp[0].minor.yy46 = TK_INTERVAL;}
         break;
-      case 205: /* intervalKey ::= EVERY */
+      case 204: /* intervalKey ::= EVERY */
 {yymsp[0].minor.yy46 = TK_EVERY;   }
         break;
-      case 206: /* session_option ::= */
+      case 205: /* session_option ::= */
 {yymsp[1].minor.yy97.col.n = 0; yymsp[1].minor.yy97.gap.n = 0;}
         break;
-      case 207: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+      case 206: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
 {
    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
    yymsp[-6].minor.yy97.col = yymsp[-4].minor.yy0;
    yymsp[-6].minor.yy97.gap = yymsp[-1].minor.yy0;
 }
         break;
-      case 208: /* windowstate_option ::= */
+      case 207: /* windowstate_option ::= */
 { yymsp[1].minor.yy6.col.n = 0; yymsp[1].minor.yy6.col.z = NULL;}
         break;
-      case 209: /* windowstate_option ::= STATE_WINDOW LP ids RP */
+      case 208: /* windowstate_option ::= STATE_WINDOW LP ids RP */
 { yymsp[-3].minor.yy6.col = yymsp[-1].minor.yy0; }
         break;
-      case 210: /* fill_opt ::= */
+      case 209: /* fill_opt ::= */
 { yymsp[1].minor.yy165 = 0;     }
         break;
-      case 211: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 210: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     SVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
@@ -2928,34 +2923,34 @@ static void yy_reduce(
     yymsp[-5].minor.yy165 = yymsp[-1].minor.yy165;
 }
         break;
-      case 212: /* fill_opt ::= FILL LP ID RP */
+      case 211: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
     yymsp[-3].minor.yy165 = tListItemAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 213: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 212: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 214: /* sliding_opt ::= */
+      case 213: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 216: /* orderby_opt ::= ORDER BY sortlist */
+      case 215: /* orderby_opt ::= ORDER BY sortlist */
 {yymsp[-2].minor.yy165 = yymsp[0].minor.yy165;}
         break;
-      case 217: /* sortlist ::= sortlist COMMA item sortorder */
+      case 216: /* sortlist ::= sortlist COMMA item sortorder */
 {
     yylhsminor.yy165 = tListItemAppend(yymsp[-3].minor.yy165, &yymsp[-1].minor.yy425, yymsp[0].minor.yy47);
 }
   yymsp[-3].minor.yy165 = yylhsminor.yy165;
         break;
-      case 218: /* sortlist ::= item sortorder */
+      case 217: /* sortlist ::= item sortorder */
 {
   yylhsminor.yy165 = tListItemAppend(NULL, &yymsp[-1].minor.yy425, yymsp[0].minor.yy47);
 }
   yymsp[-1].minor.yy165 = yylhsminor.yy165;
         break;
-      case 219: /* item ::= ids cpxName */
+      case 218: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2964,235 +2959,235 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy425 = yylhsminor.yy425;
         break;
-      case 220: /* sortorder ::= ASC */
+      case 219: /* sortorder ::= ASC */
 { yymsp[0].minor.yy47 = TSDB_ORDER_ASC; }
         break;
-      case 221: /* sortorder ::= DESC */
+      case 220: /* sortorder ::= DESC */
 { yymsp[0].minor.yy47 = TSDB_ORDER_DESC;}
         break;
-      case 222: /* sortorder ::= */
+      case 221: /* sortorder ::= */
 { yymsp[1].minor.yy47 = TSDB_ORDER_ASC; }
         break;
-      case 223: /* groupby_opt ::= */
+      case 222: /* groupby_opt ::= */
 { yymsp[1].minor.yy165 = 0;}
         break;
-      case 224: /* groupby_opt ::= GROUP BY grouplist */
+      case 223: /* groupby_opt ::= GROUP BY grouplist */
 { yymsp[-2].minor.yy165 = yymsp[0].minor.yy165;}
         break;
-      case 225: /* grouplist ::= grouplist COMMA item */
+      case 224: /* grouplist ::= grouplist COMMA item */
 {
   yylhsminor.yy165 = tListItemAppend(yymsp[-2].minor.yy165, &yymsp[0].minor.yy425, -1);
 }
   yymsp[-2].minor.yy165 = yylhsminor.yy165;
         break;
-      case 226: /* grouplist ::= item */
+      case 225: /* grouplist ::= item */
 {
   yylhsminor.yy165 = tListItemAppend(NULL, &yymsp[0].minor.yy425, -1);
 }
   yymsp[0].minor.yy165 = yylhsminor.yy165;
         break;
-      case 227: /* having_opt ::= */
-      case 237: /* where_opt ::= */ yytestcase(yyruleno==237);
-      case 281: /* expritem ::= */ yytestcase(yyruleno==281);
+      case 226: /* having_opt ::= */
+      case 236: /* where_opt ::= */ yytestcase(yyruleno==236);
+      case 280: /* expritem ::= */ yytestcase(yyruleno==280);
 {yymsp[1].minor.yy202 = 0;}
         break;
-      case 228: /* having_opt ::= HAVING expr */
-      case 238: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==238);
+      case 227: /* having_opt ::= HAVING expr */
+      case 237: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==237);
 {yymsp[-1].minor.yy202 = yymsp[0].minor.yy202;}
         break;
-      case 229: /* limit_opt ::= */
-      case 233: /* slimit_opt ::= */ yytestcase(yyruleno==233);
+      case 228: /* limit_opt ::= */
+      case 232: /* slimit_opt ::= */ yytestcase(yyruleno==232);
 {yymsp[1].minor.yy367.limit = -1; yymsp[1].minor.yy367.offset = 0;}
         break;
-      case 230: /* limit_opt ::= LIMIT signed */
-      case 234: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==234);
+      case 229: /* limit_opt ::= LIMIT signed */
+      case 233: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==233);
 {yymsp[-1].minor.yy367.limit = yymsp[0].minor.yy207;  yymsp[-1].minor.yy367.offset = 0;}
         break;
-      case 231: /* limit_opt ::= LIMIT signed OFFSET signed */
+      case 230: /* limit_opt ::= LIMIT signed OFFSET signed */
 { yymsp[-3].minor.yy367.limit = yymsp[-2].minor.yy207;  yymsp[-3].minor.yy367.offset = yymsp[0].minor.yy207;}
         break;
-      case 232: /* limit_opt ::= LIMIT signed COMMA signed */
+      case 231: /* limit_opt ::= LIMIT signed COMMA signed */
 { yymsp[-3].minor.yy367.limit = yymsp[0].minor.yy207;  yymsp[-3].minor.yy367.offset = yymsp[-2].minor.yy207;}
         break;
-      case 235: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+      case 234: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
 {yymsp[-3].minor.yy367.limit = yymsp[-2].minor.yy207;  yymsp[-3].minor.yy367.offset = yymsp[0].minor.yy207;}
         break;
-      case 236: /* slimit_opt ::= SLIMIT signed COMMA signed */
+      case 235: /* slimit_opt ::= SLIMIT signed COMMA signed */
 {yymsp[-3].minor.yy367.limit = yymsp[0].minor.yy207;  yymsp[-3].minor.yy367.offset = yymsp[-2].minor.yy207;}
         break;
-      case 239: /* expr ::= LP expr RP */
+      case 238: /* expr ::= LP expr RP */
 {yylhsminor.yy202 = yymsp[-1].minor.yy202; yylhsminor.yy202->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy202->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 240: /* expr ::= ID */
+      case 239: /* expr ::= ID */
 { yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);}
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 241: /* expr ::= ID DOT ID */
+      case 240: /* expr ::= ID DOT ID */
 { yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 242: /* expr ::= ID DOT STAR */
+      case 241: /* expr ::= ID DOT STAR */
 { yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 243: /* expr ::= INTEGER */
+      case 242: /* expr ::= INTEGER */
 { yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);}
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 244: /* expr ::= MINUS INTEGER */
-      case 245: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==245);
+      case 243: /* expr ::= MINUS INTEGER */
+      case 244: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==244);
 { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);}
   yymsp[-1].minor.yy202 = yylhsminor.yy202;
         break;
-      case 246: /* expr ::= FLOAT */
+      case 245: /* expr ::= FLOAT */
 { yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);}
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 247: /* expr ::= MINUS FLOAT */
-      case 248: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==248);
+      case 246: /* expr ::= MINUS FLOAT */
+      case 247: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==247);
 { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);}
   yymsp[-1].minor.yy202 = yylhsminor.yy202;
         break;
-      case 249: /* expr ::= STRING */
+      case 248: /* expr ::= STRING */
 { yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);}
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 250: /* expr ::= NOW */
+      case 249: /* expr ::= NOW */
 { yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); }
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 251: /* expr ::= VARIABLE */
+      case 250: /* expr ::= VARIABLE */
 { yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);}
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 252: /* expr ::= PLUS VARIABLE */
-      case 253: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==253);
+      case 251: /* expr ::= PLUS VARIABLE */
+      case 252: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==252);
 { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);}
   yymsp[-1].minor.yy202 = yylhsminor.yy202;
         break;
-      case 254: /* expr ::= BOOL */
+      case 253: /* expr ::= BOOL */
 { yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);}
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 255: /* expr ::= NULL */
+      case 254: /* expr ::= NULL */
 { yylhsminor.yy202 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);}
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 256: /* expr ::= ID LP exprlist RP */
+      case 255: /* expr ::= ID LP exprlist RP */
 { tRecordFuncName(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy202 = tSqlExprCreateFunction(yymsp[-1].minor.yy165, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
   yymsp[-3].minor.yy202 = yylhsminor.yy202;
         break;
-      case 257: /* expr ::= ID LP STAR RP */
+      case 256: /* expr ::= ID LP STAR RP */
 { tRecordFuncName(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy202 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
   yymsp[-3].minor.yy202 = yylhsminor.yy202;
         break;
-      case 258: /* expr ::= expr IS NULL */
+      case 257: /* expr ::= expr IS NULL */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, NULL, TK_ISNULL);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 259: /* expr ::= expr IS NOT NULL */
+      case 258: /* expr ::= expr IS NOT NULL */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-3].minor.yy202, NULL, TK_NOTNULL);}
   yymsp[-3].minor.yy202 = yylhsminor.yy202;
         break;
-      case 260: /* expr ::= expr LT expr */
+      case 259: /* expr ::= expr LT expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_LT);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 261: /* expr ::= expr GT expr */
+      case 260: /* expr ::= expr GT expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_GT);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 262: /* expr ::= expr LE expr */
+      case 261: /* expr ::= expr LE expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_LE);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 263: /* expr ::= expr GE expr */
+      case 262: /* expr ::= expr GE expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_GE);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 264: /* expr ::= expr NE expr */
+      case 263: /* expr ::= expr NE expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_NE);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 265: /* expr ::= expr EQ expr */
+      case 264: /* expr ::= expr EQ expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_EQ);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 266: /* expr ::= expr BETWEEN expr AND expr */
+      case 265: /* expr ::= expr BETWEEN expr AND expr */
 { tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy202); yylhsminor.yy202 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy202, yymsp[-2].minor.yy202, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy202, TK_LE), TK_AND);}
   yymsp[-4].minor.yy202 = yylhsminor.yy202;
         break;
-      case 267: /* expr ::= expr AND expr */
+      case 266: /* expr ::= expr AND expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_AND);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 268: /* expr ::= expr OR expr */
+      case 267: /* expr ::= expr OR expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_OR); }
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 269: /* expr ::= expr PLUS expr */
+      case 268: /* expr ::= expr PLUS expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_PLUS);  }
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 270: /* expr ::= expr MINUS expr */
+      case 269: /* expr ::= expr MINUS expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_MINUS); }
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 271: /* expr ::= expr STAR expr */
+      case 270: /* expr ::= expr STAR expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_STAR);  }
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 272: /* expr ::= expr SLASH expr */
+      case 271: /* expr ::= expr SLASH expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_DIVIDE);}
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 273: /* expr ::= expr REM expr */
+      case 272: /* expr ::= expr REM expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_REM);   }
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 274: /* expr ::= expr LIKE expr */
+      case 273: /* expr ::= expr LIKE expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_LIKE);  }
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 275: /* expr ::= expr MATCH expr */
+      case 274: /* expr ::= expr MATCH expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_MATCH);  }
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 276: /* expr ::= expr NMATCH expr */
+      case 275: /* expr ::= expr NMATCH expr */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-2].minor.yy202, yymsp[0].minor.yy202, TK_NMATCH);  }
   yymsp[-2].minor.yy202 = yylhsminor.yy202;
         break;
-      case 277: /* expr ::= expr IN LP exprlist RP */
+      case 276: /* expr ::= expr IN LP exprlist RP */
 {yylhsminor.yy202 = tSqlExprCreate(yymsp[-4].minor.yy202, (tSqlExpr*)yymsp[-1].minor.yy165, TK_IN); }
   yymsp[-4].minor.yy202 = yylhsminor.yy202;
         break;
-      case 278: /* exprlist ::= exprlist COMMA expritem */
+      case 277: /* exprlist ::= exprlist COMMA expritem */
 {yylhsminor.yy165 = tSqlExprListAppend(yymsp[-2].minor.yy165,yymsp[0].minor.yy202,0, 0);}
   yymsp[-2].minor.yy165 = yylhsminor.yy165;
         break;
-      case 279: /* exprlist ::= expritem */
+      case 278: /* exprlist ::= expritem */
 {yylhsminor.yy165 = tSqlExprListAppend(0,yymsp[0].minor.yy202,0, 0);}
   yymsp[0].minor.yy165 = yylhsminor.yy165;
         break;
-      case 280: /* expritem ::= expr */
+      case 279: /* expritem ::= expr */
 {yylhsminor.yy202 = yymsp[0].minor.yy202;}
   yymsp[0].minor.yy202 = yylhsminor.yy202;
         break;
-      case 282: /* cmd ::= RESET QUERY CACHE */
+      case 281: /* cmd ::= RESET QUERY CACHE */
 { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 283: /* cmd ::= SYNCDB ids REPLICA */
+      case 282: /* cmd ::= SYNCDB ids REPLICA */
 { setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);}
         break;
-      case 284: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 283: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 285: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 284: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     toTSDBType(yymsp[0].minor.yy0.type);
@@ -3201,21 +3196,21 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 286: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+      case 285: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 287: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 286: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 288: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 287: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3226,7 +3221,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 289: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 288: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3240,7 +3235,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 290: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 289: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
@@ -3252,21 +3247,21 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 291: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+      case 290: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 292: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+      case 291: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 293: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+      case 292: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3277,21 +3272,21 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 294: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+      case 293: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 295: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+      case 294: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 296: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+      case 295: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3302,7 +3297,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 297: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+      case 296: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3316,7 +3311,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 298: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+      case 297: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
@@ -3328,20 +3323,20 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 299: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+      case 298: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 300: /* cmd ::= KILL CONNECTION INTEGER */
+      case 299: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 301: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 300: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
         break;
-      case 302: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 301: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
       default:
diff --git a/source/libs/parser/test/parserTests.cpp b/source/libs/parser/test/parserTests.cpp
index a67a9a8be8..fe430c5f5e 100644
--- a/source/libs/parser/test/parserTests.cpp
+++ b/source/libs/parser/test/parserTests.cpp
@@ -714,10 +714,9 @@ TEST(testCase, show_user_Test) {
   SSqlInfo info1 = doGenerateAST(sql1);
   ASSERT_EQ(info1.valid, true);
 
-  SDclStmtInfo output;
   SParseBasicCtx ct= {.requestId = 1, .acctId = 1, .db = "abc", .pTransporter = NULL};
-  int32_t code = qParserValidateDclSqlNode(&info1, &ct, &output, msg, buf.len);
-  ASSERT_EQ(code, 0);
+  SDclStmtInfo* output = qParserValidateDclSqlNode(&info1, &ct, msg, buf.len);
+  ASSERT_NE(output, nullptr);
 
   // convert the show command to be the select query
   // select name, privilege, create_time, account from information_schema.users;
@@ -735,10 +734,9 @@ TEST(testCase, create_user_Test) {
   ASSERT_EQ(info1.valid, true);
   ASSERT_EQ(isDclSqlStatement(&info1), true);
 
-  SDclStmtInfo output;
   SParseBasicCtx ct= {.requestId = 1, .acctId = 1, .db = "abc"};
-  int32_t code = qParserValidateDclSqlNode(&info1, &ct, &output, msg, buf.len);
-  ASSERT_EQ(code, 0);
+  SDclStmtInfo* output = qParserValidateDclSqlNode(&info1, &ct, msg, buf.len);
+  ASSERT_NE(output, nullptr);
 
   destroySqlInfo(&info1);
 }
\ No newline at end of file
diff --git a/source/libs/planner/CMakeLists.txt b/source/libs/planner/CMakeLists.txt
index 7f8c118663..6234dbe0ac 100644
--- a/source/libs/planner/CMakeLists.txt
+++ b/source/libs/planner/CMakeLists.txt
@@ -11,4 +11,6 @@ target_link_libraries(
     PRIVATE os util catalog cjson parser transport function qcom
 )
 
-ADD_SUBDIRECTORY(test)
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
diff --git a/source/libs/planner/inc/plannerInt.h b/source/libs/planner/inc/plannerInt.h
index 61d622155f..a14bc29cd3 100644
--- a/source/libs/planner/inc/plannerInt.h
+++ b/source/libs/planner/inc/plannerInt.h
@@ -40,7 +40,7 @@ extern "C" {
 #define QNODE_SESSIONWINDOW 12
 #define QNODE_STATEWINDOW   13
 #define QNODE_FILL          14
-#define QNODE_INSERT        15
+#define QNODE_MODIFY        15
 
 typedef struct SQueryDistPlanNodeInfo {
   bool      stableQuery;   // super table query or not
@@ -70,6 +70,11 @@ typedef struct SQueryPlanNode {
   struct SQueryPlanNode  *pParent;
 } SQueryPlanNode;
 
+typedef struct SDataPayloadInfo {
+  int32_t msgType;
+  SArray *payload;
+} SDataPayloadInfo;
+
 /**
  * Optimize the query execution plan, currently not implement yet.
  * @param pQueryNode
diff --git a/source/libs/planner/src/logicPlan.c b/source/libs/planner/src/logicPlan.c
index 136073aa60..2de0ae2da3 100644
--- a/source/libs/planner/src/logicPlan.c
+++ b/source/libs/planner/src/logicPlan.c
@@ -37,15 +37,29 @@ int32_t optimizeQueryPlan(struct SQueryPlanNode* pQueryNode) {
   return 0;
 }
 
-int32_t createInsertPlan(const SInsertStmtInfo* pInsert, SQueryPlanNode** pQueryPlan) {
+static int32_t createModificationOpPlan(const SQueryNode* pNode, SQueryPlanNode** pQueryPlan) {
+  SInsertStmtInfo* pInsert = (SInsertStmtInfo*)pNode;
+
   *pQueryPlan = calloc(1, sizeof(SQueryPlanNode));
   SArray* blocks = taosArrayInit(taosArrayGetSize(pInsert->pDataBlocks), POINTER_BYTES);
-  if (NULL == *pQueryPlan || NULL == blocks) {
+
+  SDataPayloadInfo* pPayload = calloc(1, sizeof(SDataPayloadInfo));
+  if (NULL == *pQueryPlan || NULL == blocks || NULL == pPayload) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
-  (*pQueryPlan)->info.type = QNODE_INSERT;
+
+  (*pQueryPlan)->info.type = QNODE_MODIFY;
   taosArrayAddAll(blocks, pInsert->pDataBlocks);
-  (*pQueryPlan)->pExtInfo = blocks;
+
+  if (pNode->type == TSDB_SQL_INSERT) {
+    pPayload->msgType = TDMT_VND_SUBMIT;
+  } else if (pNode->type == TSDB_SQL_CREATE_TABLE) {
+    pPayload->msgType = TDMT_VND_CREATE_TABLE;
+  }
+
+  pPayload->payload = blocks;
+  (*pQueryPlan)->pExtInfo = pPayload;
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -62,13 +76,14 @@ int32_t createQueryPlan(const SQueryNode* pNode, SQueryPlanNode** pQueryPlan) {
     case TSDB_SQL_SELECT: {
       return createSelectPlan((const SQueryStmtInfo*)pNode, pQueryPlan);
     }
+
     case TSDB_SQL_INSERT:
-      return createInsertPlan((const SInsertStmtInfo*)pNode, pQueryPlan);
+    case TSDB_SQL_CREATE_TABLE:
+      return createModificationOpPlan(pNode, pQueryPlan);
+
     default:
       return TSDB_CODE_FAILED;
   }
-
-  return TSDB_CODE_SUCCESS;
 }
 
 int32_t queryPlanToSql(struct SQueryPlanNode* pQueryNode, char** sql) {
diff --git a/source/libs/planner/src/physicalPlan.c b/source/libs/planner/src/physicalPlan.c
index 715090d4b3..202b31d6b8 100644
--- a/source/libs/planner/src/physicalPlan.c
+++ b/source/libs/planner/src/physicalPlan.c
@@ -34,7 +34,7 @@ static const char* gOpName[] = {
 #undef INCLUDE_AS_NAME
 };
 
-static void* vailidPointer(void* p) {
+static void* validPointer(void* p) {
   if (NULL == p) {
     THROW(TSDB_CODE_TSC_OUT_OF_MEMORY);
   }
@@ -76,7 +76,7 @@ int32_t dsinkNameToDsinkType(const char* name) {
 }
 
 static SDataSink* initDataSink(int32_t type, int32_t size) {
-  SDataSink* sink = (SDataSink*)vailidPointer(calloc(1, size));
+  SDataSink* sink = (SDataSink*)validPointer(calloc(1, size));
   sink->info.type = type;
   sink->info.name = dsinkTypeToDsinkName(type);
   return sink;
@@ -121,7 +121,7 @@ static bool cloneExprArray(SArray** dst, SArray* src) {
 }
 
 static SPhyNode* initPhyNode(SQueryPlanNode* pPlanNode, int32_t type, int32_t size) {
-  SPhyNode* node = (SPhyNode*)vailidPointer(calloc(1, size));
+  SPhyNode* node = (SPhyNode*)validPointer(calloc(1, size));
   node->info.type = type;
   node->info.name = opTypeToOpName(type);
   if (!cloneExprArray(&node->pTargets, pPlanNode->pExpr) || !toDataBlockSchema(pPlanNode, &(node->targetSchema))) {
@@ -184,27 +184,30 @@ static SPhyNode* createMultiTableScanNode(SQueryPlanNode* pPlanNode, SQueryTable
 }
 
 static SSubplan* initSubplan(SPlanContext* pCxt, int32_t type) {
-  SSubplan* subplan = vailidPointer(calloc(1, sizeof(SSubplan)));
+  SSubplan* subplan = validPointer(calloc(1, sizeof(SSubplan)));
   subplan->id = pCxt->nextId;
   ++(pCxt->nextId.subplanId);
   subplan->type = type;
   subplan->level = 0;
   if (NULL != pCxt->pCurrentSubplan) {
     subplan->level = pCxt->pCurrentSubplan->level + 1;
-    if (NULL == pCxt->pCurrentSubplan->pChildern) {
-      pCxt->pCurrentSubplan->pChildern = vailidPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
+    if (NULL == pCxt->pCurrentSubplan->pChildren) {
+      pCxt->pCurrentSubplan->pChildren = validPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
     }
-    taosArrayPush(pCxt->pCurrentSubplan->pChildern, &subplan);
-    subplan->pParents = vailidPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
+
+    taosArrayPush(pCxt->pCurrentSubplan->pChildren, &subplan);
+    subplan->pParents = validPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
     taosArrayPush(subplan->pParents, &pCxt->pCurrentSubplan);
   }
+
   SArray* currentLevel;
   if (subplan->level >= taosArrayGetSize(pCxt->pDag->pSubplans)) {
-    currentLevel = vailidPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
+    currentLevel = validPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
     taosArrayPush(pCxt->pDag->pSubplans, &currentLevel);
   } else {
     currentLevel = taosArrayGetP(pCxt->pDag->pSubplans, subplan->level);
   }
+
   taosArrayPush(currentLevel, &subplan);
   pCxt->pCurrentSubplan = subplan;
   ++(pCxt->pDag->numOfSubplans);
@@ -272,12 +275,13 @@ static SPhyNode* createPhyNode(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
     case QNODE_TABLESCAN:
       node = createTableScanNode(pCxt, pPlanNode);
       break;
-    case QNODE_INSERT:
+    case QNODE_MODIFY:
       // Insert is not an operator in a physical plan.
       break;
     default:
       assert(false);
   }
+
   if (pPlanNode->pChildren != NULL && taosArrayGetSize(pPlanNode->pChildren) > 0) {
     node->pChildren = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES);
     size_t size = taosArrayGetSize(pPlanNode->pChildren);
@@ -287,31 +291,38 @@ static SPhyNode* createPhyNode(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
       taosArrayPush(node->pChildren, &child);
     }
   }
+
   return node;
 }
 
-static void splitInsertSubplan(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
-  SArray* vgs = (SArray*)pPlanNode->pExtInfo;
-  size_t numOfVg = taosArrayGetSize(vgs);
-  for (int32_t i = 0; i < numOfVg; ++i) {
+static void splitModificationOpSubPlan(SPlanContext* pCxt, SQueryPlanNode* pPlanNode) {
+  SDataPayloadInfo* pPayload = (SDataPayloadInfo*) pPlanNode->pExtInfo;
+
+  size_t numOfVgroups = taosArrayGetSize(pPayload->payload);
+  for (int32_t i = 0; i < numOfVgroups; ++i) {
     STORE_CURRENT_SUBPLAN(pCxt);
     SSubplan* subplan = initSubplan(pCxt, QUERY_TYPE_MODIFY);
-    SVgDataBlocks* blocks = (SVgDataBlocks*)taosArrayGetP(vgs, i);
+    SVgDataBlocks* blocks = (SVgDataBlocks*)taosArrayGetP(pPayload->payload, i);
+
     vgroupInfoToEpSet(&blocks->vg, &subplan->execNode);
-    subplan->pNode = NULL;
     subplan->pDataSink = createDataInserter(pCxt, blocks);
-    subplan->type = QUERY_TYPE_MODIFY;
+    subplan->pNode   = NULL;
+    subplan->type    = QUERY_TYPE_MODIFY;
+    subplan->msgType = pPayload->msgType;
+
     RECOVERY_CURRENT_SUBPLAN(pCxt);
   }
 }
 
 static void createSubplanByLevel(SPlanContext* pCxt, SQueryPlanNode* pRoot) {
-  if (QNODE_INSERT == pRoot->info.type) {
-    splitInsertSubplan(pCxt, pRoot);
+  if (QNODE_MODIFY == pRoot->info.type) {
+    splitModificationOpSubPlan(pCxt, pRoot);
   } else {
-    SSubplan* subplan = initSubplan(pCxt, QUERY_TYPE_MERGE);
+    SSubplan* subplan  = initSubplan(pCxt, QUERY_TYPE_MERGE);
     ++(pCxt->nextId.templateId);
-    subplan->pNode = createPhyNode(pCxt, pRoot);
+
+    subplan->msgType   = TDMT_VND_QUERY;
+    subplan->pNode     = createPhyNode(pCxt, pRoot);
     subplan->pDataSink = createDataDispatcher(pCxt, pRoot);
   }
   // todo deal subquery
@@ -321,12 +332,13 @@ int32_t createDag(SQueryPlanNode* pQueryNode, struct SCatalog* pCatalog, SQueryD
   TRY(TSDB_MAX_TAG_CONDITIONS) {
     SPlanContext context = {
       .pCatalog = pCatalog,
-      .pDag = vailidPointer(calloc(1, sizeof(SQueryDag))),
+      .pDag = validPointer(calloc(1, sizeof(SQueryDag))),
       .pCurrentSubplan = NULL,
       .nextId = {0} // todo queryid
     };
+
     *pDag = context.pDag;
-    context.pDag->pSubplans = vailidPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
+    context.pDag->pSubplans = validPointer(taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES));
     createSubplanByLevel(&context, pQueryNode);
   } CATCH(code) {
     CLEANUP_EXECUTE();
diff --git a/source/libs/planner/src/physicalPlanJson.c b/source/libs/planner/src/physicalPlanJson.c
index 9b2c9c1796..b25d9a3627 100644
--- a/source/libs/planner/src/physicalPlanJson.c
+++ b/source/libs/planner/src/physicalPlanJson.c
@@ -793,7 +793,7 @@ static cJSON* subplanToJson(const SSubplan* subplan) {
     return NULL;
   }
 
-  // The 'type', 'level', 'execEpSet', 'pChildern' and 'pParents' fields do not need to be serialized.
+  // The 'type', 'level', 'execEpSet', 'pChildren' and 'pParents' fields do not need to be serialized.
 
   bool res = addObject(jSubplan, jkSubplanId, subplanIdToJson, &subplan->id);
   if (res) {
@@ -835,7 +835,7 @@ int32_t subPlanToString(const SSubplan* subplan, char** str, int32_t* len) {
     SDataInserter* insert = (SDataInserter*)(subplan->pDataSink);
     *len = insert->size;
     *str = insert->pData;
-    insert->pData == NULL;
+    insert->pData = NULL;
     return TSDB_CODE_SUCCESS;
   }
 
@@ -844,6 +844,7 @@ int32_t subPlanToString(const SSubplan* subplan, char** str, int32_t* len) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return TSDB_CODE_FAILED;
   }
+
   *str = cJSON_Print(json);
   *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 96556ee3ff..d0a42c9047 100644
--- a/source/libs/planner/src/planner.c
+++ b/source/libs/planner/src/planner.c
@@ -31,17 +31,20 @@ int32_t qCreateQueryDag(const struct SQueryNode* pNode, struct SQueryDag** pDag)
     destroyQueryPlan(logicPlan);
     return code;
   }
+
   code = optimizeQueryPlan(logicPlan);
   if (TSDB_CODE_SUCCESS != code) {
     destroyQueryPlan(logicPlan);
     return code;
   }
+
   code = createDag(logicPlan, NULL, pDag);
   if (TSDB_CODE_SUCCESS != code) {
     destroyQueryPlan(logicPlan);
     qDestroyQueryDag(*pDag);
     return code;
   }
+
   destroyQueryPlan(logicPlan);
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/libs/qcom/CMakeLists.txt b/source/libs/qcom/CMakeLists.txt
index 8e09f3d97a..c63e54fb9b 100644
--- a/source/libs/qcom/CMakeLists.txt
+++ b/source/libs/qcom/CMakeLists.txt
@@ -7,8 +7,10 @@ target_include_directories(
 )
 
 target_link_libraries(
-   qcom
-   PRIVATE os util transport
+    qcom
+    PRIVATE os util transport
 )
 
-ADD_SUBDIRECTORY(test)
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
diff --git a/source/libs/qworker/CMakeLists.txt b/source/libs/qworker/CMakeLists.txt
index 001756d7c3..ea3e97057b 100644
--- a/source/libs/qworker/CMakeLists.txt
+++ b/source/libs/qworker/CMakeLists.txt
@@ -11,4 +11,6 @@ target_link_libraries(
    PRIVATE os util transport planner qcom
 )
 
-ADD_SUBDIRECTORY(test)
\ No newline at end of file
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
\ No newline at end of file
diff --git a/source/libs/scheduler/CMakeLists.txt b/source/libs/scheduler/CMakeLists.txt
index 6baaab1ef4..4e297f4e17 100644
--- a/source/libs/scheduler/CMakeLists.txt
+++ b/source/libs/scheduler/CMakeLists.txt
@@ -12,4 +12,6 @@ target_link_libraries(
         PRIVATE os util planner qcom common catalog transport
 )
 
-ADD_SUBDIRECTORY(test)
\ No newline at end of file
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
\ No newline at end of file
diff --git a/source/libs/scheduler/src/scheduler.c b/source/libs/scheduler/src/scheduler.c
index 68ccb16fc3..22556f742b 100644
--- a/source/libs/scheduler/src/scheduler.c
+++ b/source/libs/scheduler/src/scheduler.c
@@ -28,7 +28,7 @@ int32_t schBuildTaskRalation(SSchJob *job, SHashObj *planToTask) {
     for (int32_t m = 0; m < level->taskNum; ++m) {
       SSchTask *task = taosArrayGet(level->subTasks, m);
       SSubplan *plan = task->plan;
-      int32_t childNum = plan->pChildern ? (int32_t)taosArrayGetSize(plan->pChildern) : 0;
+      int32_t childNum = plan->pChildren ? (int32_t)taosArrayGetSize(plan->pChildren) : 0;
       int32_t parentNum = plan->pParents ? (int32_t)taosArrayGetSize(plan->pParents) : 0;
 
       if (childNum > 0) {
@@ -40,7 +40,7 @@ int32_t schBuildTaskRalation(SSchJob *job, SHashObj *planToTask) {
       }
 
       for (int32_t n = 0; n < childNum; ++n) {
-        SSubplan **child = taosArrayGet(plan->pChildern, n);
+        SSubplan **child = taosArrayGet(plan->pChildren, n);
         SSchTask **childTask = taosHashGet(planToTask, child, POINTER_BYTES);
         if (NULL == childTask || NULL == *childTask) {
           qError("subplan relationship error, level:%d, taskIdx:%d, childIdx:%d", i, m, n);
@@ -122,6 +122,7 @@ int32_t schValidateAndBuildJob(SQueryDag *dag, SSchJob *job) {
     SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY);
   }
 
+  //??
   job->attr.needFetch = true;
   
   job->levelNum = levelNum;
@@ -478,15 +479,27 @@ int32_t schProcessOnTaskFailure(SSchJob *job, SSchTask *task, int32_t errCode) {
 
 int32_t schProcessRspMsg(SSchJob *job, SSchTask *task, int32_t msgType, char *msg, int32_t msgSize, int32_t rspCode) {
   int32_t code = 0;
-  
+
+
   switch (msgType) {
+    case TDMT_VND_CREATE_TABLE_RSP: {
+      if (rspCode != TSDB_CODE_SUCCESS) {
+        SCH_ERR_JRET(schProcessOnTaskFailure(job, task, rspCode));
+      } else {
+//        job->resNumOfRows += rsp->affectedRows;
+        code = schProcessOnTaskSuccess(job, task);
+        if (code) {
+          goto _task_error;
+        }
+      }
+    }
     case TDMT_VND_SUBMIT_RSP: {
-        SShellSubmitRspMsg *rsp = (SShellSubmitRspMsg *)msg;
-        if (rsp->code != TSDB_CODE_SUCCESS) {
-          SCH_ERR_JRET(schProcessOnTaskFailure(job, task, rsp->code));
+        if (rspCode != TSDB_CODE_SUCCESS) {
+          SCH_ERR_JRET(schProcessOnTaskFailure(job, task, rspCode));
         } else {
+          SShellSubmitRspMsg *rsp = (SShellSubmitRspMsg *)msg;
           job->resNumOfRows += rsp->affectedRows;
-          
+
           code = schProcessOnTaskSuccess(job, task);
           if (code) {
             goto _task_error;
@@ -570,22 +583,29 @@ int32_t schHandleCallback(void* param, const SDataBuf* pMsg, int32_t msgType, in
 
 _return:  
   tfree(param);
-
   SCH_RET(code);
 }
 
 int32_t schHandleSubmitCallback(void* param, const SDataBuf* pMsg, int32_t code) {
   return schHandleCallback(param, pMsg, TDMT_VND_SUBMIT_RSP, code);
 }
+
+int32_t schHandleCreateTableCallback(void* param, const SDataBuf* pMsg, int32_t code) {
+  return schHandleCallback(param, pMsg, TDMT_VND_CREATE_TABLE_RSP, code);
+}
+
 int32_t schHandleQueryCallback(void* param, const SDataBuf* pMsg, int32_t code) {
   return schHandleCallback(param, pMsg, TDMT_VND_QUERY_RSP, code);
 }
+
 int32_t schHandleFetchCallback(void* param, const SDataBuf* pMsg, int32_t code) {
   return schHandleCallback(param, pMsg, TDMT_VND_FETCH_RSP, code);
 }
+
 int32_t schHandleReadyCallback(void* param, const SDataBuf* pMsg, int32_t code) {
   return schHandleCallback(param, pMsg, TDMT_VND_RES_READY_RSP, code);
 }
+
 int32_t schHandleDropCallback(void* param, const SDataBuf* pMsg, int32_t code) {  
   SSchCallbackParam *pParam = (SSchCallbackParam *)param;
   qDebug("drop task rsp received, queryId:%"PRIx64 ",taksId:%"PRIx64 ",code:%d", pParam->queryId, pParam->taskId, code);
@@ -593,6 +613,9 @@ int32_t schHandleDropCallback(void* param, const SDataBuf* pMsg, int32_t code) {
 
 int32_t schGetCallbackFp(int32_t msgType, __async_send_cb_fn_t *fp) {
   switch (msgType) {
+    case TDMT_VND_CREATE_TABLE:
+      *fp = schHandleCreateTableCallback;
+      break;
     case TDMT_VND_SUBMIT: 
       *fp = schHandleSubmitCallback;
       break;
@@ -673,6 +696,7 @@ int32_t schBuildAndSendMsg(SSchJob *job, SSchTask *task, int32_t msgType) {
   int32_t code = 0;
   
   switch (msgType) {
+    case TDMT_VND_CREATE_TABLE:
     case TDMT_VND_SUBMIT: {
       if (NULL == task->msg || task->msgLen <= 0) {
         qError("submit msg is NULL");
@@ -789,19 +813,15 @@ int32_t schLaunchTask(SSchJob *job, SSchTask *task) {
     SCH_ERR_RET(TSDB_CODE_SCH_INTERNAL_ERROR);
   }
 
-  int32_t msgType = (plan->type == QUERY_TYPE_MODIFY) ? TDMT_VND_SUBMIT : TDMT_VND_QUERY;
+//  int32_t msgType = (plan->type == QUERY_TYPE_MODIFY)? TDMT_VND_SUBMIT : TDMT_VND_QUERY;
   
-  SCH_ERR_RET(schBuildAndSendMsg(job, task, msgType));
-
+  SCH_ERR_RET(schBuildAndSendMsg(job, task, plan->msgType));
   SCH_ERR_RET(schPushTaskToExecList(job, task));
 
   task->status = JOB_TASK_STATUS_EXECUTING;
-
   return TSDB_CODE_SUCCESS;
 }
 
-
-
 int32_t schLaunchJob(SSchJob *job) {
   SSchLevel *level = taosArrayGet(job->levels, job->levelIdx);
   for (int32_t i = 0; i < level->taskNum; ++i) {
diff --git a/source/libs/scheduler/test/schedulerTests.cpp b/source/libs/scheduler/test/schedulerTests.cpp
index 2c8eafb825..790778b736 100644
--- a/source/libs/scheduler/test/schedulerTests.cpp
+++ b/source/libs/scheduler/test/schedulerTests.cpp
@@ -59,7 +59,8 @@ void schtBuildQueryDag(SQueryDag *dag) {
   scanPlan.execNode.inUse = 0;
   scanPlan.execNode.epAddr[0].port = 6030;
   strcpy(scanPlan.execNode.epAddr[0].fqdn, "ep0");
-  scanPlan.pChildern = NULL;
+  scanPlan.pChildren = NULL;
+  scanPlan.level = 1;
   scanPlan.pParents = taosArrayInit(1, POINTER_BYTES);
   scanPlan.pNode = (SPhyNode*)calloc(1, sizeof(SPhyNode));
 
@@ -69,14 +70,14 @@ void schtBuildQueryDag(SQueryDag *dag) {
   mergePlan.type = QUERY_TYPE_MERGE;
   mergePlan.level = 0;
   mergePlan.execNode.numOfEps = 0;
-  mergePlan.pChildern = taosArrayInit(1, POINTER_BYTES);
+  mergePlan.pChildren = taosArrayInit(1, POINTER_BYTES);
   mergePlan.pParents = NULL;
   mergePlan.pNode = (SPhyNode*)calloc(1, sizeof(SPhyNode));
 
   SSubplan *mergePointer = (SSubplan *)taosArrayPush(merge, &mergePlan);
   SSubplan *scanPointer = (SSubplan *)taosArrayPush(scan, &scanPlan);
 
-  taosArrayPush(mergePointer->pChildern, &scanPointer);
+  taosArrayPush(mergePointer->pChildren, &scanPointer);
   taosArrayPush(scanPointer->pParents, &mergePointer);
 
   taosArrayPush(dag->pSubplans, &merge);  
@@ -103,7 +104,7 @@ void schtBuildInsertDag(SQueryDag *dag) {
   insertPlan[0].execNode.inUse = 0;
   insertPlan[0].execNode.epAddr[0].port = 6030;
   strcpy(insertPlan[0].execNode.epAddr[0].fqdn, "ep0");
-  insertPlan[0].pChildern = NULL;
+  insertPlan[0].pChildren = NULL;
   insertPlan[0].pParents = NULL;
   insertPlan[0].pNode = NULL;
   insertPlan[0].pDataSink = (SDataSink*)calloc(1, sizeof(SDataSink));
@@ -118,7 +119,7 @@ void schtBuildInsertDag(SQueryDag *dag) {
   insertPlan[1].execNode.inUse = 1;
   insertPlan[1].execNode.epAddr[0].port = 6030;
   strcpy(insertPlan[1].execNode.epAddr[0].fqdn, "ep1");
-  insertPlan[1].pChildern = NULL;
+  insertPlan[1].pChildren = NULL;
   insertPlan[1].pParents = NULL;
   insertPlan[1].pNode = NULL;
   insertPlan[1].pDataSink = (SDataSink*)calloc(1, sizeof(SDataSink));
diff --git a/source/util/CMakeLists.txt b/source/util/CMakeLists.txt
index bf1774b45b..ed936e90f6 100644
--- a/source/util/CMakeLists.txt
+++ b/source/util/CMakeLists.txt
@@ -14,4 +14,7 @@ target_link_libraries(
     PUBLIC api
 )
 
-ADD_SUBDIRECTORY(test)
+if(${BUILD_TEST})
+    ADD_SUBDIRECTORY(test)
+endif(${BUILD_TEST})
+
diff --git a/source/util/src/encode.c b/source/util/src/encode.c
new file mode 100644
index 0000000000..40c03ea051
--- /dev/null
+++ b/source/util/src/encode.c
@@ -0,0 +1,141 @@
+/*
+ * 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 "encode.h"
+
+#if __STDC_VERSION__ >= 201112L
+static_assert(sizeof(float) == sizeof(uint32_t), "sizeof(float) must equal to sizeof(uint32_t)");
+static_assert(sizeof(double) == sizeof(uint64_t), "sizeof(double) must equal to sizeof(uint64_t)");
+#endif
+
+void tCoderInit(SCoder* pCoder, td_endian_t endian, uint8_t* data, int32_t size, td_coder_t type) {
+  if (type == TD_ENCODER) {
+    if (data == NULL) size = 0;
+  } else {
+    ASSERT(data && size > 0);
+  }
+
+  pCoder->type = type;
+  pCoder->endian = endian;
+  pCoder->data = data;
+  pCoder->size = size;
+  pCoder->pos = 0;
+  tFreeListInit(&(pCoder->fl));
+  TD_SLIST_INIT(&(pCoder->stack));
+}
+
+void tCoderClear(SCoder* pCoder) {
+  tFreeListClear(&(pCoder->fl));
+  struct SCoderNode* pNode;
+  for (;;) {
+    pNode = TD_SLIST_HEAD(&(pCoder->stack));
+    if (pNode == NULL) break;
+    TD_SLIST_POP(&(pCoder->stack));
+    free(pNode);
+  }
+}
+
+int tStartEncode(SCoder* pCoder) {
+  struct SCoderNode* pNode;
+
+  ASSERT(pCoder->type == TD_ENCODER);
+  if (pCoder->data) {
+    if (pCoder->size - pCoder->pos < sizeof(int32_t)) return -1;
+
+    pNode = malloc(sizeof(*pNode));
+    if (pNode == NULL) return -1;
+
+    pNode->data = pCoder->data;
+    pNode->pos = pCoder->pos;
+    pNode->size = pCoder->size;
+
+    pCoder->data = pNode->data + pNode->pos + sizeof(int32_t);
+    pCoder->pos = 0;
+    pCoder->size = pNode->size - pNode->pos - sizeof(int32_t);
+
+    TD_SLIST_PUSH(&(pCoder->stack), pNode);
+  } else {
+    pCoder->pos += sizeof(int32_t);
+  }
+  return 0;
+}
+
+void tEndEncode(SCoder* pCoder) {
+  struct SCoderNode* pNode;
+  int32_t            len;
+
+  ASSERT(pCoder->type == TD_ENCODER);
+  if (pCoder->data) {
+    pNode = TD_SLIST_HEAD(&(pCoder->stack));
+    ASSERT(pNode);
+    TD_SLIST_POP(&(pCoder->stack));
+
+    len = pCoder->pos;
+
+    pCoder->data = pNode->data;
+    pCoder->size = pNode->size;
+    pCoder->pos = pNode->pos;
+
+    if (TD_RT_ENDIAN() == pCoder->endian) {
+      tPut(int32_t, pCoder->data + pCoder->pos, len);
+    } else {
+      tRPut32(pCoder->data + pCoder->pos, len);
+    }
+
+    TD_CODER_MOVE_POS(pCoder, len + sizeof(int32_t));
+
+    free(pNode);
+  }
+}
+
+int tStartDecode(SCoder* pCoder) {
+  int32_t            len;
+  struct SCoderNode* pNode;
+
+  ASSERT(pCoder->type == TD_DECODER);
+  if (tDecodeI32(pCoder, &len) < 0) return -1;
+
+  pNode = malloc(sizeof(*pNode));
+  if (pNode == NULL) return -1;
+
+  pNode->data = pCoder->data;
+  pNode->pos = pCoder->pos;
+  pNode->size = pCoder->size;
+
+  pCoder->data = pNode->data + pNode->pos;
+  pCoder->size = len;
+  pCoder->pos = 0;
+
+  TD_SLIST_PUSH(&(pCoder->stack), pNode);
+
+  return 0;
+}
+
+void tEndDecode(SCoder* pCoder) {
+  struct SCoderNode* pNode;
+
+  ASSERT(pCoder->type == TD_DECODER);
+  ASSERT(tDecodeIsEnd(pCoder));
+
+  pNode = TD_SLIST_HEAD(&(pCoder->stack));
+  ASSERT(pNode);
+  TD_SLIST_POP(&(pCoder->stack));
+
+  pCoder->data = pNode->data;
+  pCoder->size = pNode->size;
+  pCoder->pos = pCoder->pos + pNode->pos;
+
+  free(pNode);
+}
diff --git a/source/util/test/CMakeLists.txt b/source/util/test/CMakeLists.txt
index bfc3906f79..4b6311022d 100644
--- a/source/util/test/CMakeLists.txt
+++ b/source/util/test/CMakeLists.txt
@@ -41,4 +41,8 @@ target_sources(freelistTest
 )
 target_link_libraries(freelistTest os util gtest gtest_main)
 
+# encodeTest
+add_executable(encodeTest "encodeTest.cpp")
+target_link_libraries(encodeTest os util gtest gtest_main)
+
 
diff --git a/source/util/test/encodeTest.cpp b/source/util/test/encodeTest.cpp
new file mode 100644
index 0000000000..1a861701d7
--- /dev/null
+++ b/source/util/test/encodeTest.cpp
@@ -0,0 +1,421 @@
+#include <iostream>
+
+#include "gtest/gtest.h"
+
+#include "encode.h"
+
+#define BUF_SIZE 64
+td_endian_t endian_arr[2] = {TD_LITTLE_ENDIAN, TD_BIG_ENDIAN};
+
+static int encode(SCoder *pCoder, int8_t val) { return tEncodeI8(pCoder, val); }
+static int encode(SCoder *pCoder, uint8_t val) { return tEncodeU8(pCoder, val); }
+static int encode(SCoder *pCoder, int16_t val) { return tEncodeI16(pCoder, val); }
+static int encode(SCoder *pCoder, uint16_t val) { return tEncodeU16(pCoder, val); }
+static int encode(SCoder *pCoder, int32_t val) { return tEncodeI32(pCoder, val); }
+static int encode(SCoder *pCoder, uint32_t val) { return tEncodeU32(pCoder, val); }
+static int encode(SCoder *pCoder, int64_t val) { return tEncodeI64(pCoder, val); }
+static int encode(SCoder *pCoder, uint64_t val) { return tEncodeU64(pCoder, val); }
+
+static int decode(SCoder *pCoder, int8_t *val) { return tDecodeI8(pCoder, val); }
+static int decode(SCoder *pCoder, uint8_t *val) { return tDecodeU8(pCoder, val); }
+static int decode(SCoder *pCoder, int16_t *val) { return tDecodeI16(pCoder, val); }
+static int decode(SCoder *pCoder, uint16_t *val) { return tDecodeU16(pCoder, val); }
+static int decode(SCoder *pCoder, int32_t *val) { return tDecodeI32(pCoder, val); }
+static int decode(SCoder *pCoder, uint32_t *val) { return tDecodeU32(pCoder, val); }
+static int decode(SCoder *pCoder, int64_t *val) { return tDecodeI64(pCoder, val); }
+static int decode(SCoder *pCoder, uint64_t *val) { return tDecodeU64(pCoder, val); }
+
+static int encodev(SCoder *pCoder, int8_t val) { return tEncodeI8(pCoder, val); }
+static int encodev(SCoder *pCoder, uint8_t val) { return tEncodeU8(pCoder, val); }
+static int encodev(SCoder *pCoder, int16_t val) { return tEncodeI16v(pCoder, val); }
+static int encodev(SCoder *pCoder, uint16_t val) { return tEncodeU16v(pCoder, val); }
+static int encodev(SCoder *pCoder, int32_t val) { return tEncodeI32v(pCoder, val); }
+static int encodev(SCoder *pCoder, uint32_t val) { return tEncodeU32v(pCoder, val); }
+static int encodev(SCoder *pCoder, int64_t val) { return tEncodeI64v(pCoder, val); }
+static int encodev(SCoder *pCoder, uint64_t val) { return tEncodeU64v(pCoder, val); }
+
+static int decodev(SCoder *pCoder, int8_t *val) { return tDecodeI8(pCoder, val); }
+static int decodev(SCoder *pCoder, uint8_t *val) { return tDecodeU8(pCoder, val); }
+static int decodev(SCoder *pCoder, int16_t *val) { return tDecodeI16v(pCoder, val); }
+static int decodev(SCoder *pCoder, uint16_t *val) { return tDecodeU16v(pCoder, val); }
+static int decodev(SCoder *pCoder, int32_t *val) { return tDecodeI32v(pCoder, val); }
+static int decodev(SCoder *pCoder, uint32_t *val) { return tDecodeU32v(pCoder, val); }
+static int decodev(SCoder *pCoder, int64_t *val) { return tDecodeI64v(pCoder, val); }
+static int decodev(SCoder *pCoder, uint64_t *val) { return tDecodeU64v(pCoder, val); }
+
+template <typename T>
+static void simple_encode_decode_func(bool var_len) {
+  uint8_t buf[BUF_SIZE];
+  SCoder  coder;
+  T       min_val, max_val;
+  T       step = 1;
+
+  if (typeid(T) == typeid(int8_t)) {
+    min_val = INT8_MIN;
+    max_val = INT8_MAX;
+    step = 1;
+  } else if (typeid(T) == typeid(uint8_t)) {
+    min_val = 0;
+    max_val = UINT8_MAX;
+    step = 1;
+  } else if (typeid(T) == typeid(int16_t)) {
+    min_val = INT16_MIN;
+    max_val = INT16_MAX;
+    step = 1;
+  } else if (typeid(T) == typeid(uint16_t)) {
+    min_val = 0;
+    max_val = UINT16_MAX;
+    step = 1;
+  } else if (typeid(T) == typeid(int32_t)) {
+    min_val = INT32_MIN;
+    max_val = INT32_MAX;
+    step = ((T)1) << 16;
+  } else if (typeid(T) == typeid(uint32_t)) {
+    min_val = 0;
+    max_val = UINT32_MAX;
+    step = ((T)1) << 16;
+  } else if (typeid(T) == typeid(int64_t)) {
+    min_val = INT64_MIN;
+    max_val = INT64_MAX;
+    step = ((T)1) << 48;
+  } else if (typeid(T) == typeid(uint64_t)) {
+    min_val = 0;
+    max_val = UINT64_MAX;
+    step = ((T)1) << 48;
+  }
+
+  T i = min_val;
+  for (;; /*T i = min_val; i <= max_val; i += step*/) {
+    T dval;
+
+    // Encode NULL
+    for (td_endian_t endian : endian_arr) {
+      tCoderInit(&coder, endian, NULL, 0, TD_ENCODER);
+
+      if (var_len) {
+        GTEST_ASSERT_EQ(encodev(&coder, i), 0);
+      } else {
+        GTEST_ASSERT_EQ(encode(&coder, i), 0);
+        GTEST_ASSERT_EQ(coder.pos, sizeof(T));
+      }
+
+      tCoderClear(&coder);
+    }
+
+    // Encode and decode
+    for (td_endian_t e_endian : endian_arr) {
+      for (td_endian_t d_endian : endian_arr) {
+        // Encode
+        tCoderInit(&coder, e_endian, buf, BUF_SIZE, TD_ENCODER);
+
+        if (var_len) {
+          GTEST_ASSERT_EQ(encodev(&coder, i), 0);
+        } else {
+          GTEST_ASSERT_EQ(encode(&coder, i), 0);
+          GTEST_ASSERT_EQ(coder.pos, sizeof(T));
+        }
+
+        int32_t epos = coder.pos;
+
+        tCoderClear(&coder);
+        // Decode
+        tCoderInit(&coder, d_endian, buf, BUF_SIZE, TD_DECODER);
+
+        if (var_len) {
+          GTEST_ASSERT_EQ(decodev(&coder, &dval), 0);
+        } else {
+          GTEST_ASSERT_EQ(decode(&coder, &dval), 0);
+          GTEST_ASSERT_EQ(coder.pos, sizeof(T));
+        }
+
+        GTEST_ASSERT_EQ(coder.pos, epos);
+
+        if (typeid(T) == typeid(int8_t) || typeid(T) == typeid(uint8_t) || e_endian == d_endian) {
+          GTEST_ASSERT_EQ(i, dval);
+        }
+
+        tCoderClear(&coder);
+      }
+    }
+
+    if (i == max_val) break;
+
+    if (max_val - i < step) {
+      i = max_val;
+    } else {
+      i = i + step;
+    }
+  }
+}
+
+TEST(td_encode_test, encode_decode_fixed_len_integer) {
+  simple_encode_decode_func<int8_t>(false);
+  simple_encode_decode_func<uint8_t>(false);
+  simple_encode_decode_func<int16_t>(false);
+  simple_encode_decode_func<uint16_t>(false);
+  simple_encode_decode_func<int32_t>(false);
+  simple_encode_decode_func<uint32_t>(false);
+  simple_encode_decode_func<int64_t>(false);
+  simple_encode_decode_func<uint64_t>(false);
+}
+
+TEST(td_encode_test, encode_decode_variant_len_integer) {
+  simple_encode_decode_func<int16_t>(true);
+  simple_encode_decode_func<uint16_t>(true);
+  simple_encode_decode_func<int32_t>(true);
+  simple_encode_decode_func<uint32_t>(true);
+  simple_encode_decode_func<int64_t>(true);
+  simple_encode_decode_func<uint64_t>(true);
+}
+
+TEST(td_encode_test, encode_decode_cstr) {
+  uint8_t *   buf = new uint8_t[1024 * 1024];
+  char *      cstr = new char[1024 * 1024];
+  const char *dcstr;
+  SCoder      encoder;
+  SCoder      decoder;
+
+  for (size_t i = 0; i < 1024 * 2 - 1; i++) {
+    memset(cstr, 'a', i);
+    cstr[i] = '\0';
+    for (td_endian_t endian : endian_arr) {
+      // Encode
+      tCoderInit(&encoder, endian, buf, 1024 * 1024, TD_ENCODER);
+
+      GTEST_ASSERT_EQ(tEncodeCStr(&encoder, cstr), 0);
+
+      tCoderClear(&encoder);
+
+      // Decode
+      tCoderInit(&decoder, endian, buf, 1024 * 1024, TD_DECODER);
+
+      GTEST_ASSERT_EQ(tDecodeCStr(&decoder, &dcstr), 0);
+      GTEST_ASSERT_EQ(memcmp(dcstr, cstr, i + 1), 0);
+
+      tCoderClear(&decoder);
+    }
+  }
+
+  delete buf;
+  delete cstr;
+}
+
+typedef struct {
+  int32_t A_a;
+  int64_t A_b;
+  char *  A_c;
+} SStructA_v1;
+
+static int tSStructA_v1_encode(SCoder *pCoder, const SStructA_v1 *pSAV1) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32(pCoder, pSAV1->A_a) < 0) return -1;
+  if (tEncodeI64(pCoder, pSAV1->A_b) < 0) return -1;
+  if (tEncodeCStr(pCoder, pSAV1->A_c) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+static int tSStructA_v1_decode(SCoder *pCoder, SStructA_v1 *pSAV1) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI32(pCoder, &pSAV1->A_a) < 0) return -1;
+  if (tDecodeI64(pCoder, &pSAV1->A_b) < 0) return -1;
+  const char *tstr;
+  uint64_t    len;
+  if (tDecodeCStrAndLen(pCoder, &tstr, &len) < 0) return -1;
+  pSAV1->A_c = (char *)TCODER_MALLOC(len + 1, pCoder);
+  memcpy(pSAV1->A_c, tstr, len + 1);
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+typedef struct {
+  int32_t A_a;
+  int64_t A_b;
+  char *  A_c;
+  // -------------------BELOW FEILDS ARE ADDED IN A NEW VERSION--------------
+  int16_t A_d;
+  int16_t A_e;
+} SStructA_v2;
+
+static int tSStructA_v2_encode(SCoder *pCoder, const SStructA_v2 *pSAV2) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tEncodeI32(pCoder, pSAV2->A_a) < 0) return -1;
+  if (tEncodeI64(pCoder, pSAV2->A_b) < 0) return -1;
+  if (tEncodeCStr(pCoder, pSAV2->A_c) < 0) return -1;
+
+  // ------------------------NEW FIELDS ENCODE-------------------------------
+  if (tEncodeI16(pCoder, pSAV2->A_d) < 0) return -1;
+  if (tEncodeI16(pCoder, pSAV2->A_e) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+static int tSStructA_v2_decode(SCoder *pCoder, SStructA_v2 *pSAV2) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  if (tDecodeI32(pCoder, &pSAV2->A_a) < 0) return -1;
+  if (tDecodeI64(pCoder, &pSAV2->A_b) < 0) return -1;
+  const char *tstr;
+  uint64_t    len;
+  if (tDecodeCStrAndLen(pCoder, &tstr, &len) < 0) return -1;
+  pSAV2->A_c = (char *)TCODER_MALLOC(len + 1, pCoder);
+  memcpy(pSAV2->A_c, tstr, len + 1);
+
+  // ------------------------NEW FIELDS DECODE-------------------------------
+  if (!tDecodeIsEnd(pCoder)) {
+    if (tDecodeI16(pCoder, &pSAV2->A_d) < 0) return -1;
+    if (tDecodeI16(pCoder, &pSAV2->A_e) < 0) return -1;
+  } else {
+    pSAV2->A_d = 0;
+    pSAV2->A_e = 0;
+  }
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+typedef struct {
+  SStructA_v1 *pA;
+  int32_t      v_a;
+  int8_t       v_b;
+} SFinalReq_v1;
+
+static int tSFinalReq_v1_encode(SCoder *pCoder, const SFinalReq_v1 *ps1) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tSStructA_v1_encode(pCoder, ps1->pA) < 0) return -1;
+  if (tEncodeI32(pCoder, ps1->v_a) < 0) return -1;
+  if (tEncodeI8(pCoder, ps1->v_b) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+static int tSFinalReq_v1_decode(SCoder *pCoder, SFinalReq_v1 *ps1) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  ps1->pA = (SStructA_v1 *)TCODER_MALLOC(sizeof(*(ps1->pA)), pCoder);
+  if (tSStructA_v1_decode(pCoder, ps1->pA) < 0) return -1;
+  if (tDecodeI32(pCoder, &ps1->v_a) < 0) return -1;
+  if (tDecodeI8(pCoder, &ps1->v_b) < 0) return -1;
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+typedef struct {
+  SStructA_v2 *pA;
+  int32_t      v_a;
+  int8_t       v_b;
+  // ----------------------- Feilds added -----------------------
+  int16_t v_c;
+} SFinalReq_v2;
+
+static int tSFinalReq_v2_encode(SCoder *pCoder, const SFinalReq_v2 *ps2) {
+  if (tStartEncode(pCoder) < 0) return -1;
+
+  if (tSStructA_v2_encode(pCoder, ps2->pA) < 0) return -1;
+  if (tEncodeI32(pCoder, ps2->v_a) < 0) return -1;
+  if (tEncodeI8(pCoder, ps2->v_b) < 0) return -1;
+
+  // ----------------------- Feilds added encode -----------------------
+  if (tEncodeI16(pCoder, ps2->v_c) < 0) return -1;
+
+  tEndEncode(pCoder);
+  return 0;
+}
+
+static int tSFinalReq_v2_decode(SCoder *pCoder, SFinalReq_v2 *ps2) {
+  if (tStartDecode(pCoder) < 0) return -1;
+
+  ps2->pA = (SStructA_v2 *)TCODER_MALLOC(sizeof(*(ps2->pA)), pCoder);
+  if (tSStructA_v2_decode(pCoder, ps2->pA) < 0) return -1;
+  if (tDecodeI32(pCoder, &ps2->v_a) < 0) return -1;
+  if (tDecodeI8(pCoder, &ps2->v_b) < 0) return -1;
+
+  // ----------------------- Feilds added decode -----------------------
+  if (tDecodeIsEnd(pCoder)) {
+    ps2->v_c = 0;
+  } else {
+    if (tDecodeI16(pCoder, &ps2->v_c) < 0) return -1;
+  }
+
+  tEndDecode(pCoder);
+  return 0;
+}
+
+TEST(td_encode_test, compound_struct_encode_test) {
+  SCoder       encoder, decoder;
+  uint8_t *    buf1;
+  int32_t      buf1size;
+  uint8_t *    buf2;
+  int32_t      buf2size;
+  SStructA_v1  sa1 = {.A_a = 10, .A_b = 65478, .A_c = "Hello"};
+  SStructA_v2  sa2 = {.A_a = 10, .A_b = 65478, .A_c = "Hello", .A_d = 67, .A_e = 13};
+  SFinalReq_v1 req1 = {.pA = &sa1, .v_a = 15, .v_b = 35};
+  SFinalReq_v2 req2 = {.pA = &sa2, .v_a = 15, .v_b = 32, .v_c = 37};
+  SFinalReq_v1 dreq1;
+  SFinalReq_v2 dreq21, dreq22;
+
+  // Get size
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, nullptr, 0, TD_ENCODER);
+  GTEST_ASSERT_EQ(tSFinalReq_v1_encode(&encoder, &req1), 0);
+  buf1size = encoder.pos;
+  buf1 = new uint8_t[encoder.pos];
+  tCoderClear(&encoder);
+
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, nullptr, 0, TD_ENCODER);
+  GTEST_ASSERT_EQ(tSFinalReq_v2_encode(&encoder, &req2), 0);
+  buf2size = encoder.pos;
+  buf2 = new uint8_t[encoder.pos];
+  tCoderClear(&encoder);
+
+  // Encode
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf1, buf1size, TD_ENCODER);
+  GTEST_ASSERT_EQ(tSFinalReq_v1_encode(&encoder, &req1), 0);
+  tCoderClear(&encoder);
+
+  tCoderInit(&encoder, TD_LITTLE_ENDIAN, buf2, buf2size, TD_ENCODER);
+  GTEST_ASSERT_EQ(tSFinalReq_v2_encode(&encoder, &req2), 0);
+  tCoderClear(&encoder);
+
+  // Decode
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf1, buf1size, TD_DECODER);
+  GTEST_ASSERT_EQ(tSFinalReq_v1_decode(&decoder, &dreq1), 0);
+  GTEST_ASSERT_EQ(dreq1.pA->A_a, req1.pA->A_a);
+  GTEST_ASSERT_EQ(dreq1.pA->A_b, req1.pA->A_b);
+  GTEST_ASSERT_EQ(strcmp(dreq1.pA->A_c, req1.pA->A_c), 0);
+  GTEST_ASSERT_EQ(dreq1.v_a, req1.v_a);
+  GTEST_ASSERT_EQ(dreq1.v_b, req1.v_b);
+  tCoderClear(&decoder);
+
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf1, buf1size, TD_DECODER);
+  GTEST_ASSERT_EQ(tSFinalReq_v2_decode(&decoder, &dreq21), 0);
+  GTEST_ASSERT_EQ(dreq21.pA->A_a, req1.pA->A_a);
+  GTEST_ASSERT_EQ(dreq21.pA->A_b, req1.pA->A_b);
+  GTEST_ASSERT_EQ(strcmp(dreq21.pA->A_c, req1.pA->A_c), 0);
+  GTEST_ASSERT_EQ(dreq21.pA->A_d, 0);
+  GTEST_ASSERT_EQ(dreq21.pA->A_e, 0);
+  GTEST_ASSERT_EQ(dreq21.v_a, req1.v_a);
+  GTEST_ASSERT_EQ(dreq21.v_b, req1.v_b);
+  GTEST_ASSERT_EQ(dreq21.v_c, 0);
+  tCoderClear(&decoder);
+
+  tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf2, buf2size, TD_DECODER);
+  GTEST_ASSERT_EQ(tSFinalReq_v2_decode(&decoder, &dreq22), 0);
+  GTEST_ASSERT_EQ(dreq22.pA->A_a, req2.pA->A_a);
+  GTEST_ASSERT_EQ(dreq22.pA->A_b, req2.pA->A_b);
+  GTEST_ASSERT_EQ(strcmp(dreq22.pA->A_c, req2.pA->A_c), 0);
+  GTEST_ASSERT_EQ(dreq22.pA->A_d, req2.pA->A_d);
+  GTEST_ASSERT_EQ(dreq22.pA->A_e, req2.pA->A_e);
+  GTEST_ASSERT_EQ(dreq22.v_a, req2.v_a);
+  GTEST_ASSERT_EQ(dreq22.v_b, req2.v_b);
+  GTEST_ASSERT_EQ(dreq22.v_c, req2.v_c);
+  tCoderClear(&decoder);
+}
\ No newline at end of file