Merge branch '3.0' into feature/TD-11274-3.0

docs-cn/12-taos-sql/07-function.md

@@ -668,7 +668,7 @@ SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause]
 SELECT MODE(field_name) FROM tb_name [WHERE clause];
 ```
 
-**功能说明**：返回出现频率最高的值，若存在多个频率相同的最高值，输出空。不能匹配标签、时间戳输出。
+**功能说明**：返回出现频率最高的值，若存在多个频率相同的最高值，输出空。
 
 **返回数据类型**：同应用的字段。
 

docs-cn/12-taos-sql/13-operators.md

@@ -35,8 +35,8 @@ TDengine 支持 `UNION ALL` 和 `UNION` 操作符。UNION ALL 将查询返回的
 | --- | :---------------: | -------------------------------------------------------------------- | -------------------- |
 | 1   |         =         | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 相等                 |
 | 2   |      <\>, !=      | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型，且不可以为表的时间戳主键列 | 不相等               |
-| 3   |      \>, \<       | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 大于，小于           |
-| 4   |     \>=, \<=      | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 大于等于，小于等于   |
+| 3   |      \>, <       | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 大于，小于           |
+| 4   |     \>=, <=      | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型                             | 大于等于，小于等于   |
 | 5   |   IS [NOT] NULL   | 所有类型                                                             | 是否为空值           |
 | 6   | [NOT] BETWEEN AND | 除 BOOL、BLOB、MEDIUMBLOB 和 JSON 外的所有类型                       | 闭区间比较           |
 | 7   |        IN         | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型，且不可以为表的时间戳主键列 | 与列表内的任意值相等 |

docs-en/12-taos-sql/07-function.md

@@ -281,7 +281,7 @@ SELECT CONCAT(str1|column1, str2|column2, ...) FROM { tb_name | stb_name } [WHER
 
 **Return value type**: If all input strings are VARCHAR type, the result is VARCHAR type too. If any one of input strings is NCHAR type, then the result is NCHAR.
 
-**Applicable data types**: VARCHAR, NCHAR. Can't be used on tag columns. At least 2 input strings are requird, and at most 8 input strings are allowed. 
+**Applicable data types**: VARCHAR, NCHAR.  At least 2 input strings are requird, and at most 8 input strings are allowed. 
 
 **Applicable table types**: table, STable
 
@@ -297,7 +297,7 @@ SELECT CONCAT_WS(separator, str1|column1, str2|column2, ...) FROM { tb_name | st
 
 **Return value type**: If all input strings are VARCHAR type, the result is VARCHAR type too. If any one of input strings is NCHAR type, then the result is NCHAR.
 
-**Applicable data types**: VARCHAR, NCHAR. Can't be used on tag columns. At least 3 input strings are requird, and at most 9 input strings are allowed. 
+**Applicable data types**: VARCHAR, NCHAR. At least 3 input strings are requird, and at most 9 input strings are allowed. 
 
 **Applicable table types**: table, STable
 

docs-en/12-taos-sql/13-operators.md

@@ -35,8 +35,8 @@ TDengine provides 2 set operators: `UNION ALL` and `UNION`. `UNION ALL` combines
 | --- | :---------------: | ------------------------------------------------------------------- | ----------------------------------------------- |
 | 1   |         =         | Except for BLOB, MEDIUMBLOB and JSON                                | Equal                                           |
 | 2   |      <\>, !=      | Except for BLOB, MEDIUMBLOB, JSON and primary key of timestamp type | Not equal                                       |
-| 3   |      \>, \<       | Except for BLOB, MEDIUMBLOB and JSON                                | Greater than, less than                         |
-| 4   |     \>=, \<=      | Except for BLOB, MEDIUMBLOB and JSON                                | Greater than or equal to, less than or equal to |
+| 3   |      \>, <       | Except for BLOB, MEDIUMBLOB and JSON                                | Greater than, less than                         |
+| 4   |     \>=, <=      | Except for BLOB, MEDIUMBLOB and JSON                                | Greater than or equal to, less than or equal to |
 | 5   |   IS [NOT] NULL   | Any types                                                           | Is NULL or NOT                                  |
 | 6   | [NOT] BETWEEN AND | Except for BLOB, MEDIUMBLOB and JSON                                | In a value range or not                         |
 | 7   |        IN         | Except for BLOB, MEDIUMBLOB, JSON and primary key of timestamp type | In a list of values or not                      |

example/CMakeLists.txt

-add_executable(tmq "")
-add_executable(tstream "")
-add_executable(demoapi "")
-
-target_sources(tmq
-    PRIVATE
-    "src/tmq.c"
-)
-
-target_sources(tstream
-    PRIVATE
-    "src/tstream.c"
-)
-
-target_sources(demoapi
-    PRIVATE
-    "src/demoapi.c"
-)
-
-target_link_libraries(tmq
-    taos_static
-)
-
-target_link_libraries(tstream
-    taos_static
-)
-
-target_link_libraries(demoapi
-    taos_static
-)
-
-target_include_directories(tmq
-    PUBLIC "${TD_SOURCE_DIR}/include/os"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-
-target_include_directories(tstream
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-
-target_include_directories(demoapi
-    PUBLIC "${TD_SOURCE_DIR}/include/client"
-    PUBLIC "${TD_SOURCE_DIR}/include/os"
-    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
-)
-
-SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
-SET_TARGET_PROPERTIES(tstream PROPERTIES OUTPUT_NAME tstream)
-SET_TARGET_PROPERTIES(demoapi PROPERTIES OUTPUT_NAME demoapi)

examples/c/CMakeLists.txt

@@ -11,6 +11,56 @@ IF (TD_LINUX)
   #TARGET_LINK_LIBRARIES(subscribe taos_static trpc tutil pthread )
   #ADD_EXECUTABLE(epoll epoll.c)
   #TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
+
+  add_executable(tmq "")
+  add_executable(tstream "")
+  add_executable(demoapi "")
+
+  target_sources(tmq
+      PRIVATE
+      "tmq.c"
+      )
+
+  target_sources(tstream
+      PRIVATE
+      "tstream.c"
+      )
+
+  target_sources(demoapi
+      PRIVATE
+      "demoapi.c"
+      )
+
+  target_link_libraries(tmq
+      taos_static
+      )
+
+  target_link_libraries(tstream
+      taos_static
+      )
+
+  target_link_libraries(demoapi
+      taos_static
+      )
+
+  target_include_directories(tmq
+      PUBLIC "${TD_SOURCE_DIR}/include/os"
+      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      )
+
+  target_include_directories(tstream
+      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      )
+
+  target_include_directories(demoapi
+      PUBLIC "${TD_SOURCE_DIR}/include/client"
+      PUBLIC "${TD_SOURCE_DIR}/include/os"
+      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      )
+
+  SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
+  SET_TARGET_PROPERTIES(tstream PROPERTIES OUTPUT_NAME tstream)
+  SET_TARGET_PROPERTIES(demoapi PROPERTIES OUTPUT_NAME demoapi)
 ENDIF ()
 IF (TD_DARWIN)
   INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)

include/common/tdataformat.h

@@ -30,6 +30,7 @@ extern "C" {
 typedef struct SSchema       SSchema;
 typedef struct STColumn      STColumn;
 typedef struct STSchema      STSchema;
+typedef struct SValue        SValue;
 typedef struct SColVal       SColVal;
 typedef struct STSRow2       STSRow2;
 typedef struct STSRowBuilder STSRowBuilder;
@@ -40,24 +41,26 @@ typedef struct STag          STag;
 int32_t tTSchemaCreate(int32_t sver, SSchema *pSchema, int32_t nCols, STSchema **ppTSchema);
 void    tTSchemaDestroy(STSchema *pTSchema);
 
-// SColVal
-#define ColValNONE               ((SColVal){.type = COL_VAL_NONE, .nData = 0, .pData = NULL})
-#define ColValNULL               ((SColVal){.type = COL_VAL_NULL, .nData = 0, .pData = NULL})
-#define ColValDATA(nData, pData) ((SColVal){.type = COL_VAL_DATA, .nData = (nData), .pData = (pData)})
-
 // STSRow2
+#define COL_VAL_NONE(CID)     ((SColVal){.cid = (CID), .isNone = 1})
+#define COL_VAL_NULL(CID)     ((SColVal){.cid = (CID), .isNull = 1})
+#define COL_VAL_VALUE(CID, V) ((SColVal){.cid = (CID), .value = (V)})
+
+int32_t tTSRowClone(const STSRow2 *pRow, STSRow2 **ppRow);
+void    tTSRowFree(STSRow2 *pRow);
+void    tTSRowGet(STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal);
+int32_t tTSRowToArray(STSRow2 *pRow, STSchema *pTSchema, SArray **ppArray);
 int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow);
 int32_t tGetTSRow(uint8_t *p, STSRow2 *pRow);
-int32_t tTSRowDup(const STSRow2 *pRow, STSRow2 **ppRow);
-void    tTSRowFree(STSRow2 *pRow);
-int32_t tTSRowGet(const STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal);
 
 // STSRowBuilder
+#if 0
 int32_t tTSRowBuilderInit(STSRowBuilder *pBuilder, int32_t sver, int32_t nCols, SSchema *pSchema);
 void    tTSRowBuilderClear(STSRowBuilder *pBuilder);
 void    tTSRowBuilderReset(STSRowBuilder *pBuilder);
 int32_t tTSRowBuilderPut(STSRowBuilder *pBuilder, int32_t cid, uint8_t *pData, uint32_t nData);
 int32_t tTSRowBuilderGetRow(STSRowBuilder *pBuilder, const STSRow2 **ppRow);
+#endif
 
 // STag
 int32_t tTagNew(SArray *pArray, int32_t version, int8_t isJson, STag **ppTag);
@@ -90,7 +93,9 @@ struct STSchema {
 #define TSROW_HAS_NONE ((uint8_t)0x1)
 #define TSROW_HAS_NULL ((uint8_t)0x2U)
 #define TSROW_HAS_VAL  ((uint8_t)0x4U)
-#define TSROW_KV_ROW   ((uint8_t)0x10U)
+#define TSROW_KV_SMALL ((uint8_t)0x10U)
+#define TSROW_KV_MID   ((uint8_t)0x20U)
+#define TSROW_KV_BIG   ((uint8_t)0x40U)
 struct STSRow2 {
   TSKEY    ts;
   uint8_t  flags;
@@ -113,11 +118,31 @@ struct STSRowBuilder {
   STSRow2   row;
 };
 
-typedef enum { COL_VAL_NONE = 0, COL_VAL_NULL = 1, COL_VAL_DATA = 2 } EColValT;
+struct SValue {
+  union {
+    int8_t   i8;   // TSDB_DATA_TYPE_BOOL||TSDB_DATA_TYPE_TINYINT
+    uint8_t  u8;   // TSDB_DATA_TYPE_UTINYINT
+    int16_t  i16;  // TSDB_DATA_TYPE_SMALLINT
+    uint16_t u16;  // TSDB_DATA_TYPE_USMALLINT
+    int32_t  i32;  // TSDB_DATA_TYPE_INT
+    uint32_t u32;  // TSDB_DATA_TYPE_UINT
+    int64_t  i64;  // TSDB_DATA_TYPE_BIGINT
+    uint64_t u64;  // TSDB_DATA_TYPE_UBIGINT
+    TSKEY    ts;   // TSDB_DATA_TYPE_TIMESTAMP
+    float    f;    // TSDB_DATA_TYPE_FLOAT
+    double   d;    // TSDB_DATA_TYPE_DOUBLE
+    struct {
+      uint32_t nData;
+      uint8_t *pData;
+    };
+  };
+};
+
 struct SColVal {
-  EColValT type;
-  uint32_t nData;
-  uint8_t *pData;
+  int16_t cid;
+  int8_t  isNone;
+  int8_t  isNull;
+  SValue  value;
 };
 
 #pragma pack(push, 1)

include/common/tmsg.h

@@ -244,7 +244,7 @@ typedef struct {
   const void* pMsg;
 } SSubmitMsgIter;
 
-int32_t tInitSubmitMsgIter(SSubmitReq* pMsg, SSubmitMsgIter* pIter);
+int32_t tInitSubmitMsgIter(const SSubmitReq* pMsg, SSubmitMsgIter* pIter);
 int32_t tGetSubmitMsgNext(SSubmitMsgIter* pIter, SSubmitBlk** pPBlock);
 int32_t tInitSubmitBlkIter(SSubmitMsgIter* pMsgIter, SSubmitBlk* pBlock, SSubmitBlkIter* pIter);
 STSRow* tGetSubmitBlkNext(SSubmitBlkIter* pIter);
@@ -945,7 +945,6 @@ typedef struct {
   int64_t timeInFetchQueue;
 } SQnodeLoad;
 
-
 typedef struct {
   int32_t     sver;      // software version
   int64_t     dnodeVer;  // dnode table version in sdb
@@ -1002,7 +1001,6 @@ typedef struct {
 
 typedef struct {
   int32_t  vgId;
-  int32_t  dnodeId;
   char     db[TSDB_DB_FNAME_LEN];
   int64_t  dbUid;
   int32_t  vgVersion;
@@ -1025,16 +1023,14 @@ typedef struct {
   int8_t   compression;
   int8_t   strict;
   int8_t   cacheLastRow;
+  int8_t   isTsma;
+  int8_t   standby;
   int8_t   replica;
   int8_t   selfIndex;
   SReplica replicas[TSDB_MAX_REPLICA];
   int32_t  numOfRetensions;
   SArray*  pRetensions;  // SRetention
-
-  // for tsma
-  int8_t isTsma;
-  void*  pTsma;
-
+  void*    pTsma;
 } SCreateVnodeReq;
 
 int32_t tSerializeSCreateVnodeReq(void* buf, int32_t bufLen, SCreateVnodeReq* pReq);
@@ -1072,8 +1068,8 @@ typedef struct {
   int8_t   walLevel;
   int8_t   strict;
   int8_t   cacheLastRow;
-  int8_t   replica;
   int8_t   selfIndex;
+  int8_t   replica;
   SReplica replicas[TSDB_MAX_REPLICA];
 } SAlterVnodeReq;
 
@@ -1977,7 +1973,7 @@ typedef struct {
   int8_t   killConnection;
   int8_t   align[3];
   SEpSet   epSet;
-  SArray  *pQnodeList;
+  SArray*  pQnodeList;
 } SQueryHbRspBasic;
 
 typedef struct {
@@ -2663,6 +2659,23 @@ typedef struct {
 int32_t tEncodeSVSubmitReq(SEncoder* pCoder, const SVSubmitReq* pReq);
 int32_t tDecodeSVSubmitReq(SDecoder* pCoder, SVSubmitReq* pReq);
 
+// TDMT_VND_DELETE
+typedef struct {
+  TSKEY sKey;
+  TSKEY eKey;
+
+  // super table
+  char* stbName;
+
+  // child/normal
+  char* tbName;
+} SVDeleteReq;
+
+typedef struct {
+  int32_t code;
+  // TODO
+} SVDeleteRsp;
+
 #pragma pack(pop)
 
 #ifdef __cplusplus

include/common/tmsgdef.h

@@ -221,9 +221,11 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_SYNC_APPLY_MSG, "vnode-sync-apply-msg", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_SYNC_CONFIG_CHANGE, "vnode-sync-config-change", NULL, NULL)
   
-  TD_DEF_MSG_TYPE(TDMT_VND_SYNC_VNODE, "vnode-sync-vnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_VNODE, "vnode-alter-vnode", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_COMPACT_VNODE, "vnode-compact-vnode", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_CONFIG, "vnode-alter-config", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_REPLICA, "vnode-alter-replica", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_COMPACT, "vnode-compact", NULL, NULL)
+
+  TD_DEF_MSG_TYPE(TDMT_VND_DELETE, "vnode-delete-data", SVDeleteReq, SVDeleteRsp)
 
   // Requests handled by QNODE
   TD_NEW_MSG_SEG(TDMT_QND_MSG)

include/libs/stream/tstream.h

@@ -61,11 +61,8 @@ enum {
 };
 
 typedef struct {
-  int8_t type;
-
-  int32_t sourceVg;
-  int64_t sourceVer;
-
+  int8_t      type;
+  int64_t     ver;
   int32_t*    dataRef;
   SSubmitReq* data;
 } SStreamDataSubmit;
@@ -111,6 +108,8 @@ static FORCE_INLINE void streamDataSubmitRefDec(SStreamDataSubmit* pDataSubmit)
   }
 }
 
+SStreamDataSubmit* streamSubmitRefClone(SStreamDataSubmit* pSubmit);
+
 int32_t streamDataBlockEncode(void** buf, const SStreamDataBlock* pOutput);
 void*   streamDataBlockDecode(const void* buf, SStreamDataBlock* pInput);
 
@@ -209,8 +208,6 @@ struct SStreamTask {
   int32_t nodeId;
   SEpSet  epSet;
 
-  // source preprocess
-
   // exec
   STaskExec exec;
 
@@ -318,8 +315,6 @@ int32_t streamDequeueOutput(SStreamTask* pTask, void** output);
 
 int32_t streamTaskRun(SStreamTask* pTask);
 
-int32_t streamTaskHandleInput(SStreamTask* pTask, void* data);
-
 int32_t streamTaskProcessRunReq(SStreamTask* pTask, SMsgCb* pMsgCb);
 int32_t streamProcessDispatchReq(SStreamTask* pTask, SMsgCb* pMsgCb, SStreamDispatchReq* pReq, SRpcMsg* pMsg);
 int32_t streamProcessDispatchRsp(SStreamTask* pTask, SMsgCb* pMsgCb, SStreamDispatchRsp* pRsp);

include/util/tencode.h

@@ -461,64 +461,153 @@ static FORCE_INLINE void* tDecoderMalloc(SDecoder* pCoder, int32_t size) {
 }
 
 // ===========================================
-#define tPutV(p, v)                  \
-  int32_t n = 0;                     \
-  for (;;) {                         \
-    if (v <= 0x7f) {                 \
-      if (p) p[n] = v;               \
-      n++;                           \
-      break;                         \
-    }                                \
-    if (p) p[n] = (v & 0x7f) | 0x80; \
-    n++;                             \
-    v >>= 7;                         \
-  }                                  \
-  return n;
+#define tPutV(p, v)                    \
+  do {                                 \
+    int32_t n = 0;                     \
+    for (;;) {                         \
+      if (v <= 0x7f) {                 \
+        if (p) p[n] = v;               \
+        n++;                           \
+        break;                         \
+      }                                \
+      if (p) p[n] = (v & 0x7f) | 0x80; \
+      n++;                             \
+      v >>= 7;                         \
+    }                                  \
+    return n;                          \
+  } while (0)
 
-#define tGetV(p, v)                            \
-  int32_t n = 0;                               \
-  if (v) *v = 0;                               \
-  for (;;) {                                   \
-    if (p[n] <= 0x7f) {                        \
-      if (v) (*v) |= (p[n] << (7 * n));        \
-      n++;                                     \
-      break;                                   \
-    }                                          \
-    if (v) (*v) |= ((p[n] & 0x7f) << (7 * n)); \
-    n++;                                       \
-  }                                            \
-  return n;
+#define tGetV(p, v)                              \
+  do {                                           \
+    int32_t n = 0;                               \
+    if (v) *v = 0;                               \
+    for (;;) {                                   \
+      if (p[n] <= 0x7f) {                        \
+        if (v) (*v) |= (p[n] << (7 * n));        \
+        n++;                                     \
+        break;                                   \
+      }                                          \
+      if (v) (*v) |= ((p[n] & 0x7f) << (7 * n)); \
+      n++;                                       \
+    }                                            \
+    return n;                                    \
+  } while (0)
 
 // PUT
+static FORCE_INLINE int32_t tPutU8(uint8_t* p, uint8_t v) {
+  if (p) ((uint8_t*)p)[0] = v;
+  return sizeof(uint8_t);
+}
+
 static FORCE_INLINE int32_t tPutI8(uint8_t* p, int8_t v) {
   if (p) ((int8_t*)p)[0] = v;
   return sizeof(int8_t);
 }
 
+static FORCE_INLINE int32_t tPutU16(uint8_t* p, uint16_t v) {
+  if (p) ((uint16_t*)p)[0] = v;
+  return sizeof(uint16_t);
+}
+
+static FORCE_INLINE int32_t tPutI16(uint8_t* p, int16_t v) {
+  if (p) ((int16_t*)p)[0] = v;
+  return sizeof(int16_t);
+}
+
+static FORCE_INLINE int32_t tPutU32(uint8_t* p, uint32_t v) {
+  if (p) ((uint32_t*)p)[0] = v;
+  return sizeof(uint32_t);
+}
+
+static FORCE_INLINE int32_t tPutI32(uint8_t* p, int32_t v) {
+  if (p) ((int32_t*)p)[0] = v;
+  return sizeof(int32_t);
+}
+
+static FORCE_INLINE int32_t tPutU64(uint8_t* p, uint64_t v) {
+  if (p) ((uint64_t*)p)[0] = v;
+  return sizeof(uint64_t);
+}
+
 static FORCE_INLINE int32_t tPutI64(uint8_t* p, int64_t v) {
   if (p) ((int64_t*)p)[0] = v;
   return sizeof(int64_t);
 }
 
-static FORCE_INLINE int32_t tPutU16v(uint8_t* p, uint16_t v) { tPutV(p, v) }
+static FORCE_INLINE int32_t tPutFloat(uint8_t* p, float f) {
+  union {
+    uint32_t ui;
+    float    f;
+  } v;
+  v.f = f;
+
+  return tPutU32(p, v.ui);
+}
+
+static FORCE_INLINE int32_t tPutDouble(uint8_t* p, double d) {
+  union {
+    uint64_t ui;
+    double   d;
+  } v;
+  v.d = d;
+
+  return tPutU64(p, v.ui);
+}
+
+static FORCE_INLINE int32_t tPutU16v(uint8_t* p, uint16_t v) { tPutV(p, v); }
 
 static FORCE_INLINE int32_t tPutI16v(uint8_t* p, int16_t v) { return tPutU16v(p, ZIGZAGE(int16_t, v)); }
 
-static FORCE_INLINE int32_t tPutU32v(uint8_t* p, uint32_t v) { tPutV(p, v) }
+static FORCE_INLINE int32_t tPutU32v(uint8_t* p, uint32_t v) { tPutV(p, v); }
 
 static FORCE_INLINE int32_t tPutI32v(uint8_t* p, int32_t v) { return tPutU32v(p, ZIGZAGE(int32_t, v)); }
 
+static FORCE_INLINE int32_t tPutU64v(uint8_t* p, uint64_t v) { tPutV(p, v); }
+
+static FORCE_INLINE int32_t tPutI64v(uint8_t* p, int64_t v) { return tPutU64v(p, ZIGZAGE(int64_t, v)); }
+
+// GET
+static FORCE_INLINE int32_t tGetU8(uint8_t* p, uint8_t* v) {
+  if (v) *v = ((uint8_t*)p)[0];
+  return sizeof(uint8_t);
+}
+
 static FORCE_INLINE int32_t tGetI8(uint8_t* p, int8_t* v) {
   if (v) *v = ((int8_t*)p)[0];
   return sizeof(int8_t);
 }
 
+static FORCE_INLINE int32_t tGetU16(uint8_t* p, uint16_t* v) {
+  if (v) *v = ((uint16_t*)p)[0];
+  return sizeof(uint16_t);
+}
+
+static FORCE_INLINE int32_t tGetI16(uint8_t* p, int16_t* v) {
+  if (v) *v = ((int16_t*)p)[0];
+  return sizeof(int16_t);
+}
+
+static FORCE_INLINE int32_t tGetU32(uint8_t* p, uint32_t* v) {
+  if (v) *v = ((uint32_t*)p)[0];
+  return sizeof(uint32_t);
+}
+
+static FORCE_INLINE int32_t tGetI32(uint8_t* p, int32_t* v) {
+  if (v) *v = ((int32_t*)p)[0];
+  return sizeof(int32_t);
+}
+
+static FORCE_INLINE int32_t tGetU64(uint8_t* p, uint64_t* v) {
+  if (v) *v = ((uint64_t*)p)[0];
+  return sizeof(uint64_t);
+}
+
 static FORCE_INLINE int32_t tGetI64(uint8_t* p, int64_t* v) {
   if (v) *v = ((int64_t*)p)[0];
   return sizeof(int64_t);
 }
 
-static FORCE_INLINE int32_t tGetU16v(uint8_t* p, uint16_t* v) { tGetV(p, v) }
+static FORCE_INLINE int32_t tGetU16v(uint8_t* p, uint16_t* v) { tGetV(p, v); }
 
 static FORCE_INLINE int32_t tGetI16v(uint8_t* p, int16_t* v) {
   int32_t  n;
@@ -530,7 +619,7 @@ static FORCE_INLINE int32_t tGetI16v(uint8_t* p, int16_t* v) {
   return n;
 }
 
-static FORCE_INLINE int32_t tGetU32v(uint8_t* p, uint32_t* v) { tGetV(p, v) }
+static FORCE_INLINE int32_t tGetU32v(uint8_t* p, uint32_t* v) { tGetV(p, v); }
 
 static FORCE_INLINE int32_t tGetI32v(uint8_t* p, int32_t* v) {
   int32_t  n;
@@ -542,6 +631,46 @@ static FORCE_INLINE int32_t tGetI32v(uint8_t* p, int32_t* v) {
   return n;
 }
 
+static FORCE_INLINE int32_t tGetU64v(uint8_t* p, uint64_t* v) { tGetV(p, v); }
+
+static FORCE_INLINE int32_t tGetI64v(uint8_t* p, int64_t* v) {
+  int32_t  n;
+  uint64_t tv;
+
+  n = tGetU64v(p, &tv);
+  if (v) *v = ZIGZAGD(int64_t, tv);
+
+  return n;
+}
+
+static FORCE_INLINE int32_t tGetFloat(uint8_t* p, float* f) {
+  int32_t n = 0;
+
+  union {
+    uint32_t ui;
+    float    f;
+  } v;
+
+  n = tGetU32(p, &v.ui);
+
+  *f = v.f;
+  return n;
+}
+
+static FORCE_INLINE int32_t tGetDouble(uint8_t* p, double* d) {
+  int32_t n = 0;
+
+  union {
+    uint64_t ui;
+    double   d;
+  } v;
+
+  n = tGetU64(p, &v.ui);
+
+  *d = v.d;
+  return n;
+}
+
 // =====================
 static FORCE_INLINE int32_t tPutBinary(uint8_t* p, uint8_t* pData, uint32_t nData) {
   int n = 0;

source/common/src/tdataformat.c

@@ -21,15 +21,10 @@
 
 static int32_t tGetTagVal(uint8_t *p, STagVal *pTagVal, int8_t isJson);
 
-typedef struct SKVIdx {
-  int32_t cid;
-  int32_t offset;
-} SKVIdx;
-
 #pragma pack(push, 1)
 typedef struct {
   int16_t nCols;
-  SKVIdx  idx[];
+  uint8_t idx[];
 } STSKVRow;
 #pragma pack(pop)
 
@@ -43,171 +38,551 @@ typedef struct {
 
 static FORCE_INLINE int tSKVIdxCmprFn(const void *p1, const void *p2);
 
-// STSRow2
-int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow) {
+// SValue
+static FORCE_INLINE int32_t tPutValue(uint8_t *p, SValue *pValue, int8_t type) {
   int32_t n = 0;
 
-  n += tPutI64(p ? p + n : p, pRow->ts);
-  n += tPutI8(p ? p + n : p, pRow->flags);
-  n += tPutI32v(p ? p + n : p, pRow->sver);
+  if (IS_VAR_DATA_TYPE(type)) {
+    n += tPutBinary(p ? p + n : p, pValue->pData, pValue->nData);
+  } else {
+    switch (type) {
+      case TSDB_DATA_TYPE_BOOL:
+        n += tPutI8(p ? p + n : p, pValue->i8 ? 1 : 0);
+        break;
+      case TSDB_DATA_TYPE_TINYINT:
+        n += tPutI8(p ? p + n : p, pValue->i8);
+        break;
+      case TSDB_DATA_TYPE_SMALLINT:
+        n += tPutI16(p ? p + n : p, pValue->i16);
+        break;
+      case TSDB_DATA_TYPE_INT:
+        n += tPutI32(p ? p + n : p, pValue->i32);
+        break;
+      case TSDB_DATA_TYPE_BIGINT:
+        n += tPutI64(p ? p + n : p, pValue->i64);
+        break;
+      case TSDB_DATA_TYPE_FLOAT:
+        n += tPutFloat(p ? p + n : p, pValue->f);
+        break;
+      case TSDB_DATA_TYPE_DOUBLE:
+        n += tPutDouble(p ? p + n : p, pValue->d);
+        break;
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        n += tPutI64(p ? p + n : p, pValue->ts);
+        break;
+      case TSDB_DATA_TYPE_UTINYINT:
+        n += tPutU8(p ? p + n : p, pValue->u8);
+        break;
+      case TSDB_DATA_TYPE_USMALLINT:
+        n += tPutU16(p ? p + n : p, pValue->u16);
+        break;
+      case TSDB_DATA_TYPE_UINT:
+        n += tPutU32(p ? p + n : p, pValue->u32);
+        break;
+      case TSDB_DATA_TYPE_UBIGINT:
+        n += tPutU64(p ? p + n : p, pValue->u64);
+        break;
+      default:
+        ASSERT(0);
+    }
+  }
 
-  ASSERT(pRow->flags & 0xf);
+  return n;
+}
 
-  switch (pRow->flags & 0xf) {
-    case TSROW_HAS_NONE:
-    case TSROW_HAS_NULL:
-      break;
-    default:
-      n += tPutBinary(p ? p + n : p, pRow->pData, pRow->nData);
-      break;
+static FORCE_INLINE int32_t tGetValue(uint8_t *p, SValue *pValue, int8_t type) {
+  int32_t n = 0;
+
+  if (IS_VAR_DATA_TYPE(type)) {
+    n += tGetBinary(p, &pValue->pData, pValue ? &pValue->nData : NULL);
+  } else {
+    switch (type) {
+      case TSDB_DATA_TYPE_BOOL:
+        n += tGetI8(p, &pValue->i8);
+        break;
+      case TSDB_DATA_TYPE_TINYINT:
+        n += tGetI8(p, &pValue->i8);
+        break;
+      case TSDB_DATA_TYPE_SMALLINT:
+        n += tGetI16(p, &pValue->i16);
+        break;
+      case TSDB_DATA_TYPE_INT:
+        n += tGetI32(p, &pValue->i32);
+        break;
+      case TSDB_DATA_TYPE_BIGINT:
+        n += tGetI64(p, &pValue->i64);
+        break;
+      case TSDB_DATA_TYPE_FLOAT:
+        n += tGetFloat(p, &pValue->f);
+        break;
+      case TSDB_DATA_TYPE_DOUBLE:
+        n += tGetDouble(p, &pValue->d);
+        break;
+      case TSDB_DATA_TYPE_TIMESTAMP:
+        n += tGetI64(p, &pValue->ts);
+        break;
+      case TSDB_DATA_TYPE_UTINYINT:
+        n += tGetU8(p, &pValue->u8);
+        break;
+      case TSDB_DATA_TYPE_USMALLINT:
+        n += tGetU16(p, &pValue->u16);
+        break;
+      case TSDB_DATA_TYPE_UINT:
+        n += tGetU32(p, &pValue->u32);
+        break;
+      case TSDB_DATA_TYPE_UBIGINT:
+        n += tGetU64(p, &pValue->u64);
+        break;
+      default:
+        ASSERT(0);
+    }
   }
 
   return n;
 }
 
-int32_t tGetTSRow(uint8_t *p, STSRow2 *pRow) {
-  int32_t n = 0;
-  uint8_t flags;
+// STSRow2 ========================================================================
+static void tTupleTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow2 *pRow) {
+  int32_t   nColVal = taosArrayGetSize(pArray);
+  STColumn *pTColumn;
+  SColVal  *pColVal;
+
+  ASSERT(nColVal > 0);
+
+  pRow->sver = pTSchema->version;
 
-  n += tGetI64(p + n, pRow ? &pRow->ts : NULL);
-  n += tGetI8(p + n, pRow ? &pRow->flags : &flags);
-  n += tGetI32v(p + n, pRow ? &pRow->sver : NULL);
+  // ts
+  pTColumn = &pTSchema->columns[0];
+  pColVal = (SColVal *)taosArrayGet(pArray, 0);
 
-  if (pRow) flags = pRow->flags;
+  ASSERT(pTColumn->colId == 0 && pColVal->cid == 0);
+  ASSERT(pTColumn->type == TSDB_DATA_TYPE_TIMESTAMP);
+
+  pRow->ts = pColVal->value.ts;
+
+  // other fields
+  int32_t  iColVal = 1;
+  int32_t  bidx;
+  uint32_t nv = 0;
+  uint8_t *pb = NULL;
+  uint8_t *pf = NULL;
+  uint8_t *pv = NULL;
+  uint8_t  flags = 0;
+  for (int32_t iColumn = 1; iColumn < pTSchema->numOfCols; iColumn++) {
+    bidx = iColumn - 1;
+    pTColumn = &pTSchema->columns[iColumn];
+
+    if (iColVal < nColVal) {
+      pColVal = (SColVal *)taosArrayGet(pArray, iColVal);
+    } else {
+      pColVal = NULL;
+    }
+
+    if (pColVal) {
+      if (pColVal->cid == pTColumn->colId) {
+        iColVal++;
+        if (pColVal->isNone) {
+          goto _set_none;
+        } else if (pColVal->isNull) {
+          goto _set_null;
+        } else {
+          goto _set_value;
+        }
+      } else if (pColVal->cid > pTColumn->colId) {
+        goto _set_none;
+      } else {
+        ASSERT(0);
+      }
+    } else {
+      goto _set_none;
+    }
+
+  _set_none:
+    flags |= TSROW_HAS_NONE;
+    // SET_BIT2(pb, bidx, 0); (todo)
+    continue;
+
+  _set_null:
+    flags != TSROW_HAS_NULL;
+    // SET_BIT2(pb, bidx, 1); (todo)
+    continue;
+
+  _set_value:
+    flags != TSROW_HAS_VAL;
+    // SET_BIT2(pb, bidx, 2); (todo)
+    if (IS_VAR_DATA_TYPE(pTColumn->type)) {
+      // nv += tPutColVal(pv ? pv + nv : pv, pColVal, pTColumn->type, 1);
+    } else {
+      // tPutColVal(pf ? pf + pTColumn->offset : pf, pColVal, pTColumn->type, 1);
+    }
+    continue;
+  }
+
+  ASSERT(flags);
   switch (flags & 0xf) {
     case TSROW_HAS_NONE:
     case TSROW_HAS_NULL:
+      pRow->nData = 0;
+      break;
+    case TSROW_HAS_VAL:
+      pRow->nData = pTSchema->flen + nv;
+      break;
+    case TSROW_HAS_NULL | TSROW_HAS_NONE:
+      pRow->nData = BIT1_SIZE(pTSchema->numOfCols - 1);
+      break;
+    case TSROW_HAS_VAL | TSROW_HAS_NONE:
+    case TSROW_HAS_VAL | TSROW_HAS_NULL:
+      pRow->nData = BIT1_SIZE(pTSchema->numOfCols - 1) + pTSchema->flen + nv;
+      break;
+    case TSROW_HAS_VAL | TSROW_HAS_NULL | TSROW_HAS_NONE:
+      pRow->nData = BIT2_SIZE(pTSchema->numOfCols - 1) + pTSchema->flen + nv;
       break;
     default:
-      n += tGetBinary(p + n, pRow ? &pRow->pData : NULL, pRow ? &pRow->nData : NULL);
       break;
   }
+}
 
-  return n;
+static void tMapTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow2 *pRow) {
+  int32_t   nColVal = taosArrayGetSize(pArray);
+  STColumn *pTColumn;
+  SColVal  *pColVal;
+
+  ASSERT(nColVal > 0);
+
+  pRow->sver = pTSchema->version;
+
+  // ts
+  pTColumn = &pTSchema->columns[0];
+  pColVal = (SColVal *)taosArrayGet(pArray, 0);
+
+  ASSERT(pTColumn->colId == 0 && pColVal->cid == 0);
+  ASSERT(pTColumn->type == TSDB_DATA_TYPE_TIMESTAMP);
+
+  pRow->ts = pColVal->value.ts;
+
+  // other fields
+  int32_t  iColVal = 1;
+  uint32_t nv = 0;
+  uint8_t *pv = NULL;
+  uint8_t *pidx = NULL;
+  uint8_t  flags = 0;
+  int16_t  nCol = 0;
+  for (int32_t iColumn = 1; iColumn < pTSchema->numOfCols; iColumn++) {
+    pTColumn = &pTSchema->columns[iColumn];
+
+    if (iColVal < nColVal) {
+      pColVal = (SColVal *)taosArrayGet(pArray, iColVal);
+    } else {
+      pColVal = NULL;
+    }
+
+    if (pColVal) {
+      if (pColVal->cid == pTColumn->colId) {
+        iColVal++;
+        if (pColVal->isNone) {
+          goto _set_none;
+        } else if (pColVal->isNull) {
+          goto _set_null;
+        } else {
+          goto _set_value;
+        }
+      } else if (pColVal->cid > pTColumn->colId) {
+        goto _set_none;
+      } else {
+        ASSERT(0);
+      }
+    } else {
+      goto _set_none;
+    }
+
+  _set_none:
+    flags |= TSROW_HAS_NONE;
+    continue;
+
+  _set_null:
+    flags != TSROW_HAS_NULL;
+    pidx[nCol++] = nv;
+    // nv += tPutColVal(pv ? pv + nv : pv, pColVal, pTColumn->type, 0);
+    continue;
+
+  _set_value:
+    flags != TSROW_HAS_VAL;
+    pidx[nCol++] = nv;
+    // nv += tPutColVal(pv ? pv + nv : pv, pColVal, pTColumn->type, 0);
+    continue;
+  }
+
+  if (nv <= UINT8_MAX) {
+    // small
+  } else if (nv <= UINT16_MAX) {
+    // mid
+  } else {
+    // large
+  }
+}
+
+// try-decide-build
+int32_t tTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow2 **ppRow) {
+  int32_t code = 0;
+  STSRow2 rowT = {0};
+  STSRow2 rowM = {0};
+
+  // try
+  tTupleTSRowNew(pArray, pTSchema, &rowT);
+  tMapTSRowNew(pArray, pTSchema, &rowM);
+
+  // decide & build
+  if (rowT.nData <= rowM.nData) {
+    tTupleTSRowNew(pArray, pTSchema, &rowT);
+  } else {
+    tMapTSRowNew(pArray, pTSchema, &rowM);
+  }
+
+  return code;
 }
 
-int32_t tTSRowDup(const STSRow2 *pRow, STSRow2 **ppRow) {
-  (*ppRow) = taosMemoryMalloc(sizeof(*pRow) + pRow->nData);
+int32_t tTSRowClone(const STSRow2 *pRow, STSRow2 **ppRow) {
+  int32_t code = 0;
+
+  (*ppRow) = (STSRow2 *)taosMemoryMalloc(sizeof(**ppRow));
   if (*ppRow == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _exit;
   }
+  **ppRow = *pRow;
+  (*ppRow)->pData = NULL;
 
-  (*ppRow)->ts = pRow->ts;
-  (*ppRow)->flags = pRow->flags;
-  (*ppRow)->sver = pRow->sver;
-  (*ppRow)->nData = pRow->nData;
   if (pRow->nData) {
-    (*ppRow)->pData = (uint8_t *)(&(*ppRow)[1]);
+    (*ppRow)->pData = taosMemoryMalloc(pRow->nData);
+    if ((*ppRow)->pData == NULL) {
+      taosMemoryFree(*ppRow);
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _exit;
+    }
     memcpy((*ppRow)->pData, pRow->pData, pRow->nData);
-  } else {
-    (*ppRow)->pData = NULL;
   }
 
-  return 0;
+_exit:
+  return code;
 }
 
 void tTSRowFree(STSRow2 *pRow) {
-  if (pRow) taosMemoryFree(pRow);
+  if (pRow) {
+    if (pRow->pData) taosMemoryFree(pRow->pData);
+    taosMemoryFree(pRow);
+  }
 }
 
-int32_t tTSRowGet(const STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal) {
-  uint32_t  n;
-  uint8_t  *p;
-  uint8_t   v;
-  int32_t   bidx = iCol - 1;
+void tTSRowGet(STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal) {
+  uint8_t   isTuple = (pRow->flags & 0xf0 == 0) ? 1 : 0;
   STColumn *pTColumn = &pTSchema->columns[iCol];
-  STSKVRow *pTSKVRow;
-  SKVIdx   *pKVIdx;
+  uint8_t   flags = pRow->flags & (uint8_t)0xf;
+  SValue    value;
 
-  ASSERT(iCol != 0);
-  ASSERT(pTColumn->colId != 0);
+  ASSERT(iCol < pTSchema->numOfCols);
+  ASSERT(flags);
+  ASSERT(pRow->sver == pTSchema->version);
 
-  ASSERT((pRow->flags & 0xf) != 0);
-  switch (pRow->flags & 0xf) {
-    case TSROW_HAS_NONE:
-      *pColVal = ColValNONE;
-      return 0;
-    case TSROW_HAS_NULL:
-      *pColVal = ColValNULL;
-      return 0;
+  if (iCol == 0) {
+    value.ts = pRow->ts;
+    goto _return_value;
   }
 
-  if (TSROW_IS_KV_ROW(pRow)) {
-    ASSERT((pRow->flags & 0xf) != TSROW_HAS_VAL);
+  if (flags == TSROW_HAS_NONE) {
+    goto _return_none;
+  } else if (flags == TSROW_HAS_NONE) {
+    goto _return_null;
+  }
 
-    pTSKVRow = (STSKVRow *)pRow->pData;
-    pKVIdx =
-        bsearch(&((SKVIdx){.cid = pTColumn->colId}), pTSKVRow->idx, pTSKVRow->nCols, sizeof(SKVIdx), tSKVIdxCmprFn);
-    if (pKVIdx == NULL) {
-      *pColVal = ColValNONE;
-    } else if (pKVIdx->offset < 0) {
-      *pColVal = ColValNULL;
-    } else {
-      p = pRow->pData + sizeof(STSKVRow) + sizeof(SKVIdx) * pTSKVRow->nCols + pKVIdx->offset;
-      pColVal->type = COL_VAL_DATA;
-      tGetBinary(p, &pColVal->pData, &pColVal->nData);
-    }
-  } else {
-    // get bitmap
-    p = pRow->pData;
-    switch (pRow->flags & 0xf) {
+  ASSERT(pRow->nData && pRow->pData);
+
+  if (isTuple) {
+    uint8_t *pb = pRow->pData;
+    uint8_t *pf = NULL;
+    uint8_t *pv = NULL;
+    uint8_t *p;
+    uint8_t  b;
+
+    // bit
+    switch (flags) {
+      case TSROW_HAS_VAL:
+        pf = pb;
+        break;
       case TSROW_HAS_NULL | TSROW_HAS_NONE:
-        v = GET_BIT1(p, bidx);
-        if (v == 0) {
-          *pColVal = ColValNONE;
+        b = GET_BIT1(pb, iCol - 1);
+        if (b == 0) {
+          goto _return_none;
         } else {
-          *pColVal = ColValNULL;
+          goto _return_null;
         }
-        return 0;
       case TSROW_HAS_VAL | TSROW_HAS_NONE:
-        v = GET_BIT1(p, bidx);
-        if (v == 1) {
-          p = p + BIT1_SIZE(pTSchema->numOfCols - 1);
-          break;
+        b = GET_BIT1(pb, iCol - 1);
+        if (b == 0) {
+          goto _return_none;
         } else {
-          *pColVal = ColValNONE;
-          return 0;
+          pf = pb + BIT1_SIZE(pTSchema->numOfCols - 1);
+          break;
         }
       case TSROW_HAS_VAL | TSROW_HAS_NULL:
-        v = GET_BIT1(p, bidx);
-        if (v == 1) {
-          p = p + BIT1_SIZE(pTSchema->numOfCols - 1);
-          break;
+        b = GET_BIT1(pb, iCol - 1);
+        if (b == 0) {
+          goto _return_null;
         } else {
-          *pColVal = ColValNULL;
-          return 0;
+          pf = pb + BIT1_SIZE(pTSchema->numOfCols - 1);
+          break;
         }
       case TSROW_HAS_VAL | TSROW_HAS_NULL | TSROW_HAS_NONE:
-        v = GET_BIT2(p, bidx);
-        if (v == 0) {
-          *pColVal = ColValNONE;
-          return 0;
-        } else if (v == 1) {
-          *pColVal = ColValNULL;
-          return 0;
-        } else if (v == 2) {
-          p = p + BIT2_SIZE(pTSchema->numOfCols - 1);
-          break;
+        b = GET_BIT2(pb, iCol - 1);
+        if (b == 0) {
+          goto _return_none;
+        } else if (b == 1) {
+          goto _return_null;
         } else {
-          ASSERT(0);
+          pf = pb + BIT2_SIZE(pTSchema->numOfCols - 1);
+          break;
         }
       default:
-        break;
+        ASSERT(0);
     }
 
-    // get real value
-    p = p + pTColumn->offset;
-    pColVal->type = COL_VAL_DATA;
+    ASSERT(pf);
+
+    p = pf + pTColumn->offset;
     if (IS_VAR_DATA_TYPE(pTColumn->type)) {
-      tGetBinary(p + pTSchema->flen + *(int32_t *)p, &pColVal->pData, &pColVal->nData);
+      pv = pf + pTSchema->flen;
+      p = pv + *(VarDataOffsetT *)p;
+    }
+    tGetValue(p, &value, pTColumn->type);
+    goto _return_value;
+  } else {
+    STSKVRow *pRowK = (STSKVRow *)pRow->pData;
+    int16_t   lidx = 0;
+    int16_t   ridx = pRowK->nCols - 1;
+    uint8_t  *p;
+    int16_t   midx;
+    uint32_t  n;
+    int16_t   cid;
+
+    ASSERT(pRowK->nCols > 0);
+
+    if (pRow->flags & TSROW_KV_SMALL) {
+      p = pRow->pData + sizeof(STSKVRow) + sizeof(uint8_t) * pRowK->nCols;
+    } else if (pRow->flags & TSROW_KV_MID) {
+      p = pRow->pData + sizeof(STSKVRow) + sizeof(uint16_t) * pRowK->nCols;
+    } else if (pRow->flags & TSROW_KV_BIG) {
+      p = pRow->pData + sizeof(STSKVRow) + sizeof(uint32_t) * pRowK->nCols;
     } else {
-      pColVal->pData = p;
-      pColVal->nData = pTColumn->bytes;
+      ASSERT(0);
+    }
+    while (lidx <= ridx) {
+      midx = (lidx + ridx) / 2;
+
+      if (pRow->flags & TSROW_KV_SMALL) {
+        n = ((uint8_t *)pRowK->idx)[midx];
+      } else if (pRow->flags & TSROW_KV_MID) {
+        n = ((uint16_t *)pRowK->idx)[midx];
+      } else {
+        n = ((uint32_t *)pRowK->idx)[midx];
+      }
+
+      n += tGetI16v(p + n, &cid);
+
+      if (TABS(cid) == pTColumn->colId) {
+        if (cid < 0) {
+          goto _return_null;
+        } else {
+          n += tGetValue(p + n, &value, pTColumn->type);
+          goto _return_value;
+        }
+
+        return;
+      } else if (TABS(cid) > pTColumn->colId) {
+        ridx = midx - 1;
+      } else {
+        lidx = midx + 1;
+      }
     }
+
+    // not found, return NONE
+    goto _return_none;
   }
 
-  return 0;
+_return_none:
+  *pColVal = COL_VAL_NONE(pTColumn->colId);
+  return;
+
+_return_null:
+  *pColVal = COL_VAL_NULL(pTColumn->colId);
+  return;
+
+_return_value:
+  *pColVal = COL_VAL_VALUE(pTColumn->colId, value);
+  return;
+}
+
+int32_t tTSRowToArray(STSRow2 *pRow, STSchema *pTSchema, SArray **ppArray) {
+  int32_t code = 0;
+  SColVal cv;
+
+  (*ppArray) = taosArrayInit(pTSchema->numOfCols, sizeof(SColVal));
+  if (*ppArray == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _exit;
+  }
+
+  for (int32_t iColumn = 0; iColumn < pTSchema->numOfCols; iColumn++) {
+    tTSRowGet(pRow, pTSchema, iColumn, &cv);
+    taosArrayPush(*ppArray, &cv);
+  }
+
+_exit:
+  return code;
+}
+
+int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow) {
+  int32_t n = 0;
+
+  n += tPutI64(p ? p + n : p, pRow->ts);
+  n += tPutI8(p ? p + n : p, pRow->flags);
+  n += tPutI32v(p ? p + n : p, pRow->sver);
+
+  ASSERT(pRow->flags & 0xf);
+
+  switch (pRow->flags & 0xf) {
+    case TSROW_HAS_NONE:
+    case TSROW_HAS_NULL:
+      ASSERT(pRow->nData == 0);
+      ASSERT(pRow->pData == NULL);
+      break;
+    default:
+      ASSERT(pRow->nData && pRow->pData);
+      n += tPutBinary(p ? p + n : p, pRow->pData, pRow->nData);
+      break;
+  }
+
+  return n;
+}
+
+int32_t tGetTSRow(uint8_t *p, STSRow2 *pRow) {
+  int32_t n = 0;
+
+  n += tGetI64(p + n, &pRow->ts);
+  n += tGetI8(p + n, &pRow->flags);
+  n += tGetI32v(p + n, &pRow->sver);
+
+  ASSERT(pRow->flags);
+  switch (pRow->flags & 0xf) {
+    case TSROW_HAS_NONE:
+    case TSROW_HAS_NULL:
+      pRow->nData = 0;
+      pRow->pData = NULL;
+      break;
+    default:
+      n += tGetBinary(p + n, &pRow->pData, &pRow->nData);
+      break;
+  }
+
+  return n;
 }
 
 // STSchema
@@ -251,6 +626,7 @@ void tTSchemaDestroy(STSchema *pTSchema) {
 }
 
 // STSRowBuilder
+#if 0
 int32_t tTSRowBuilderInit(STSRowBuilder *pBuilder, int32_t sver, int32_t nCols, SSchema *pSchema) {
   if (tTSchemaCreate(sver, pSchema, nCols, &pBuilder->pTSchema) < 0) return -1;
 
@@ -508,6 +884,7 @@ int32_t tTSRowBuilderGetRow(STSRowBuilder *pBuilder, const STSRow2 **ppRow) {
 
   return 0;
 }
+#endif
 
 static int tTagValCmprFn(const void *p1, const void *p2) {
   if (((STagVal *)p1)->cid < ((STagVal *)p2)->cid) {
@@ -622,9 +999,9 @@ void debugPrintSTag(STag *pTag, const char *tag, int32_t ln) {
     }
     printf("%s:%d loop[%d-%d] offset=%d\n", __func__, __LINE__, (int32_t)pTag->nTag, (int32_t)n, (int32_t)offset);
     tGetTagVal(p + offset, &tagVal, isJson);
-    if(IS_VAR_DATA_TYPE(tagVal.type)){
+    if (IS_VAR_DATA_TYPE(tagVal.type)) {
       debugPrintTagVal(tagVal.type, tagVal.pData, tagVal.nData, __func__, __LINE__);
-    }else{
+    } else {
       debugPrintTagVal(tagVal.type, &tagVal.i64, tDataTypes[tagVal.type].bytes, __func__, __LINE__);
     }
   }
@@ -650,7 +1027,7 @@ static int32_t tPutTagVal(uint8_t *p, STagVal *pTagVal, int8_t isJson) {
   } else {
     p = p ? p + n : p;
     n += tDataTypes[pTagVal->type].bytes;
-    if(p) memcpy(p, &(pTagVal->i64), tDataTypes[pTagVal->type].bytes);
+    if (p) memcpy(p, &(pTagVal->i64), tDataTypes[pTagVal->type].bytes);
   }
 
   return n;
@@ -750,21 +1127,21 @@ void tTagFree(STag *pTag) {
   if (pTag) taosMemoryFree(pTag);
 }
 
-char *tTagValToData(const STagVal *value, bool isJson){
-  if(!value) return NULL;
-  char *data = NULL;
+char *tTagValToData(const STagVal *value, bool isJson) {
+  if (!value) return NULL;
+  char  *data = NULL;
   int8_t typeBytes = 0;
   if (isJson) {
     typeBytes = CHAR_BYTES;
   }
-  if(IS_VAR_DATA_TYPE(value->type)){
+  if (IS_VAR_DATA_TYPE(value->type)) {
     data = taosMemoryCalloc(1, typeBytes + VARSTR_HEADER_SIZE + value->nData);
-    if(data == NULL) return NULL;
-    if(isJson) *data = value->type;
+    if (data == NULL) return NULL;
+    if (isJson) *data = value->type;
     varDataLen(data + typeBytes) = value->nData;
     memcpy(varDataVal(data + typeBytes), value->pData, value->nData);
-  }else{
-    data = ((char*)&(value->i64)) - typeBytes;  // json with type
+  } else {
+    data = ((char *)&(value->i64)) - typeBytes;  // json with type
   }
 
   return data;

source/common/src/tmsg.c

@@ -28,7 +28,7 @@
 #undef TD_MSG_SEG_CODE_
 #include "tmsgdef.h"
 
-int32_t tInitSubmitMsgIter(SSubmitReq *pMsg, SSubmitMsgIter *pIter) {
+int32_t tInitSubmitMsgIter(const SSubmitReq *pMsg, SSubmitMsgIter *pIter) {
   if (pMsg == NULL) {
     terrno = TSDB_CODE_TDB_SUBMIT_MSG_MSSED_UP;
     return -1;
@@ -165,7 +165,6 @@ int32_t tDecodeSQueryNodeLoad(SDecoder *pDecoder, SQueryNodeLoad *pLoad) {
   return 0;
 }
 
-
 int32_t taosEncodeSEpSet(void **buf, const SEpSet *pEp) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI8(buf, pEp->inUse);
@@ -2934,7 +2933,6 @@ int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pR
 
   if (tStartEncode(&encoder) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->vgId) < 0) return -1;
-  if (tEncodeI32(&encoder, pReq->dnodeId) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
   if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1;
   if (tEncodeI32(&encoder, pReq->vgVersion) < 0) return -1;
@@ -2957,6 +2955,7 @@ int32_t tSerializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *pR
   if (tEncodeI8(&encoder, pReq->compression) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->standby) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->selfIndex) < 0) return -1;
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
@@ -2991,7 +2990,6 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *
 
   if (tStartDecode(&decoder) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->vgId) < 0) return -1;
-  if (tDecodeI32(&decoder, &pReq->dnodeId) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
   if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1;
   if (tDecodeI32(&decoder, &pReq->vgVersion) < 0) return -1;
@@ -3014,6 +3012,7 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *
   if (tDecodeI8(&decoder, &pReq->compression) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->standby) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->selfIndex) < 0) return -1;
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
@@ -3053,7 +3052,7 @@ int32_t tDeserializeSCreateVnodeReq(void *buf, int32_t bufLen, SCreateVnodeReq *
 int32_t tFreeSCreateVnodeReq(SCreateVnodeReq *pReq) {
   taosArrayDestroy(pReq->pRetensions);
   pReq->pRetensions = NULL;
-  if(pReq->isTsma) {
+  if (pReq->isTsma) {
     taosMemoryFreeClear(pReq->pTsma);
   }
   return 0;
@@ -3134,8 +3133,8 @@ int32_t tSerializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pReq
   if (tEncodeI8(&encoder, pReq->walLevel) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->strict) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->cacheLastRow) < 0) return -1;
-  if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
   if (tEncodeI8(&encoder, pReq->selfIndex) < 0) return -1;
+  if (tEncodeI8(&encoder, pReq->replica) < 0) return -1;
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
     SReplica *pReplica = &pReq->replicas[i];
     if (tEncodeSReplica(&encoder, pReplica) < 0) return -1;
@@ -3165,8 +3164,8 @@ int32_t tDeserializeSAlterVnodeReq(void *buf, int32_t bufLen, SAlterVnodeReq *pR
   if (tDecodeI8(&decoder, &pReq->walLevel) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->strict) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->cacheLastRow) < 0) return -1;
-  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
   if (tDecodeI8(&decoder, &pReq->selfIndex) < 0) return -1;
+  if (tDecodeI8(&decoder, &pReq->replica) < 0) return -1;
   for (int32_t i = 0; i < TSDB_MAX_REPLICA; ++i) {
     SReplica *pReplica = &pReq->replicas[i];
     if (tDecodeSReplica(&decoder, pReplica) < 0) return -1;

source/dnode/mgmt/mgmt_mnode/src/mmHandle.c

@@ -219,9 +219,9 @@ SArray *mmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_VND_DROP_TASK, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_QUERY_HEARTBEAT, mmPutNodeMsgToQueryQueue, 1) == NULL) goto _OVER;
 
-  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_SYNC_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT_VNODE_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_CONFIG_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_REPLICA_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT_RSP, mmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
 
   if (dmSetMgmtHandle(pArray, TDMT_VND_SYNC_TIMEOUT, mmPutNodeMsgToSyncQueue, 1) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_SYNC_PING, mmPutNodeMsgToSyncQueue, 1) == NULL) goto _OVER;

source/dnode/mgmt/mgmt_vnode/src/vmHandle.c

@@ -162,13 +162,14 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
   pCfg->hashEnd = pCreate->hashEnd;
   pCfg->hashMethod = pCreate->hashMethod;
 
+  pCfg->standby = pCfg->standby;
   pCfg->syncCfg.myIndex = pCreate->selfIndex;
   pCfg->syncCfg.replicaNum = pCreate->replica;
   memset(&pCfg->syncCfg.nodeInfo, 0, sizeof(pCfg->syncCfg.nodeInfo));
   for (int i = 0; i < pCreate->replica; ++i) {
-    pCfg->syncCfg.nodeInfo[i].nodePort = pCreate->replicas[i].port;
-    snprintf(pCfg->syncCfg.nodeInfo[i].nodeFqdn, sizeof(pCfg->syncCfg.nodeInfo[i].nodeFqdn), "%s",
-             pCreate->replicas[i].fqdn);
+    SNodeInfo *pNode = &pCfg->syncCfg.nodeInfo[i];
+    pNode->nodePort = pCreate->replicas[i].port;
+    tstrncpy(pNode->nodeFqdn, pCreate->replicas[i].fqdn, sizeof(pNode->nodeFqdn));
   }
 }
 
@@ -181,6 +182,8 @@ static void vmGenerateWrapperCfg(SVnodeMgmt *pMgmt, SCreateVnodeReq *pCreate, SW
 
 int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
   SCreateVnodeReq createReq = {0};
+  SVnodeCfg       vnodeCfg = {0};
+  SWrapperCfg     wrapperCfg = {0};
   int32_t         code = -1;
   char            path[TSDB_FILENAME_LEN] = {0};
 
@@ -189,12 +192,9 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) {
     return -1;
   }
 
-  dDebug("vgId:%d, create vnode req is received, tsma:%d", createReq.vgId, createReq.isTsma);
-
-  SVnodeCfg vnodeCfg = {0};
+  dDebug("vgId:%d, create vnode req is received, tsma:%d standby:%d", createReq.vgId, createReq.isTsma,
+         createReq.standby);
   vmGenerateVnodeCfg(&createReq, &vnodeCfg);
-
-  SWrapperCfg wrapperCfg = {0};
   vmGenerateWrapperCfg(pMgmt, &createReq, &wrapperCfg);
 
   SVnodeObj *pVnode = vmAcquireVnode(pMgmt, createReq.vgId);
@@ -333,8 +333,9 @@ SArray *vmGetMsgHandles() {
   if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_DISPATCH, vmPutNodeMsgToFetchQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_VND_TASK_RECOVER, vmPutNodeMsgToFetchQueue, 0) == NULL) goto _OVER;
 
-  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_VNODE, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
-  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT_VNODE, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_REPLICA, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_ALTER_CONFIG, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
+  if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT, vmPutNodeMsgToWriteQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_VNODE, vmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
   if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_VNODE, vmPutNodeMsgToMgmtQueue, 0) == NULL) goto _OVER;
 

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

@@ -61,7 +61,7 @@ int32_t mndTransAppendRedoAction(STrans *pTrans, STransAction *pAction);
 int32_t mndTransAppendUndoAction(STrans *pTrans, STransAction *pAction);
 void    mndTransSetRpcRsp(STrans *pTrans, void *pCont, int32_t contLen);
 void    mndTransSetCb(STrans *pTrans, ETrnFunc startFunc, ETrnFunc stopFunc, void *param, int32_t paramLen);
-void    mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb);
+void    mndTransSetDbName(STrans *pTrans, const char *dbname);
 void    mndTransSetSerial(STrans *pTrans);
 
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans);

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

@@ -36,7 +36,7 @@ SArray *mndBuildDnodesArray(SMnode *pMnode);
 int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray);
 int32_t mndRemoveVnodeFromVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray, SVnodeGid *del1, SVnodeGid *del2);
 
-void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
+void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen, bool standby);
 void *mndBuildDropVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
 void *mndBuildAlterVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen);
 

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

@@ -261,7 +261,7 @@ void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {
   sdbRelease(pSdb, pDb);
 }
 
-static int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SVnodeGid *pVgid) {
+static int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SVnodeGid *pVgid, bool standby) {
   STransAction action = {0};
 
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
@@ -270,7 +270,7 @@ static int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *p
   mndReleaseDnode(pMnode, pDnode);
 
   int32_t contLen = 0;
-  void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen);
+  void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen, standby);
   if (pReq == NULL) return -1;
 
   action.pCont = pReq;
@@ -286,7 +286,7 @@ static int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *p
   return 0;
 }
 
-static int32_t mndAddAlterVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
+static int32_t mndAddAlterVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, tmsg_t msgType) {
   STransAction action = {0};
   action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
 
@@ -296,7 +296,7 @@ static int32_t mndAddAlterVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pD
 
   action.pCont = pReq;
   action.contLen = contLen;
-  action.msgType = TDMT_VND_ALTER_VNODE;
+  action.msgType = msgType;
 
   if (mndTransAppendRedoAction(pTrans, &action) != 0) {
     taosMemoryFree(pReq);
@@ -388,7 +388,7 @@ static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
   }
 
   terrno = 0;
-  return TSDB_CODE_SUCCESS;
+  return terrno;
 }
 
 static void mndSetDefaultDbCfg(SDbCfg *pCfg) {
@@ -467,7 +467,7 @@ static int32_t mndSetCreateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
 
     for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
       SVnodeGid *pVgid = pVgroup->vnodeGid + vn;
-      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid) != 0) {
+      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, false) != 0) {
         return -1;
       }
     }
@@ -550,7 +550,7 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
 
   mDebug("trans:%d, used to create db:%s", pTrans->id, pCreate->db);
 
-  mndTransSetDbInfo(pTrans, &dbObj);
+  mndTransSetDbName(pTrans, dbObj.name);
   if (mndSetCreateDbRedoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
   if (mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
   if (mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
@@ -688,29 +688,37 @@ static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
 static int32_t mndSetAlterDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
   SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);
   if (pRedoRaw == NULL) return -1;
-  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY) != 0) return -1;
+  if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
+    sdbFreeRaw(pRedoRaw);
+    return -1;
+  }
 
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY);
   return 0;
 }
 
 static int32_t mndSetAlterDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
   SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);
   if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1;
+  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+    sdbFreeRaw(pCommitRaw);
+    return -1;
+  }
 
+  sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
   return 0;
 }
 
 static int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SArray *pArray) {
   if (pVgroup->replica <= 0 || pVgroup->replica == pDb->cfg.replications) {
-    if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, pVgroup) != 0) {
+    if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, pVgroup, TDMT_VND_ALTER_CONFIG) != 0) {
       return -1;
     }
   } else {
     SVgObj newVgroup = {0};
     memcpy(&newVgroup, pVgroup, sizeof(SVgObj));
+    mndTransSetSerial(pTrans);
+
     if (newVgroup.replica < pDb->cfg.replications) {
       mInfo("db:%s, vgId:%d, will add 2 vnodes, vn:0 dnode:%d", pVgroup->dbName, pVgroup->vgId,
             pVgroup->vnodeGid[0].dnodeId);
@@ -720,9 +728,9 @@ static int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
         return -1;
       }
       newVgroup.replica = pDb->cfg.replications;
-      if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, &newVgroup) != 0) return -1;
-      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVgroup, &newVgroup.vnodeGid[1]) != 0) return -1;
-      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVgroup, &newVgroup.vnodeGid[2]) != 0) return -1;
+      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVgroup, &newVgroup.vnodeGid[1], true) != 0) return -1;
+      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVgroup, &newVgroup.vnodeGid[2], true) != 0) return -1;
+      if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, &newVgroup, TDMT_VND_ALTER_REPLICA) != 0) return -1;
     } else {
       mInfo("db:%s, vgId:%d, will remove 2 vnodes", pVgroup->dbName, pVgroup->vgId);
 
@@ -733,15 +741,18 @@ static int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
         return -1;
       }
       newVgroup.replica = pDb->cfg.replications;
-      if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, &newVgroup) != 0) return -1;
+      if (mndAddAlterVnodeAction(pMnode, pTrans, pDb, &newVgroup, TDMT_VND_ALTER_REPLICA) != 0) return -1;
       if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVgroup, &del1, true) != 0) return -1;
       if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVgroup, &del2, true) != 0) return -1;
     }
 
     SSdbRaw *pVgRaw = mndVgroupActionEncode(&newVgroup);
     if (pVgRaw == NULL) return -1;
-    if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) return -1;
-    if (sdbSetRawStatus(pVgRaw, SDB_STATUS_READY) != 0) return -1;
+    if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {
+      sdbFreeRaw(pVgRaw);
+      return -1;
+    }
+    sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
   }
 
   return 0;
@@ -774,18 +785,16 @@ static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
 }
 
 static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *pNew) {
-  int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq);
-  if (pTrans == NULL) goto _OVER;
-
+  if (pTrans == NULL) return -1;
   mDebug("trans:%d, used to alter db:%s", pTrans->id, pOld->name);
 
-  mndTransSetDbInfo(pTrans, pOld);
+  int32_t code = -1;
+  mndTransSetDbName(pTrans, pOld->name);
   if (mndSetAlterDbRedoLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
   if (mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
   if (mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
   if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
-
   code = 0;
 
 _OVER:
@@ -1040,7 +1049,7 @@ static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop db:%s", pTrans->id, pDb->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
 
   if (mndSetDropDbRedoLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
   if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) goto _OVER;

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

@@ -426,7 +426,7 @@ static int32_t mndSetCreateSmaVgroupRedoActions(SMnode *pMnode, STrans *pTrans,
   pVgroup->pTsma = pSmaReq;
 
   int32_t contLen = 0;
-  void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen);
+  void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen, false);
   taosMemoryFreeClear(pSmaReq);
   if (pReq == NULL) return -1;
 
@@ -512,7 +512,7 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to create sma:%s", pTrans->id, pCreate->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
   mndTransSetSerial(pTrans);
 
   if (mndSetCreateSmaRedoLogs(pMnode, pTrans, &smaObj) != 0) goto _OVER;
@@ -757,7 +757,7 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop sma:%s", pTrans->id, pSma->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
 
   if (mndSetDropSmaRedoLogs(pMnode, pTrans, pSma) != 0) goto _OVER;
   if (mndSetDropSmaVgroupRedoLogs(pMnode, pTrans, pVgroup) != 0) goto _OVER;

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

@@ -754,7 +754,7 @@ _OVER:
 }
 
 int32_t mndAddStbToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
   if (mndSetCreateStbRedoLogs(pMnode, pTrans, pDb, pStb) != 0) return -1;
   if (mndSetCreateStbUndoLogs(pMnode, pTrans, pDb, pStb) != 0) return -1;
   if (mndSetCreateStbCommitLogs(pMnode, pTrans, pDb, pStb) != 0) return -1;
@@ -1261,7 +1261,7 @@ static int32_t mndAlterStb(SMnode *pMnode, SRpcMsg *pReq, const SMAlterStbReq *p
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to alter stb:%s", pTrans->id, pAlter->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
 
   if (mndSetAlterStbRedoLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
   if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, &stbObj) != 0) goto _OVER;
@@ -1407,7 +1407,7 @@ static int32_t mndDropStb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *p
   if (pTrans == NULL) goto _OVER;
 
   mDebug("trans:%d, used to drop stb:%s", pTrans->id, pStb->name);
-  mndTransSetDbInfo(pTrans, pDb);
+  mndTransSetDbName(pTrans, pDb->name);
 
   if (mndSetDropStbRedoLogs(pMnode, pTrans, pStb) != 0) goto _OVER;
   if (mndSetDropStbCommitLogs(pMnode, pTrans, pStb) != 0) goto _OVER;

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

@@ -619,8 +619,8 @@ void mndTransSetCb(STrans *pTrans, ETrnFunc startFunc, ETrnFunc stopFunc, void *
   pTrans->paramLen = paramLen;
 }
 
-void mndTransSetDbInfo(STrans *pTrans, SDbObj *pDb) {
-  memcpy(pTrans->dbname, pDb->name, TSDB_DB_FNAME_LEN);
+void mndTransSetDbName(STrans *pTrans, const char *dbname) {
+  memcpy(pTrans->dbname, dbname, TSDB_DB_FNAME_LEN);
 }
 
 void mndTransSetSerial(STrans *pTrans) { pTrans->exec = TRN_EXEC_SERIAL; }

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

@@ -51,9 +51,10 @@ int32_t mndInitVgroup(SMnode *pMnode) {
   };
 
   mndSetMsgHandle(pMnode, TDMT_DND_CREATE_VNODE_RSP, mndProcessCreateVnodeRsp);
-  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_VNODE_RSP, mndProcessAlterVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_REPLICA_RSP, mndProcessAlterVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_ALTER_CONFIG_RSP, mndProcessAlterVnodeRsp);
   mndSetMsgHandle(pMnode, TDMT_DND_DROP_VNODE_RSP, mndProcessDropVnodeRsp);
-  mndSetMsgHandle(pMnode, TDMT_VND_COMPACT_VNODE_RSP, mndProcessCompactVnodeRsp);
+  mndSetMsgHandle(pMnode, TDMT_VND_COMPACT_RSP, mndProcessCompactVnodeRsp);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndRetrieveVgroups);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_VGROUP, mndCancelGetNextVgroup);
@@ -188,10 +189,10 @@ void mndReleaseVgroup(SMnode *pMnode, SVgObj *pVgroup) {
   sdbRelease(pSdb, pVgroup);
 }
 
-void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen) {
+void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen,
+                             bool standby) {
   SCreateVnodeReq createReq = {0};
   createReq.vgId = pVgroup->vgId;
-  createReq.dnodeId = pDnode->id;
   memcpy(createReq.db, pDb->name, TSDB_DB_FNAME_LEN);
   createReq.dbUid = pDb->uid;
   createReq.vgVersion = pVgroup->version;
@@ -218,6 +219,7 @@ void *mndBuildCreateVnodeReq(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVg
   createReq.hashMethod = pDb->cfg.hashMethod;
   createReq.numOfRetensions = pDb->cfg.numOfRetensions;
   createReq.pRetensions = pDb->cfg.pRetensions;
+  createReq.standby = standby;
   createReq.isTsma = pVgroup->isTsma;
   createReq.pTsma = pVgroup->pTsma;
 
@@ -276,7 +278,6 @@ void *mndBuildAlterVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup, int32_
   alterReq.strict = pDb->cfg.strict;
   alterReq.cacheLastRow = pDb->cfg.cacheLastRow;
   alterReq.replica = pVgroup->replica;
-  alterReq.selfIndex = -1;
 
   for (int32_t v = 0; v < pVgroup->replica; ++v) {
     SReplica  *pReplica = &alterReq.replicas[v];
@@ -292,13 +293,6 @@ void *mndBuildAlterVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup, int32_
     mndReleaseDnode(pMnode, pVgidDnode);
   }
 
-#if 0
-  if (alterReq.selfIndex == -1) {
-    terrno = TSDB_CODE_MND_APP_ERROR;
-    return NULL;
-  }
-#endif
-
   int32_t contLen = tSerializeSAlterVnodeReq(NULL, 0, &alterReq);
   if (contLen < 0) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -510,7 +504,7 @@ _OVER:
   taosArrayDestroy(pArray);
   return code;
 }
-
+//--->
 int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
   taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
   for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
@@ -538,7 +532,7 @@ int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
 
     SVnodeGid *pVgid = &pVgroup->vnodeGid[maxPos];
     pVgid->dnodeId = pDnode->id;
-    pVgid->role = TAOS_SYNC_STATE_FOLLOWER;
+    pVgid->role = TAOS_SYNC_STATE_ERROR;
     pDnode->numOfVnodes++;
 
     mInfo("db:%s, vgId:%d, vnode_index:%d dnode:%d is added", pVgroup->dbName, pVgroup->vgId, maxPos, pVgid->dnodeId);
@@ -549,16 +543,15 @@ int32_t mndAddVnodeToVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
   terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
   return -1;
 }
-
+//--->
 int32_t mndRemoveVnodeFromVgroup(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray, SVnodeGid *del1, SVnodeGid *del2) {
-  int32_t removedNum = 0;
-
   taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
   for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
     SDnodeObj *pDnode = taosArrayGet(pArray, i);
     mDebug("dnode:%d, equivalent vnodes:%d", pDnode->id, pDnode->numOfVnodes);
   }
 
+  int32_t removedNum = 0;
   for (int32_t d = taosArrayGetSize(pArray) - 1; d >= 0; --d) {
     SDnodeObj *pDnode = taosArrayGet(pArray, d);
 
@@ -664,6 +657,7 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
   int32_t numOfRows = 0;
   SVgObj *pVgroup = NULL;
   int32_t cols = 0;
+  int64_t curMs = taosGetTimestampMs();
 
   SDbObj *pDb = NULL;
   if (strlen(pShow->db) > 0) {
@@ -703,12 +697,15 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
       if (i < pVgroup->replica) {
         colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->vnodeGid[i].dnodeId, false);
 
+        bool       online = false;
+        SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgroup->vnodeGid[i].dnodeId);
+        if (pDnode != NULL) {
+          online = mndIsDnodeOnline(pMnode, pDnode, curMs);
+          mndReleaseDnode(pMnode, pDnode);
+        }
+
         char        buf1[20] = {0};
-        SDnodeObj *pDnodeObj = mndAcquireDnode(pMnode, pVgroup->vnodeGid[i].dnodeId);
-        ASSERT(pDnodeObj != NULL);
-        bool isOffLine = !mndIsDnodeOnline(pMnode, pDnodeObj, taosGetTimestampMs());
-        const char *role = isOffLine ? "OFFLINE" : syncStr(pVgroup->vnodeGid[i].role);
-        
+        const char *role = online ? syncStr(pVgroup->vnodeGid[i].role) : "OFFLINE";
         STR_WITH_MAXSIZE_TO_VARSTR(buf1, role, pShow->pMeta->pSchemas[cols].bytes);
 
         pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

source/dnode/mnode/impl/test/trans/trans2.cpp

@@ -128,7 +128,7 @@ class MndTestTrans2 : public ::testing::Test {
     mndTransSetCb(pTrans, TRANS_START_FUNC_TEST, TRANS_STOP_FUNC_TEST, param, strlen(param) + 1);
 
     if (pDb != NULL) {
-      mndTransSetDbInfo(pTrans, pDb);
+      mndTransSetDbName(pTrans, pDb->name);
     }
 
     int32_t code = mndTransPrepare(pMnode, pTrans);
@@ -201,7 +201,7 @@ class MndTestTrans2 : public ::testing::Test {
     }
 
     if (pDb != NULL) {
-      mndTransSetDbInfo(pTrans, pDb);
+      mndTransSetDbName(pTrans, pDb->name);
     }
 
     int32_t code = mndTransPrepare(pMnode, pTrans);

source/dnode/vnode/CMakeLists.txt

@@ -35,7 +35,6 @@ target_sources(
     "src/sma/smaTimeRange.c"
 
     # tsdb
-    # "src/tsdb/tsdbTDBImpl.c"
     "src/tsdb/tsdbCommit.c"
     "src/tsdb/tsdbCommit2.c"
     "src/tsdb/tsdbFile.c"
@@ -45,7 +44,6 @@ target_sources(
     "src/tsdb/tsdbMemTable2.c"
     "src/tsdb/tsdbRead.c"
     "src/tsdb/tsdbReadImpl.c"
-    # "src/tsdb/tsdbSma.c"
     "src/tsdb/tsdbWrite.c"
     "src/tsdb/tsdbSnapshot.c"
 
@@ -55,8 +53,9 @@ target_sources(
     "src/tq/tqMeta.c"
     "src/tq/tqRead.c"
     "src/tq/tqOffset.c"
-    #"src/tq/tqPush.c"
-    #"src/tq/tqCommit.c"
+    "src/tq/tqPush.c"
+    "src/tq/tqSink.c"
+    "src/tq/tqCommit.c"
 )
 target_include_directories(
     vnode

source/dnode/vnode/inc/vnode.h

@@ -175,6 +175,7 @@ struct SVnodeCfg {
   int8_t   isTsma;
   int8_t   isRsma;
   int8_t   hashMethod;
+  int8_t   standby;
   STsdbCfg tsdbCfg;
   SWalCfg  walCfg;
   SSyncCfg syncCfg;

source/dnode/vnode/src/inc/sma.h

@@ -219,7 +219,7 @@ static int32_t  tdInitSmaEnv(SSma *pSma, int8_t smaType, const char *path, SDisk
 void *tdFreeRSmaInfo(SRSmaInfo *pInfo);
 
 int32_t tdProcessTSmaCreateImpl(SSma *pSma, int64_t version, const char *pMsg);
-int32_t tdUpdateExpiredWindowImpl(SSma *pSma, SSubmitReq *pMsg, int64_t version);
+int32_t tdUpdateExpiredWindowImpl(SSma *pSma, const SSubmitReq *pMsg, int64_t version);
 // TODO: This is the basic params, and should wrap the params to a queryHandle.
 int32_t tdGetTSmaDataImpl(SSma *pSma, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult);
 
@@ -227,4 +227,4 @@ int32_t tdGetTSmaDataImpl(SSma *pSma, char *pData, int64_t indexUid, TSKEY query
 }
 #endif
 
-#endif /*_TD_VNODE_SMA_H_*/
\ No newline at end of file
+#endif /*_TD_VNODE_SMA_H_*/

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

@@ -66,33 +66,27 @@ struct STqReadHandle {
 // tqPush
 
 typedef struct {
-  int64_t        consumerId;
-  int32_t        epoch;
-  int32_t        skipLogNum;
-  int64_t        reqOffset;
-  SRpcHandleInfo info;
-  SRWLatch       lock;
-} STqPushHandle;
+  STaosQueue* queue;
+  STaosQall*  qall;
+  void*       qItem;
+} STqInputQ;
 
-#if 0
 typedef struct {
-  char    subKey[TSDB_SUBSCRIBE_KEY_LEN];
+  // msg info
   int64_t consumerId;
+  int64_t reqOffset;
+  int64_t processedVer;
   int32_t epoch;
-  int8_t  subType;
-  // int8_t        withTbName;
-  // int8_t        withSchema;
-  // int8_t        withTag;
-  char*         qmsg;
-  SHashObj*     pDropTbUid;
-  STqPushHandle pushHandle;
-  // SRWLatch        lock;
-  SWalReadHandle* pWalReader;
-  // task number should be the same with fetch thread
-  STqReadHandle* pExecReader[5];
-  qTaskInfo_t    task[5];
-} STqExec;
-#endif
+  int32_t skipLogNum;
+  // rpc info
+  int64_t        reqId;
+  SRpcHandleInfo rpcInfo;
+  // exec
+  int8_t    inputStatus;
+  int8_t    execStatus;
+  STqInputQ inputQ;
+  SRWLatch  lock;
+} STqPushHandle;
 
 // tqExec
 
@@ -154,27 +148,21 @@ typedef struct {
 
 static STqMgmt tqMgmt = {0};
 
-// init once
-int  tqInit();
-void tqCleanUp();
-
-// int32_t tEncodeSTqExec(SEncoder* pEncoder, const STqExec* pExec);
-// int32_t tDecodeSTqExec(SDecoder* pDecoder, STqExec* pExec);
-
-int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle);
-int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle);
-
+// tqRead
 int64_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, SWalHead** pHeadWithCkSum);
 
+// tqExec
 int32_t tqDataExec(STQ* pTq, STqExecHandle* pExec, SSubmitReq* pReq, SMqDataBlkRsp* pRsp, int32_t workerId);
 
 // tqMeta
-
 int32_t tqMetaOpen(STQ* pTq);
 int32_t tqMetaClose(STQ* pTq);
 int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle);
 int32_t tqMetaDeleteHandle(STQ* pTq, const char* key);
 
+// tqSink
+void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data);
+
 // tqOffset
 STqOffsetStore* STqOffsetOpen(STqOffsetCfg*);
 void            STqOffsetClose(STqOffsetStore*);

source/dnode/vnode/src/inc/tsdb.h

@@ -32,14 +32,27 @@ extern "C" {
 #define tsdbTrace(...) do { if (tsdbDebugFlag & DEBUG_TRACE) { taosPrintLog("TSDB ", DEBUG_TRACE, tsdbDebugFlag, __VA_ARGS__); }} while(0)
 // clang-format on
 
+typedef struct TSDBROW TSDBROW;
+typedef struct TSDBKEY TSDBKEY;
+typedef struct SDelOp  SDelOp;
+
+static int tsdbKeyCmprFn(const void *p1, const void *p2);
+
+// tsdbMemTable2.c ==============================================================================================
+typedef struct SMemTable SMemTable;
+
+int32_t tsdbMemTableCreate2(STsdb *pTsdb, SMemTable **ppMemTable);
+void    tsdbMemTableDestroy2(SMemTable *pMemTable);
+
 // tsdbMemTable ================
+typedef struct STsdbRow      STsdbRow;
 typedef struct STbData       STbData;
 typedef struct STsdbMemTable STsdbMemTable;
 typedef struct SMergeInfo    SMergeInfo;
 typedef struct STable        STable;
 
 int  tsdbMemTableCreate(STsdb *pTsdb, STsdbMemTable **ppMemTable);
-void tsdbMemTableDestroy(STsdb *pTsdb, STsdbMemTable *pMemTable);
+void tsdbMemTableDestroy(STsdbMemTable *pMemTable);
 int  tsdbLoadDataFromCache(STsdb *pTsdb, STable *pTable, SSkipListIterator *pIter, TSKEY maxKey, int maxRowsToRead,
                            SDataCols *pCols, TKEY *filterKeys, int nFilterKeys, bool keepDup, SMergeInfo *pMergeInfo);
 
@@ -845,6 +858,42 @@ static FORCE_INLINE int tsdbUnLockFS(STsdbFS *pFs) {
   return 0;
 }
 
+struct TSDBROW {
+  int64_t version;
+  STSRow2 tsRow;
+};
+
+struct TSDBKEY {
+  int64_t version;
+  TSKEY   ts;
+};
+
+struct SDelOp {
+  int64_t version;
+  TSKEY   sKey;  // included
+  TSKEY   eKey;  // included
+  SDelOp *pNext;
+};
+
+static FORCE_INLINE int tsdbKeyCmprFn(const void *p1, const void *p2) {
+  TSDBKEY *pKey1 = (TSDBKEY *)p1;
+  TSDBKEY *pKey2 = (TSDBKEY *)p2;
+
+  if (pKey1->ts < pKey2->ts) {
+    return -1;
+  } else if (pKey1->ts > pKey2->ts) {
+    return 1;
+  }
+
+  if (pKey1->version < pKey2->version) {
+    return -1;
+  } else if (pKey1->version > pKey2->version) {
+    return 1;
+  }
+
+  return 0;
+}
+
 #endif
 
 #ifdef __cplusplus

source/dnode/vnode/src/inc/vnd.h

@@ -81,9 +81,10 @@ int32_t vnodeSyncCommit(SVnode* pVnode);
 int32_t vnodeAsyncCommit(SVnode* pVnode);
 
 // vnodeSync.c
-int32_t   vnodeSyncOpen(SVnode* pVnode, char* path);
-void      vnodeSyncStart(SVnode* pVnode);
-void      vnodeSyncClose(SVnode* pVnode);
+int32_t vnodeSyncOpen(SVnode* pVnode, char* path);
+void    vnodeSyncStart(SVnode* pVnode);
+void    vnodeSyncClose(SVnode* pVnode);
+void    vnodeSyncAlter(SVnode* pVnode, SRpcMsg* pMsg);
 
 #ifdef __cplusplus
 }

source/dnode/vnode/src/inc/vnodeInt.h

@@ -125,6 +125,8 @@ int32_t      tsdbSnapshotReaderClose(STsdbSnapshotReader* pReader);
 int32_t      tsdbSnapshotRead(STsdbSnapshotReader* pReader, void** ppData, uint32_t* nData);
 
 // tq
+int     tqInit();
+void    tqCleanUp();
 STQ*    tqOpen(const char* path, SVnode* pVnode, SWal* pWal);
 void    tqClose(STQ*);
 int     tqPushMsg(STQ*, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver);
@@ -145,11 +147,11 @@ int32_t tqProcessTaskRecoverRsp(STQ* pTq, SRpcMsg* pMsg);
 int32_t smaOpen(SVnode* pVnode);
 int32_t smaClose(SSma* pSma);
 
-int32_t tdUpdateExpireWindow(SSma* pSma, SSubmitReq* pMsg, int64_t version);
+int32_t tdUpdateExpireWindow(SSma* pSma, const SSubmitReq* pMsg, int64_t version);
 int32_t tdProcessTSmaCreate(SSma* pSma, int64_t version, const char* msg);
 int32_t tdProcessTSmaInsert(SSma* pSma, int64_t indexUid, const char* msg);
 
-int32_t tdProcessRSmaCreate(SVnode *pVnode, SVCreateStbReq* pReq);
+int32_t tdProcessRSmaCreate(SVnode* pVnode, SVCreateStbReq* pReq);
 int32_t tdProcessRSmaSubmit(SSma* pSma, void* pMsg, int32_t inputType);
 int32_t tdFetchTbUidList(SSma* pSma, STbUidStore** ppStore, tb_uid_t suid, tb_uid_t uid);
 int32_t tdUpdateTbUidList(SSma* pSma, STbUidStore* pUidStore);

source/dnode/vnode/src/meta/metaTable.c

@@ -31,9 +31,9 @@ int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
   int         vLen = 0;
   const void *pKey = NULL;
   const void *pVal = NULL;
-  void *      pBuf = NULL;
+  void       *pBuf = NULL;
   int32_t     szBuf = 0;
-  void *      p = NULL;
+  void       *p = NULL;
   SMetaReader mr = {0};
 
   // validate req
@@ -87,7 +87,7 @@ int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq) {
   }
 
   // drop all child tables
-  TBC *   pCtbIdxc = NULL;
+  TBC    *pCtbIdxc = NULL;
   SArray *pArray = taosArrayInit(8, sizeof(tb_uid_t));
 
   tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, &pMeta->txn);
@@ -142,8 +142,8 @@ _exit:
 int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
   SMetaEntry  oStbEntry = {0};
   SMetaEntry  nStbEntry = {0};
-  TBC *       pUidIdxc = NULL;
-  TBC *       pTbDbc = NULL;
+  TBC        *pUidIdxc = NULL;
+  TBC        *pTbDbc = NULL;
   const void *pData;
   int         nData;
   int64_t     oversion;
@@ -262,7 +262,7 @@ _err:
 }
 
 int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUids) {
-  void *   pData = NULL;
+  void    *pData = NULL;
   int      nData = 0;
   int      rc = 0;
   tb_uid_t uid;
@@ -288,7 +288,7 @@ int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUi
 }
 
 static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
-  void *     pData = NULL;
+  void      *pData = NULL;
   int        nData = 0;
   int        rc = 0;
   int64_t    version;
@@ -324,14 +324,14 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
 }
 
 static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
-  void *          pVal = NULL;
+  void           *pVal = NULL;
   int             nVal = 0;
-  const void *    pData = NULL;
+  const void     *pData = NULL;
   int             nData = 0;
   int             ret = 0;
   tb_uid_t        uid;
   int64_t         oversion;
-  SSchema *       pColumn = NULL;
+  SSchema        *pColumn = NULL;
   SMetaEntry      entry = {0};
   SSchemaWrapper *pSchema;
   int             c;
@@ -479,7 +479,7 @@ _err:
 static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
   SMetaEntry  ctbEntry = {0};
   SMetaEntry  stbEntry = {0};
-  void *      pVal = NULL;
+  void       *pVal = NULL;
   int         nVal = 0;
   int         ret;
   int         c;
@@ -510,7 +510,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
   oversion = *(int64_t *)pData;
 
   // search table.db
-  TBC *    pTbDbc = NULL;
+  TBC     *pTbDbc = NULL;
   SDecoder dc1 = {0};
   SDecoder dc2 = {0};
 
@@ -534,7 +534,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
   metaDecodeEntry(&dc2, &stbEntry);
 
   SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag;
-  SSchema *       pColumn = NULL;
+  SSchema        *pColumn = NULL;
   int32_t         iCol = 0;
   for (;;) {
     pColumn = NULL;
@@ -579,7 +579,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
         if (IS_VAR_DATA_TYPE(pCol->type)) {
           val.pData = pAlterTbReq->pTagVal;
           val.nData = pAlterTbReq->nTagVal;
-        }else{
+        } else {
           memcpy(&val.i64, pAlterTbReq->pTagVal, pAlterTbReq->nTagVal);
         }
         taosArrayPush(pTagArray, &val);
@@ -649,8 +649,8 @@ int metaAlterTable(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) {
 
 static int metaSaveToTbDb(SMeta *pMeta, const SMetaEntry *pME) {
   STbDbKey tbDbKey;
-  void *   pKey = NULL;
-  void *   pVal = NULL;
+  void    *pKey = NULL;
+  void    *pVal = NULL;
   int      kLen = 0;
   int      vLen = 0;
   SEncoder coder = {0};
@@ -732,7 +732,7 @@ static int metaUpdateCtbIdx(SMeta *pMeta, const SMetaEntry *pME) {
 }
 
 int metaCreateTagIdxKey(tb_uid_t suid, int32_t cid, const void *pTagData, int32_t nTagData, int8_t type, tb_uid_t uid,
-                               STagIdxKey **ppTagIdxKey, int32_t *nTagIdxKey) {
+                        STagIdxKey **ppTagIdxKey, int32_t *nTagIdxKey) {
   // int32_t nTagData = 0;
 
   // if (pTagData) {
@@ -765,11 +765,11 @@ static void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey) {
 }
 
 static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
-  void *         pData = NULL;
+  void          *pData = NULL;
   int            nData = 0;
   STbDbKey       tbDbKey = {0};
   SMetaEntry     stbEntry = {0};
-  STagIdxKey *   pTagIdxKey = NULL;
+  STagIdxKey    *pTagIdxKey = NULL;
   int32_t        nTagIdxKey;
   const SSchema *pTagColumn;       // = &stbEntry.stbEntry.schema.pSchema[0];
   const void    *pTagData = NULL;  //
@@ -788,21 +788,20 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
   pTagColumn = &stbEntry.stbEntry.schemaTag.pSchema[0];
 
   STagVal tagVal = {.cid = pTagColumn->colId};
-  if(pTagColumn->type != TSDB_DATA_TYPE_JSON){
+  if (pTagColumn->type != TSDB_DATA_TYPE_JSON) {
     tTagGet((const STag *)pCtbEntry->ctbEntry.pTags, &tagVal);
-    if(IS_VAR_DATA_TYPE(pTagColumn->type)){
+    if (IS_VAR_DATA_TYPE(pTagColumn->type)) {
       pTagData = tagVal.pData;
       nTagData = (int32_t)tagVal.nData;
-    }else{
+    } else {
       pTagData = &(tagVal.i64);
       nTagData = tDataTypes[pTagColumn->type].bytes;
     }
-  }else{
-    //pTagData = pCtbEntry->ctbEntry.pTags;
-    //nTagData = ((const STag *)pCtbEntry->ctbEntry.pTags)->len;
+  } else {
+    // pTagData = pCtbEntry->ctbEntry.pTags;
+    // nTagData = ((const STag *)pCtbEntry->ctbEntry.pTags)->len;
   }
 
-
   // update tag index
 #ifdef USE_INVERTED_INDEX
   tb_uid_t suid = pCtbEntry->ctbEntry.suid;
@@ -816,8 +815,8 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
   int ret = indexPut((SIndex *)pMeta->pTagIvtIdx, tmGroup, tuid);
   indexMultiTermDestroy(tmGroup);
 #else
-  if (metaCreateTagIdxKey(pCtbEntry->ctbEntry.suid, pTagColumn->colId, pTagData, nTagData, pTagColumn->type, pCtbEntry->uid,
-                          &pTagIdxKey, &nTagIdxKey) < 0) {
+  if (metaCreateTagIdxKey(pCtbEntry->ctbEntry.suid, pTagColumn->colId, pTagData, nTagData, pTagColumn->type,
+                          pCtbEntry->uid, &pTagIdxKey, &nTagIdxKey) < 0) {
     return -1;
   }
   tdbTbInsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, &pMeta->txn);
@@ -830,7 +829,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
 
 static int metaSaveToSkmDb(SMeta *pMeta, const SMetaEntry *pME) {
   SEncoder              coder = {0};
-  void *                pVal = NULL;
+  void                 *pVal = NULL;
   int                   vLen = 0;
   int                   rcode = 0;
   SSkmDbKey             skmDbKey = {0};

source/dnode/vnode/src/sma/sma.c

@@ -15,7 +15,6 @@
 
 #include "sma.h"
 
-
 // TODO: Who is responsible for resource allocate and release?
 int32_t tdProcessTSmaInsert(SSma* pSma, int64_t indexUid, const char* msg) {
   int32_t code = TSDB_CODE_SUCCESS;
@@ -37,7 +36,7 @@ int32_t tdProcessTSmaCreate(SSma* pSma, int64_t version, const char* msg) {
   return code;
 }
 
-int32_t tdUpdateExpireWindow(SSma* pSma, SSubmitReq* pMsg, int64_t version) {
+int32_t tdUpdateExpireWindow(SSma* pSma, const SSubmitReq* pMsg, int64_t version) {
   int32_t code = TSDB_CODE_SUCCESS;
   if ((code = tdUpdateExpiredWindowImpl(pSma, pMsg, version)) < 0) {
     smaWarn("vgId:%d update expired sma window failed since %s", SMA_VID(pSma), tstrerror(terrno));

source/dnode/vnode/src/sma/smaTimeRange.c

@@ -932,7 +932,7 @@ static int32_t tdSetExpiredWindow(SSma *pSma, SHashObj *pItemsHash, int64_t inde
  * @param msg SSubmitReq
  * @return int32_t
  */
-int32_t tdUpdateExpiredWindowImpl(SSma *pSma, SSubmitReq *pMsg, int64_t version) {
+int32_t tdUpdateExpiredWindowImpl(SSma *pSma, const SSubmitReq *pMsg, int64_t version) {
   // no time-range-sma, just return success
   if (atomic_load_16(&SMA_TSMA_NUM(pSma)) <= 0) {
     smaTrace("vgId:%d not update expire window since no tSma", SMA_VID(pSma));

source/dnode/vnode/src/tq/tq.c

@@ -81,169 +81,10 @@ void tqClose(STQ* pTq) {
   // TODO
 }
 
-int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle) {
-  if (tStartEncode(pEncoder) < 0) return -1;
-  if (tEncodeCStr(pEncoder, pHandle->subKey) < 0) return -1;
-  if (tEncodeI64(pEncoder, pHandle->consumerId) < 0) return -1;
-  if (tEncodeI32(pEncoder, pHandle->epoch) < 0) return -1;
-  if (tEncodeI8(pEncoder, pHandle->execHandle.subType) < 0) return -1;
-  if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-    if (tEncodeCStr(pEncoder, pHandle->execHandle.exec.execCol.qmsg) < 0) return -1;
-  }
-  tEndEncode(pEncoder);
-  return pEncoder->pos;
-}
-
-int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
-  if (tStartDecode(pDecoder) < 0) return -1;
-  if (tDecodeCStrTo(pDecoder, pHandle->subKey) < 0) return -1;
-  if (tDecodeI64(pDecoder, &pHandle->consumerId) < 0) return -1;
-  if (tDecodeI32(pDecoder, &pHandle->epoch) < 0) return -1;
-  if (tDecodeI8(pDecoder, &pHandle->execHandle.subType) < 0) return -1;
-  if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-    if (tDecodeCStrAlloc(pDecoder, &pHandle->execHandle.exec.execCol.qmsg) < 0) return -1;
-  }
-  tEndDecode(pDecoder);
-  return 0;
-}
-
-int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
-  void* pIter = NULL;
-  while (1) {
-    pIter = taosHashIterate(pTq->handles, pIter);
-    if (pIter == NULL) break;
-    STqHandle* pExec = (STqHandle*)pIter;
-    if (pExec->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
-      for (int32_t i = 0; i < 5; i++) {
-        int32_t code = qUpdateQualifiedTableId(pExec->execHandle.exec.execCol.task[i], tbUidList, isAdd);
-        ASSERT(code == 0);
-      }
-    } else if (pExec->execHandle.subType == TOPIC_SUB_TYPE__DB) {
-      if (!isAdd) {
-        int32_t sz = taosArrayGetSize(tbUidList);
-        for (int32_t i = 0; i < sz; i++) {
-          int64_t tbUid = *(int64_t*)taosArrayGet(tbUidList, i);
-          taosHashPut(pExec->execHandle.exec.execDb.pFilterOutTbUid, &tbUid, sizeof(int64_t), NULL, 0);
-        }
-      }
-    } else {
-      // tq update id
-    }
-  }
-  while (1) {
-    pIter = taosHashIterate(pTq->pStreamTasks, pIter);
-    if (pIter == NULL) break;
-    SStreamTask* pTask = (SStreamTask*)pIter;
-    if (pTask->inputType == STREAM_INPUT__DATA_SUBMIT) {
-      int32_t code = qUpdateQualifiedTableId(pTask->exec.executor, tbUidList, isAdd);
-      ASSERT(code == 0);
-    }
-  }
-  return 0;
-}
-
-int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver, SRpcHandleInfo handleInfo) {
-  if (msgType != TDMT_VND_SUBMIT) return 0;
-  void*       pIter = NULL;
-  STqHandle*  pHandle = NULL;
-  SSubmitReq* pReq = (SSubmitReq*)msg;
-  int32_t     workerId = 4;
-  int64_t     fetchOffset = ver;
-
-  while (1) {
-    pIter = taosHashIterate(pTq->pushMgr, pIter);
-    if (pIter == NULL) break;
-    pHandle = *(STqHandle**)pIter;
-
-    taosWLockLatch(&pHandle->pushHandle.lock);
-
-    SMqDataBlkRsp rsp = {0};
-    rsp.reqOffset = pHandle->pushHandle.reqOffset;
-    rsp.blockData = taosArrayInit(0, sizeof(void*));
-    rsp.blockDataLen = taosArrayInit(0, sizeof(int32_t));
-
-    if (msgType == TDMT_VND_SUBMIT) {
-      tqDataExec(pTq, &pHandle->execHandle, pReq, &rsp, workerId);
-    } else {
-      // TODO
-      ASSERT(0);
-    }
-
-    if (rsp.blockNum == 0) {
-      taosWUnLockLatch(&pHandle->pushHandle.lock);
-      continue;
-    }
-
-    ASSERT(taosArrayGetSize(rsp.blockData) == rsp.blockNum);
-    ASSERT(taosArrayGetSize(rsp.blockDataLen) == rsp.blockNum);
-
-    rsp.rspOffset = fetchOffset;
-
-    int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqDataBlkRsp(NULL, &rsp);
-    void*   buf = rpcMallocCont(tlen);
-    if (buf == NULL) {
-      // todo free
-      return -1;
-    }
-
-    ((SMqRspHead*)buf)->mqMsgType = TMQ_MSG_TYPE__POLL_RSP;
-    ((SMqRspHead*)buf)->epoch = pHandle->pushHandle.epoch;
-    ((SMqRspHead*)buf)->consumerId = pHandle->pushHandle.consumerId;
-
-    void* abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead));
-    tEncodeSMqDataBlkRsp(&abuf, &rsp);
-
-    SRpcMsg resp = {
-        .info = pHandle->pushHandle.info,
-        .pCont = buf,
-        .contLen = tlen,
-        .code = 0,
-    };
-    tmsgSendRsp(&resp);
-
-    memset(&pHandle->pushHandle.info, 0, sizeof(SRpcHandleInfo));
-    taosWUnLockLatch(&pHandle->pushHandle.lock);
-
-    tqDebug("vg %d offset %ld from consumer %ld (epoch %d) send rsp, block num: %d, reqOffset: %ld, rspOffset: %ld",
-            TD_VID(pTq->pVnode), fetchOffset, pHandle->pushHandle.consumerId, pHandle->pushHandle.epoch, rsp.blockNum,
-            rsp.reqOffset, rsp.rspOffset);
-
-    // TODO destroy
-    taosArrayDestroy(rsp.blockData);
-    taosArrayDestroy(rsp.blockDataLen);
-  }
-
-  return 0;
-}
-
-int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver) {
-  if (msgType == TDMT_VND_SUBMIT) {
-    if (taosHashGetSize(pTq->pStreamTasks) == 0) return 0;
-
-    if (tdUpdateExpireWindow(pTq->pVnode->pSma, msg, ver) != 0) {
-      // TODO handle sma error
-    }
-    void* data = taosMemoryMalloc(msgLen);
-    if (data == NULL) {
-      return -1;
-    }
-    memcpy(data, msg, msgLen);
-
-    tqProcessStreamTrigger(pTq, data);
-  }
-
-  return 0;
-}
-
-int tqCommit(STQ* pTq) {
-  // do nothing
-  return 0;
-}
-
 int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   SMqPollReq* pReq = pMsg->pCont;
   int64_t     consumerId = pReq->consumerId;
-  int64_t     waitTime = pReq->timeout;
+  int64_t     timeout = pReq->timeout;
   int32_t     reqEpoch = pReq->epoch;
   int64_t     fetchOffset;
 
@@ -286,20 +127,18 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
   }
   if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
     rsp.withSchema = false;
-
     rsp.withTag = false;
   } else {
     rsp.withSchema = true;
-    rsp.blockSchema = taosArrayInit(0, sizeof(void*));
-
     rsp.withTag = false;
+    rsp.blockSchema = taosArrayInit(0, sizeof(void*));
   }
 
   while (1) {
     consumerEpoch = atomic_load_32(&pHandle->epoch);
     if (consumerEpoch > reqEpoch) {
-      tqDebug("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, found new consumer epoch %d discard req epoch %d",
-              consumerId, pReq->epoch, TD_VID(pTq->pVnode), fetchOffset, consumerEpoch, reqEpoch);
+      tqWarn("tmq poll: consumer %ld (epoch %d) vg %d offset %ld, found new consumer epoch %d, discard req epoch %d",
+             consumerId, pReq->epoch, TD_VID(pTq->pVnode), fetchOffset, consumerEpoch, reqEpoch);
       break;
     }
 
@@ -310,27 +149,6 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg, int32_t workerId) {
 
     SWalReadHead* pHead = &pHeadWithCkSum->head;
 
-#if 0
-      // add to pushMgr
-      taosWLockLatch(&pExec->pushHandle.lock);
-
-      pExec->pushHandle.consumerId = consumerId;
-      pExec->pushHandle.epoch = reqEpoch;
-      pExec->pushHandle.reqOffset = rsp.reqOffset;
-      pExec->pushHandle.skipLogNum = rsp.skipLogNum;
-      pExec->pushHandle.handle = pMsg;
-
-      taosWUnLockLatch(&pExec->pushHandle.lock);
-
-      // TODO add timer
-
-      // TODO: the pointer will always be valid?
-      taosHashPut(pTq->pushMgr, &consumerId, sizeof(int64_t), &pExec, sizeof(void*));
-      taosArrayDestroy(rsp.blockData);
-      taosArrayDestroy(rsp.blockDataLen);
-      return 0;
-#endif
-
     tqDebug("tmq poll: consumer %ld (epoch %d) iter log, vg %d offset %ld msgType %d", consumerId, pReq->epoch,
             TD_VID(pTq->pVnode), fetchOffset, pHead->msgType);
 
@@ -471,24 +289,6 @@ int32_t tqProcessVgChangeReq(STQ* pTq, char* msg, int32_t msgLen) {
   return 0;
 }
 
-void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {
-  const SArray* pRes = (const SArray*)data;
-  SVnode*       pVnode = (SVnode*)vnode;
-
-  ASSERT(pTask->tbSink.pTSchema);
-  SSubmitReq* pReq = tdBlockToSubmit(pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
-                                     pTask->tbSink.stbFullName, pVnode->config.vgId);
-  /*tPrintFixedSchemaSubmitReq(pReq, pTask->tbSink.pTSchema);*/
-  // build write msg
-  SRpcMsg msg = {
-      .msgType = TDMT_VND_SUBMIT,
-      .pCont = pReq,
-      .contLen = ntohl(pReq->length),
-  };
-
-  ASSERT(tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg) == 0);
-}
-
 int32_t tqProcessTaskDeploy(STQ* pTq, char* msg, int32_t msgLen) {
   SStreamTask* pTask = taosMemoryCalloc(1, sizeof(SStreamTask));
   if (pTask == NULL) {
@@ -579,9 +379,11 @@ int32_t tqProcessStreamTrigger(STQ* pTq, SSubmitReq* pReq) {
         continue;
       }
 
-      streamDataSubmitRefInc(pSubmit);
-      SStreamDataSubmit* pSubmitClone = taosAllocateQitem(sizeof(SStreamDataSubmit), DEF_QITEM);
-      memcpy(pSubmitClone, pSubmit, sizeof(SStreamDataSubmit));
+      SStreamDataSubmit* pSubmitClone = streamSubmitRefClone(pSubmit);
+      if (pSubmitClone == NULL) {
+        atomic_store_8(&pTask->inputStatus, TASK_INPUT_STATUS__FAILED);
+        continue;
+      }
       taosWriteQitem(pTask->inputQ, pSubmitClone);
 
       int8_t execStatus = atomic_load_8(&pTask->status);

source/dnode/vnode/src/tq/tqCommit.c

@@ -14,3 +14,8 @@
  */
 
 #include "tq.h"
+
+int tqCommit(STQ* pTq) {
+  // do nothing
+  return 0;
+}

source/dnode/vnode/src/tq/tqMeta.c

@@ -15,6 +15,32 @@
 #include "tdbInt.h"
 #include "tq.h"
 
+static int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle) {
+  if (tStartEncode(pEncoder) < 0) return -1;
+  if (tEncodeCStr(pEncoder, pHandle->subKey) < 0) return -1;
+  if (tEncodeI64(pEncoder, pHandle->consumerId) < 0) return -1;
+  if (tEncodeI32(pEncoder, pHandle->epoch) < 0) return -1;
+  if (tEncodeI8(pEncoder, pHandle->execHandle.subType) < 0) return -1;
+  if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+    if (tEncodeCStr(pEncoder, pHandle->execHandle.exec.execCol.qmsg) < 0) return -1;
+  }
+  tEndEncode(pEncoder);
+  return pEncoder->pos;
+}
+
+static int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
+  if (tStartDecode(pDecoder) < 0) return -1;
+  if (tDecodeCStrTo(pDecoder, pHandle->subKey) < 0) return -1;
+  if (tDecodeI64(pDecoder, &pHandle->consumerId) < 0) return -1;
+  if (tDecodeI32(pDecoder, &pHandle->epoch) < 0) return -1;
+  if (tDecodeI8(pDecoder, &pHandle->execHandle.subType) < 0) return -1;
+  if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+    if (tDecodeCStrAlloc(pDecoder, &pHandle->execHandle.exec.execCol.qmsg) < 0) return -1;
+  }
+  tEndDecode(pDecoder);
+  return 0;
+}
+
 int tqExecKeyCompare(const void* pKey1, int32_t kLen1, const void* pKey2, int32_t kLen2) {
   return strcmp(pKey1, pKey2);
 }

source/dnode/vnode/src/tq/tqPush.c

@@ -14,3 +14,183 @@
  */
 
 #include "tq.h"
+
+int32_t tqExecFromInputQ(STQ* pTq, STqHandle* pHandle) {
+  // 1. guard and set status executing
+  // 2. check processedVer
+  // 2.1. if not missed, get msg from queue
+  // 2.2. if missed, scan wal
+  //
+  // 3. exec, after each success, update processed ver
+  // first run
+  // set exec status closing
+  // second run
+  // set exec status idle
+  //
+  // 4. if get result
+  // 4.1 set exec input status blocked and exec status idle
+  // 4.2 rpc send
+  // 4.3 clear rpc info
+  return 0;
+}
+
+int32_t tqOpenPushHandle(STQ* pTq, STqHandle* pHandle) {
+  memset(&pHandle->pushHandle, 0, sizeof(STqPushHandle));
+  pHandle->pushHandle.inputQ.queue = taosOpenQueue();
+  pHandle->pushHandle.inputQ.qall = taosAllocateQall();
+  if (pHandle->pushHandle.inputQ.queue == NULL || pHandle->pushHandle.inputQ.qall == NULL) {
+    if (pHandle->pushHandle.inputQ.queue) {
+      taosCloseQueue(pHandle->pushHandle.inputQ.queue);
+    }
+    if (pHandle->pushHandle.inputQ.qall) {
+      taosFreeQall(pHandle->pushHandle.inputQ.qall);
+    }
+    return -1;
+  }
+  return 0;
+}
+
+void tqPreparePush(STQ* pTq, STqHandle* pHandle, int64_t reqId, const SRpcHandleInfo* pInfo, int64_t processedVer) {
+  memcpy(&pHandle->pushHandle.rpcInfo, pInfo, sizeof(SRpcHandleInfo));
+  atomic_store_64(&pHandle->pushHandle.reqId, reqId);
+  atomic_store_64(&pHandle->pushHandle.processedVer, processedVer);
+  atomic_store_8(&pHandle->pushHandle.inputStatus, TASK_INPUT_STATUS__NORMAL);
+  // set timeout timer
+}
+
+int32_t tqEnqueue(STqHandle* pHandle, SStreamDataSubmit* pSubmit) {
+  int8_t inputStatus = atomic_load_8(&pHandle->pushHandle.inputStatus);
+  if (inputStatus == TASK_INPUT_STATUS__NORMAL) {
+    SStreamDataSubmit* pSubmitClone = streamSubmitRefClone(pSubmit);
+    if (pSubmitClone == NULL) {
+      return -1;
+    }
+    taosWriteQitem(pHandle->pushHandle.inputQ.queue, pSubmitClone);
+    return 0;
+  }
+  return -1;
+}
+
+int32_t tqSendExecReq(STQ* pTq, STqHandle* pHandle) {
+  //
+  return 0;
+}
+
+int32_t tqEnqueueAll(STQ* pTq, SSubmitReq* pReq) {
+  void*              pIter = NULL;
+  SStreamDataSubmit* pSubmit = streamDataSubmitNew(pReq);
+  if (pSubmit == NULL) {
+    return -1;
+  }
+
+  while (1) {
+    pIter = taosHashIterate(pTq->handles, pIter);
+    if (pIter == NULL) break;
+    STqHandle* pHandle = (STqHandle*)pIter;
+    if (tqEnqueue(pHandle, pSubmit) < 0) {
+      continue;
+    }
+    int8_t execStatus = atomic_load_8(&pHandle->pushHandle.execStatus);
+    if (execStatus == TASK_STATUS__IDLE || execStatus == TASK_STATUS__CLOSING) {
+      tqSendExecReq(pTq, pHandle);
+    }
+  }
+
+  streamDataSubmitRefDec(pSubmit);
+
+  return 0;
+}
+
+int32_t tqPushMsgNew(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver, SRpcHandleInfo handleInfo) {
+  if (msgType != TDMT_VND_SUBMIT) return 0;
+  void*       pIter = NULL;
+  STqHandle*  pHandle = NULL;
+  SSubmitReq* pReq = (SSubmitReq*)msg;
+  int32_t     workerId = 4;
+  int64_t     fetchOffset = ver;
+
+  while (1) {
+    pIter = taosHashIterate(pTq->pushMgr, pIter);
+    if (pIter == NULL) break;
+    pHandle = *(STqHandle**)pIter;
+
+    taosWLockLatch(&pHandle->pushHandle.lock);
+
+    SMqDataBlkRsp rsp = {0};
+    rsp.reqOffset = pHandle->pushHandle.reqOffset;
+    rsp.blockData = taosArrayInit(0, sizeof(void*));
+    rsp.blockDataLen = taosArrayInit(0, sizeof(int32_t));
+
+    if (msgType == TDMT_VND_SUBMIT) {
+      tqDataExec(pTq, &pHandle->execHandle, pReq, &rsp, workerId);
+    } else {
+      // TODO
+      ASSERT(0);
+    }
+
+    if (rsp.blockNum == 0) {
+      taosWUnLockLatch(&pHandle->pushHandle.lock);
+      continue;
+    }
+
+    ASSERT(taosArrayGetSize(rsp.blockData) == rsp.blockNum);
+    ASSERT(taosArrayGetSize(rsp.blockDataLen) == rsp.blockNum);
+
+    rsp.rspOffset = fetchOffset;
+
+    int32_t tlen = sizeof(SMqRspHead) + tEncodeSMqDataBlkRsp(NULL, &rsp);
+    void*   buf = rpcMallocCont(tlen);
+    if (buf == NULL) {
+      // todo free
+      return -1;
+    }
+
+    ((SMqRspHead*)buf)->mqMsgType = TMQ_MSG_TYPE__POLL_RSP;
+    ((SMqRspHead*)buf)->epoch = pHandle->pushHandle.epoch;
+    ((SMqRspHead*)buf)->consumerId = pHandle->pushHandle.consumerId;
+
+    void* abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead));
+    tEncodeSMqDataBlkRsp(&abuf, &rsp);
+
+    SRpcMsg resp = {
+        .info = pHandle->pushHandle.rpcInfo,
+        .pCont = buf,
+        .contLen = tlen,
+        .code = 0,
+    };
+    tmsgSendRsp(&resp);
+
+    memset(&pHandle->pushHandle.rpcInfo, 0, sizeof(SRpcHandleInfo));
+    taosWUnLockLatch(&pHandle->pushHandle.lock);
+
+    tqDebug("vg %d offset %ld from consumer %ld (epoch %d) send rsp, block num: %d, reqOffset: %ld, rspOffset: %ld",
+            TD_VID(pTq->pVnode), fetchOffset, pHandle->pushHandle.consumerId, pHandle->pushHandle.epoch, rsp.blockNum,
+            rsp.reqOffset, rsp.rspOffset);
+
+    // TODO destroy
+    taosArrayDestroy(rsp.blockData);
+    taosArrayDestroy(rsp.blockDataLen);
+  }
+
+  return 0;
+}
+
+int tqPushMsg(STQ* pTq, void* msg, int32_t msgLen, tmsg_t msgType, int64_t ver) {
+  if (msgType == TDMT_VND_SUBMIT) {
+    if (taosHashGetSize(pTq->pStreamTasks) == 0) return 0;
+
+    if (tdUpdateExpireWindow(pTq->pVnode->pSma, msg, ver) != 0) {
+      // TODO handle sma error
+    }
+    void* data = taosMemoryMalloc(msgLen);
+    if (data == NULL) {
+      return -1;
+    }
+    memcpy(data, msg, msgLen);
+
+    tqProcessStreamTrigger(pTq, data);
+  }
+
+  return 0;
+}
+

source/dnode/vnode/src/tq/tqRead.c

@@ -298,3 +298,38 @@ int tqReadHandleRemoveTbUidList(STqReadHandle* pHandle, const SArray* tbUidList)
 
   return 0;
 }
+
+int32_t tqUpdateTbUidList(STQ* pTq, const SArray* tbUidList, bool isAdd) {
+  void* pIter = NULL;
+  while (1) {
+    pIter = taosHashIterate(pTq->handles, pIter);
+    if (pIter == NULL) break;
+    STqHandle* pExec = (STqHandle*)pIter;
+    if (pExec->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
+      for (int32_t i = 0; i < 5; i++) {
+        int32_t code = qUpdateQualifiedTableId(pExec->execHandle.exec.execCol.task[i], tbUidList, isAdd);
+        ASSERT(code == 0);
+      }
+    } else if (pExec->execHandle.subType == TOPIC_SUB_TYPE__DB) {
+      if (!isAdd) {
+        int32_t sz = taosArrayGetSize(tbUidList);
+        for (int32_t i = 0; i < sz; i++) {
+          int64_t tbUid = *(int64_t*)taosArrayGet(tbUidList, i);
+          taosHashPut(pExec->execHandle.exec.execDb.pFilterOutTbUid, &tbUid, sizeof(int64_t), NULL, 0);
+        }
+      }
+    } else {
+      // tq update id
+    }
+  }
+  while (1) {
+    pIter = taosHashIterate(pTq->pStreamTasks, pIter);
+    if (pIter == NULL) break;
+    SStreamTask* pTask = (SStreamTask*)pIter;
+    if (pTask->inputType == STREAM_INPUT__DATA_SUBMIT) {
+      int32_t code = qUpdateQualifiedTableId(pTask->exec.executor, tbUidList, isAdd);
+      ASSERT(code == 0);
+    }
+  }
+  return 0;
+}

source/dnode/vnode/src/tq/tqSink.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tq.h"
+
+void tqTableSink(SStreamTask* pTask, void* vnode, int64_t ver, void* data) {
+  const SArray* pRes = (const SArray*)data;
+  SVnode*       pVnode = (SVnode*)vnode;
+
+  ASSERT(pTask->tbSink.pTSchema);
+  SSubmitReq* pReq = tdBlockToSubmit(pRes, pTask->tbSink.pTSchema, true, pTask->tbSink.stbUid,
+                                     pTask->tbSink.stbFullName, pVnode->config.vgId);
+  /*tPrintFixedSchemaSubmitReq(pReq, pTask->tbSink.pTSchema);*/
+  // build write msg
+  SRpcMsg msg = {
+      .msgType = TDMT_VND_SUBMIT,
+      .pCont = pReq,
+      .contLen = ntohl(pReq->length),
+  };
+
+  ASSERT(tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg) == 0);
+}

source/dnode/vnode/src/tsdb/tsdbCommit.c

@@ -238,7 +238,7 @@ static void tsdbStartCommit(STsdb *pRepo) {
 
 static void tsdbEndCommit(STsdb *pTsdb, int eno) {
   tsdbEndFSTxn(pTsdb);
-  tsdbMemTableDestroy(pTsdb, pTsdb->imem);
+  tsdbMemTableDestroy(pTsdb->imem);
   pTsdb->imem = NULL;
   tsdbInfo("vgId:%d commit over, %s", REPO_ID(pTsdb), (eno == TSDB_CODE_SUCCESS) ? "succeed" : "failed");
 }

source/dnode/vnode/src/tsdb/tsdbDelete.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
\ No newline at end of file

source/dnode/vnode/src/tsdb/tsdbMemTable.c

@@ -60,7 +60,7 @@ int tsdbMemTableCreate(STsdb *pTsdb, STsdbMemTable **ppMemTable) {
   return 0;
 }
 
-void tsdbMemTableDestroy(STsdb *pTsdb, STsdbMemTable *pMemTable) {
+void tsdbMemTableDestroy(STsdbMemTable *pMemTable) {
   if (pMemTable) {
     taosHashCleanup(pMemTable->pHashIdx);
     SSkipListIterator *pIter = tSkipListCreateIter(pMemTable->pSlIdx);
@@ -142,69 +142,6 @@ int tsdbLoadDataFromCache(STsdb *pTsdb, STable *pTable, SSkipListIterator *pIter
       } else {
         fKey = tdGetKey(filterKeys[filterIter]);
       }
-#if 0
-    } else if (fKey > rowKey) {
-      if (isRowDel) {
-        pMergeInfo->rowsDeleteFailed++;
-      } else {
-        if (pMergeInfo->rowsInserted - pMergeInfo->rowsDeleteSucceed >= maxRowsToRead) break;
-        if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-
-        pMergeInfo->rowsInserted++;
-        pMergeInfo->nOperations++;
-        pMergeInfo->keyFirst = TMIN(pMergeInfo->keyFirst, rowKey);
-        pMergeInfo->keyLast = TMAX(pMergeInfo->keyLast, rowKey);
-        tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-      }
-
-      tSkipListIterNext(pIter);
-      row = tsdbNextIterRow(pIter);
-      if (row == NULL || TD_ROW_KEY(row) > maxKey) {
-        rowKey = INT64_MAX;
-        isRowDel = false;
-      } else {
-        rowKey = TD_ROW_KEY(row);
-        isRowDel = TD_ROW_IS_DELETED(row);
-      }
-    } else {
-      if (isRowDel) {
-        ASSERT(!keepDup);
-        if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-        pMergeInfo->rowsDeleteSucceed++;
-        pMergeInfo->nOperations++;
-        tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-      } else {
-        if (keepDup) {
-          if (pCols && pMergeInfo->nOperations >= pCols->maxPoints) break;
-          pMergeInfo->rowsUpdated++;
-          pMergeInfo->nOperations++;
-          pMergeInfo->keyFirst = TMIN(pMergeInfo->keyFirst, rowKey);
-          pMergeInfo->keyLast = TMAX(pMergeInfo->keyLast, rowKey);
-          tsdbAppendTableRowToCols(pTable, pCols, &pSchema, row);
-        } else {
-          pMergeInfo->keyFirst = TMIN(pMergeInfo->keyFirst, fKey);
-          pMergeInfo->keyLast = TMAX(pMergeInfo->keyLast, fKey);
-        }
-      }
-
-      tSkipListIterNext(pIter);
-      row = tsdbNextIterRow(pIter);
-      if (row == NULL || TD_ROW_KEY(row) > maxKey) {
-        rowKey = INT64_MAX;
-        isRowDel = false;
-      } else {
-        rowKey = TD_ROW_KEY(row);
-        isRowDel = TD_ROW_IS_DELETED(row);
-      }
-
-      filterIter++;
-      if (filterIter >= nFilterKeys) {
-        fKey = INT64_MAX;
-      } else {
-        fKey = tdGetKey(filterKeys[filterIter]);
-      }
-    }
-#endif
 #if 1
     } else if (fKey > rowKey) {
       if (isRowDel) {
@@ -321,7 +258,7 @@ int tsdbInsertTableData(STsdb *pTsdb, SSubmitMsgIter *pMsgIter, SSubmitBlk *pBlo
     terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST;
     return -1;
   }
-  if(pRsp->tblFName) strcat(pRsp->tblFName, mr.me.name);
+  if (pRsp->tblFName) strcat(pRsp->tblFName, mr.me.name);
 
   if (mr.me.type == TSDB_NORMAL_TABLE) {
     sverNew = mr.me.ntbEntry.schemaRow.version;

source/dnode/vnode/src/tsdb/tsdbMemTable2.c

@@ -15,52 +15,308 @@
 
 #include "tsdb.h"
 
-typedef struct SMemTable          SMemTable;
-typedef struct SMemData           SMemData;
-typedef struct SMemSkipList       SMemSkipList;
-typedef struct SMemSkipListNode   SMemSkipListNode;
-typedef struct SMemSkipListCurosr SMemSkipListCurosr;
-
-#define SL_MAX_LEVEL 5
-
-struct SMemTable {
-  STsdb              *pTsdb;
-  TSKEY               minKey;
-  TSKEY               maxKey;
-  int64_t             minVer;
-  int64_t             maxVer;
-  int64_t             nRows;
-  int32_t             nHash;
-  int32_t             nBucket;
-  SMemData          **pBuckets;
-  SMemSkipListCurosr *pSlc;
-};
+typedef struct SMemData         SMemData;
+typedef struct SMemSkipList     SMemSkipList;
+typedef struct SMemSkipListNode SMemSkipListNode;
 
 struct SMemSkipListNode {
   int8_t            level;
-  SMemSkipListNode *forwards[1];  // Windows does not allow 0
+  SMemSkipListNode *forwards[0];
 };
 
 struct SMemSkipList {
-  uint32_t         seed;
-  int8_t           maxLevel;
-  int8_t           level;
-  int32_t          size;
-  SMemSkipListNode pHead[1];  // Windows does not allow 0
+  uint32_t          seed;
+  int32_t           size;
+  int8_t            maxLevel;
+  int8_t            level;
+  SMemSkipListNode *pHead;
+  SMemSkipListNode *pTail;
 };
 
 struct SMemData {
-  SMemData    *pHashNext;
   tb_uid_t     suid;
   tb_uid_t     uid;
-  TSKEY        minKey;
-  TSKEY        maxKey;
-  int64_t      minVer;
-  int64_t      maxVer;
-  int64_t      nRows;
+  TSDBKEY      minKey;
+  TSDBKEY      maxKey;
+  SDelOp      *delOpHead;
+  SDelOp      *delOpTail;
   SMemSkipList sl;
 };
 
+struct SMemTable {
+  STsdb  *pTsdb;
+  int32_t nRef;
+  TSDBKEY minKey;
+  TSDBKEY maxKey;
+  int64_t nRows;
+  SArray *pArray;  // SArray<SMemData>
+};
+
+#define SL_NODE_SIZE(l)        (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l)*2)
+#define SL_NODE_HALF_SIZE(l)   (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l))
+#define SL_NODE_FORWARD(n, l)  ((n)->forwards[l])
+#define SL_NODE_BACKWARD(n, l) ((n)->forwards[(n)->level + (l)])
+#define SL_NODE_DATA(n)        (&SL_NODE_BACKWARD(n, (n)->level))
+
+#define SL_HEAD_FORWARD(sl, l)  SL_NODE_FORWARD((sl)->pHead, l)
+#define SL_TAIL_BACKWARD(sl, l) SL_NODE_FORWARD((sl)->pTail, l)
+
+static int32_t tsdbGetOrCreateMemData(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid, SMemData **ppMemData);
+static int     memDataPCmprFn(const void *p1, const void *p2);
+static int32_t tPutTSDBRow(uint8_t *p, TSDBROW *pRow);
+static int32_t tGetTSDBRow(uint8_t *p, TSDBROW *pRow);
+static int8_t  tsdbMemSkipListRandLevel(SMemSkipList *pSl);
+
+// SMemTable ==============================================
+int32_t tsdbMemTableCreate2(STsdb *pTsdb, SMemTable **ppMemTable) {
+  int32_t    code = 0;
+  SMemTable *pMemTable = NULL;
+
+  pMemTable = (SMemTable *)taosMemoryCalloc(1, sizeof(*pMemTable));
+  if (pMemTable == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+  pMemTable->pTsdb = pTsdb;
+  pMemTable->nRef = 1;
+  pMemTable->minKey = (TSDBKEY){.version = INT64_MAX, .ts = TSKEY_MAX};
+  pMemTable->maxKey = (TSDBKEY){.version = -1, .ts = TSKEY_MIN};
+  pMemTable->nRows = 0;
+  pMemTable->pArray = taosArrayInit(512, sizeof(SMemData *));
+  if (pMemTable->pArray == NULL) {
+    taosMemoryFree(pMemTable);
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+
+  *ppMemTable = pMemTable;
+  return code;
+
+_err:
+  *ppMemTable = NULL;
+  return code;
+}
+
+void tsdbMemTableDestroy2(SMemTable *pMemTable) {
+  taosArrayDestroyEx(pMemTable->pArray, NULL /*TODO*/);
+  taosMemoryFree(pMemTable);
+}
+
+int32_t tsdbInsertTableData2(STsdb *pTsdb, int64_t version, SVSubmitBlk *pSubmitBlk) {
+  int32_t    code = 0;
+  SMemTable *pMemTable = (SMemTable *)pTsdb->mem;  // TODO
+  SMemData  *pMemData;
+  TSDBROW    row = {.version = version};
+
+  ASSERT(pMemTable);
+
+  {
+    // check if table exists (todo)
+  }
+
+  code = tsdbGetOrCreateMemData(pMemTable, pSubmitBlk->suid, pSubmitBlk->uid, &pMemData);
+  if (code) {
+    tsdbError("vgId:%d failed to create/get table data since %s", TD_VID(pTsdb->pVnode), tstrerror(code));
+    goto _err;
+  }
+
+  // do insert
+  int32_t           nt;
+  uint8_t          *pt;
+  int32_t           n = 0;
+  uint8_t          *p = pSubmitBlk->pData;
+  SVBufPool        *pPool = pTsdb->pVnode->inUse;
+  int8_t            level;
+  SMemSkipListNode *pNode;
+  while (n < pSubmitBlk->nData) {
+    nt = tGetTSRow(p + n, &row.tsRow);
+    n += nt;
+
+    ASSERT(n <= pSubmitBlk->nData);
+
+    // build the node
+    level = tsdbMemSkipListRandLevel(&pMemData->sl);
+    pNode = (SMemSkipListNode *)vnodeBufPoolMalloc(pPool, SL_NODE_SIZE(level) + nt + sizeof(version));
+    if (pNode == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _err;
+    }
+    pNode->level = level;
+    tPutTSDBRow((uint8_t *)SL_NODE_DATA(pNode), &row);
+
+    // put the node (todo)
+
+    // set info
+    if (tsdbKeyCmprFn(&row, &pMemData->minKey) < 0) pMemData->minKey = *(TSDBKEY *)&row;
+    if (tsdbKeyCmprFn(&row, &pMemData->maxKey) > 0) pMemData->maxKey = *(TSDBKEY *)&row;
+  }
+
+  if (tsdbKeyCmprFn(&pMemTable->minKey, &pMemData->minKey) < 0) pMemTable->minKey = pMemData->minKey;
+  if (tsdbKeyCmprFn(&pMemTable->maxKey, &pMemData->maxKey) > 0) pMemTable->maxKey = pMemData->maxKey;
+
+  return code;
+
+_err:
+  return code;
+}
+
+int32_t tsdbDeleteTableData2(STsdb *pTsdb, int64_t version, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKEY eKey) {
+  int32_t    code = 0;
+  SMemTable *pMemTable = (SMemTable *)pTsdb->mem;  // TODO
+  SMemData  *pMemData;
+  SVBufPool *pPool = pTsdb->pVnode->inUse;
+
+  ASSERT(pMemTable);
+
+  {
+    // check if table exists (todo)
+  }
+
+  code = tsdbGetOrCreateMemData(pMemTable, suid, uid, &pMemData);
+  if (code) {
+    goto _err;
+  }
+
+  // do delete
+  SDelOp *pDelOp = (SDelOp *)vnodeBufPoolMalloc(pPool, sizeof(*pDelOp));
+  if (pDelOp == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+  pDelOp->version = version;
+  pDelOp->sKey = sKey;
+  pDelOp->eKey = eKey;
+  pDelOp->pNext = NULL;
+  if (pMemData->delOpHead == NULL) {
+    ASSERT(pMemData->delOpTail == NULL);
+    pMemData->delOpHead = pMemData->delOpTail = pDelOp;
+  } else {
+    pMemData->delOpTail->pNext = pDelOp;
+    pMemData->delOpTail = pDelOp;
+  }
+
+  {
+    // update the state of pMemTable, pMemData, last and lastrow (todo)
+  }
+
+  tsdbDebug("vgId:%d delete data from table suid:%" PRId64 " uid:%" PRId64 " sKey:%" PRId64 " eKey:%" PRId64
+            " since %s",
+            TD_VID(pTsdb->pVnode), suid, uid, sKey, eKey, tstrerror(code));
+  return code;
+
+_err:
+  tsdbError("vgId:%d failed to delete data from table suid:%" PRId64 " uid:%" PRId64 " sKey:%" PRId64 " eKey:%" PRId64
+            " since %s",
+            TD_VID(pTsdb->pVnode), suid, uid, sKey, eKey, tstrerror(code));
+  return code;
+}
+
+static int32_t tsdbGetOrCreateMemData(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid, SMemData **ppMemData) {
+  int32_t    code = 0;
+  int32_t    idx = 0;
+  SMemData  *pMemDataT = &(SMemData){.suid = suid, .uid = uid};
+  SMemData  *pMemData = NULL;
+  SVBufPool *pPool = pMemTable->pTsdb->pVnode->inUse;
+  int8_t     maxLevel = pMemTable->pTsdb->pVnode->config.tsdbCfg.slLevel;
+
+  // get
+  idx = taosArraySearchIdx(pMemTable->pArray, &pMemDataT, memDataPCmprFn, TD_GE);
+  if (idx >= 0) {
+    pMemData = (SMemData *)taosArrayGet(pMemTable->pArray, idx);
+    if (memDataPCmprFn(&pMemDataT, &pMemData) == 0) goto _exit;
+  }
+
+  // create
+  pMemData = vnodeBufPoolMalloc(pPool, sizeof(*pMemData) + SL_NODE_HALF_SIZE(maxLevel) * 2);
+  if (pMemData == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+  pMemData->suid = suid;
+  pMemData->uid = uid;
+  pMemData->minKey = (TSDBKEY){.version = INT64_MAX, .ts = TSKEY_MAX};
+  pMemData->maxKey = (TSDBKEY){.version = -1, .ts = TSKEY_MIN};
+  pMemData->delOpHead = pMemData->delOpTail = NULL;
+  pMemData->sl.seed = taosRand();
+  pMemData->sl.size = 0;
+  pMemData->sl.maxLevel = maxLevel;
+  pMemData->sl.level = 0;
+  pMemData->sl.pHead = (SMemSkipListNode *)&pMemData[1];
+  pMemData->sl.pTail = (SMemSkipListNode *)POINTER_SHIFT(pMemData->sl.pHead, SL_NODE_HALF_SIZE(maxLevel));
+
+  for (int8_t iLevel = 0; iLevel < pMemData->sl.maxLevel; iLevel++) {
+    SL_HEAD_FORWARD(&pMemData->sl, iLevel) = pMemData->sl.pTail;
+    SL_TAIL_BACKWARD(&pMemData->sl, iLevel) = pMemData->sl.pHead;
+  }
+
+  if (idx < 0) idx = 0;
+  if (taosArrayInsert(pMemTable->pArray, idx, &pMemData) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err;
+  }
+
+_exit:
+  *ppMemData = pMemData;
+  return code;
+
+_err:
+  *ppMemData = NULL;
+  return code;
+}
+
+static int memDataPCmprFn(const void *p1, const void *p2) {
+  SMemData *pMemData1 = *(SMemData **)p1;
+  SMemData *pMemData2 = *(SMemData **)p2;
+
+  if (pMemData1->suid < pMemData2->suid) {
+    return -1;
+  } else if (pMemData1->suid > pMemData2->suid) {
+    return 1;
+  }
+
+  if (pMemData1->uid < pMemData2->uid) {
+    return -1;
+  } else if (pMemData1->uid > pMemData2->uid) {
+    return 1;
+  }
+
+  return 0;
+}
+
+static int32_t tPutTSDBRow(uint8_t *p, TSDBROW *pRow) {
+  int32_t n = 0;
+
+  n += tPutI64(p ? p + n : p, pRow->version);
+  n += tPutTSRow(p ? p + n : p, &pRow->tsRow);
+
+  return n;
+}
+
+static int32_t tGetTSDBRow(uint8_t *p, TSDBROW *pRow) {
+  int32_t n = 0;
+
+  n += tGetI64(p + n, &pRow->version);
+  n += tGetTSRow(p + n, &pRow->tsRow);
+
+  return n;
+}
+
+static FORCE_INLINE int8_t tsdbMemSkipListRandLevel(SMemSkipList *pSl) {
+  int8_t         level = 1;
+  int8_t         tlevel = TMIN(pSl->maxLevel, pSl->level + 1);
+  const uint32_t factor = 4;
+
+  while ((taosRandR(&pSl->seed) % factor) == 0 && level < tlevel) {
+    level++;
+  }
+
+  return level;
+}
+
+#if 0  //====================================================================================
+
+#define SL_MAX_LEVEL 5
+
 struct SMemSkipListCurosr {
   SMemSkipList     *pSl;
   SMemSkipListNode *pNodes[SL_MAX_LEVEL];
@@ -74,12 +330,6 @@ typedef struct {
 
 #define HASH_BUCKET(SUID, UID, NBUCKET) (TABS((SUID) + (UID)) % (NBUCKET))
 
-#define SL_NODE_SIZE(l)        (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l)*2)
-#define SL_NODE_HALF_SIZE(l)   (sizeof(SMemSkipListNode) + sizeof(SMemSkipListNode *) * (l))
-#define SL_NODE_FORWARD(n, l)  ((n)->forwards[l])
-#define SL_NODE_BACKWARD(n, l) ((n)->forwards[(n)->level + (l)])
-#define SL_NODE_DATA(n)        (&SL_NODE_BACKWARD(n, (n)->level))
-
 #define SL_HEAD_NODE(sl)            ((sl)->pHead)
 #define SL_TAIL_NODE(sl)            ((SMemSkipListNode *)&SL_NODE_FORWARD(SL_HEAD_NODE(sl), (sl)->maxLevel))
 #define SL_HEAD_NODE_FORWARD(n, l)  SL_NODE_FORWARD(n, l)
@@ -99,50 +349,7 @@ static int32_t tsdbMemSkipListCursorMoveToNext(SMemSkipListCurosr *pSlc);
 static int32_t tsdbMemSkipListCursorMoveToPrev(SMemSkipListCurosr *pSlc);
 static SMemSkipListNode *tsdbMemSkipListNodeCreate(SVBufPool *pPool, SMemSkipList *pSl, const STsdbRow *pTRow);
 
-// SMemTable
-int32_t tsdbMemTableCreate2(STsdb *pTsdb, SMemTable **ppMemTb) {
-  SMemTable *pMemTb = NULL;
-
-  pMemTb = taosMemoryCalloc(1, sizeof(*pMemTb));
-  if (pMemTb == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  pMemTb->pTsdb = pTsdb;
-  pMemTb->minKey = TSKEY_MAX;
-  pMemTb->maxKey = TSKEY_MIN;
-  pMemTb->minVer = -1;
-  pMemTb->maxVer = -1;
-  pMemTb->nRows = 0;
-  pMemTb->nHash = 0;
-  pMemTb->nBucket = 1024;
-  pMemTb->pBuckets = taosMemoryCalloc(pMemTb->nBucket, sizeof(*pMemTb->pBuckets));
-  if (pMemTb->pBuckets == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    taosMemoryFree(pMemTb);
-    return -1;
-  }
-  if (tsdbMemSkipListCursorCreate(pTsdb->pVnode->config.tsdbCfg.slLevel, &pMemTb->pSlc) < 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    taosMemoryFree(pMemTb->pBuckets);
-    taosMemoryFree(pMemTb);
-  }
-
-  *ppMemTb = pMemTb;
-  return 0;
-}
-
-int32_t tsdbMemTableDestroy2(STsdb *pTsdb, SMemTable *pMemTb) {
-  if (pMemTb) {
-    // loop to destroy the contents (todo)
-    tsdbMemSkipListCursorDestroy(pMemTb->pSlc);
-    taosMemoryFree(pMemTb->pBuckets);
-    taosMemoryFree(pMemTb);
-  }
-  return 0;
-}
-
+// SMemTable ========================
 int32_t tsdbInsertData2(SMemTable *pMemTb, int64_t version, const SVSubmitBlk *pSubmitBlk) {
   SMemData  *pMemData;
   STsdb     *pTsdb = pMemTb->pTsdb;
@@ -253,18 +460,6 @@ int32_t tsdbInsertData2(SMemTable *pMemTb, int64_t version, const SVSubmitBlk *p
   return 0;
 }
 
-static FORCE_INLINE int8_t tsdbMemSkipListRandLevel(SMemSkipList *pSl) {
-  int8_t         level = 1;
-  int8_t         tlevel = TMIN(pSl->maxLevel, pSl->level + 1);
-  const uint32_t factor = 4;
-
-  while ((taosRandR(&pSl->seed) % factor) == 0 && level < tlevel) {
-    level++;
-  }
-
-  return level;
-}
-
 static FORCE_INLINE int32_t tsdbEncodeRow(SEncoder *pEncoder, const STsdbRow *pRow) {
   if (tEncodeI64(pEncoder, pRow->version) < 0) return -1;
   if (tEncodeBinary(pEncoder, (const uint8_t *)pRow->pRow, pRow->szRow) < 0) return -1;
@@ -377,4 +572,5 @@ static SMemSkipListNode *tsdbMemSkipListNodeCreate(SVBufPool *pPool, SMemSkipLis
   }
 
   return pNode;
-}
\ No newline at end of file
+}
+#endif
\ No newline at end of file

source/dnode/vnode/src/tsdb/tsdbSma.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "tsdbSma.h"
-#include "tsdb.h"
-
-static const char *TSDB_SMA_DNAME[] = {
-    "",      // TSDB_SMA_TYPE_BLOCK
-    "tsma",  // TSDB_SMA_TYPE_TIME_RANGE
-    "rsma",  // TSDB_SMA_TYPE_ROLLUP
-};
-
-#undef _TEST_SMA_PRINT_DEBUG_LOG_
-#define SMA_STORAGE_TSDB_DAYS   30
-#define SMA_STORAGE_TSDB_TIMES  10
-#define SMA_STORAGE_SPLIT_HOURS 24
-#define SMA_KEY_LEN             16  // TSKEY+groupId 8+8
-#define SMA_DROP_EXPIRED_TIME   10  // default is 10 seconds
-
-#define SMA_STATE_HASH_SLOT      4
-#define SMA_STATE_ITEM_HASH_SLOT 32
-
-#define SMA_TEST_INDEX_NAME "smaTestIndexName"  // TODO: just for test
-#define SMA_TEST_INDEX_UID  2000000001          // TODO: just for test
-
-typedef struct SRSmaInfo SRSmaInfo;
-typedef enum {
-  SMA_STORAGE_LEVEL_TSDB = 0,     // use days of self-defined  e.g. vnode${N}/tsdb/tsma/sma_index_uid/v2f200.tsma
-  SMA_STORAGE_LEVEL_DFILESET = 1  // use days of TS data       e.g. vnode${N}/tsdb/tsma/sma_index_uid/v2f1906.tsma
-} ESmaStorageLevel;
-
-typedef struct SPoolMem {
-  int64_t          size;
-  struct SPoolMem *prev;
-  struct SPoolMem *next;
-} SPoolMem;
-
-struct SSmaEnv {
-  TdThreadRwlock lock;
-  int8_t         type;
-  TXN            txn;
-  SPoolMem      *pPool;
-  SDiskID        did;
-  TDB           *dbEnv;  // TODO: If it's better to put it in smaIndex level?
-  char          *path;   // relative path
-  SSmaStat      *pStat;
-};
-
-#define SMA_ENV_LOCK(env)       ((env)->lock)
-#define SMA_ENV_TYPE(env)       ((env)->type)
-#define SMA_ENV_DID(env)        ((env)->did)
-#define SMA_ENV_ENV(env)        ((env)->dbEnv)
-#define SMA_ENV_PATH(env)       ((env)->path)
-#define SMA_ENV_STAT(env)       ((env)->pStat)
-#define SMA_ENV_STAT_ITEMS(env) ((env)->pStat->smaStatItems)
-
-typedef struct {
-  STsdb        *pTsdb;
-  SDBFile       dFile;
-  const SArray *pDataBlocks;  // sma data
-  int32_t       interval;     // interval with the precision of DB
-} STSmaWriteH;
-
-typedef struct {
-  int32_t iter;
-  int32_t fid;
-} SmaFsIter;
-
-typedef struct {
-  STsdb    *pTsdb;
-  SDBFile   dFile;
-  int32_t   interval;   // interval with the precision of DB
-  int32_t   blockSize;  // size of SMA block item
-  int8_t    storageLevel;
-  int8_t    days;
-  SmaFsIter smaFsIter;
-} STSmaReadH;
-
-typedef struct {
-  /**
-   * @brief The field 'state' is here to demonstrate if one smaIndex is ready to provide service.
-   *    - TSDB_SMA_STAT_OK: 1) The sma calculation of history data is finished; 2) Or recevied information from
-   * Streaming Module or TSDB local persistence.
-   *    - TSDB_SMA_STAT_EXPIRED: 1) If sma calculation of history TS data is not finished; 2) Or if the TSDB is open,
-   * without information about its previous state.
-   *    - TSDB_SMA_STAT_DROPPED: 1)sma dropped
-   * N.B. only applicable to tsma
-   */
-  int8_t    state;           // ETsdbSmaStat
-  SHashObj *expiredWindows;  // key: skey of time window, value: N/A
-  STSma    *pSma;            // cache schema
-} SSmaStatItem;
-
-#define RSMA_TASK_INFO_HASH_SLOT 8
-struct SRSmaInfo {
-  void *taskInfo[TSDB_RETENTION_L2];  // qTaskInfo_t
-};
-
-struct SSmaStat {
-  union {
-    SHashObj *smaStatItems;  // key: indexUid, value: SSmaStatItem for tsma
-    SHashObj *rsmaInfoHash;  // key: stbUid, value: SRSmaInfo;
-  };
-  T_REF_DECLARE()
-};
-#define SMA_STAT_ITEMS(s)     ((s)->smaStatItems)
-#define SMA_STAT_INFO_HASH(s) ((s)->rsmaInfoHash)
-
-static FORCE_INLINE void tsdbFreeTaskHandle(qTaskInfo_t *taskHandle) {
-  // Note: free/kill may in RC
-  qTaskInfo_t otaskHandle = atomic_load_ptr(taskHandle);
-  if (otaskHandle && atomic_val_compare_exchange_ptr(taskHandle, otaskHandle, NULL)) {
-    qDestroyTask(otaskHandle);
-  }
-}
-
-static FORCE_INLINE void *tsdbFreeRSmaInfo(SRSmaInfo *pInfo) {
-  for (int32_t i = 0; i < TSDB_RETENTION_MAX; ++i) {
-    if (pInfo->taskInfo[i]) {
-      tsdbFreeTaskHandle(pInfo->taskInfo[i]);
-    }
-  }
-  return NULL;
-}
-
-// declaration of static functions
-
-// expired window
-static int32_t  tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version);
-static int32_t  tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey,
-                                     int64_t version);
-static int32_t  tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType);
-static void    *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem);
-static int32_t  tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType);
-static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did);
-static int32_t  tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did, SSmaEnv **pEnv);
-static int32_t  tsdbResetExpiredWindow(STsdb *pTsdb, SSmaStat *pStat, int64_t indexUid, TSKEY skey);
-static int32_t  tsdbRefSmaStat(STsdb *pTsdb, SSmaStat *pStat);
-static int32_t  tsdbUnRefSmaStat(STsdb *pTsdb, SSmaStat *pStat);
-
-// read data
-// TODO: This is the basic params, and should wrap the params to a queryHandle.
-static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult);
-
-// insert data
-static int32_t tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, const SArray *pDataBlocks, int64_t interval,
-                                  int8_t intervalUnit);
-static void    tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH);
-static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, int64_t interval, int8_t intervalUnit);
-static int32_t tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit);
-static int32_t tsdbSetRSmaDataFile(STSmaWriteH *pSmaH, int32_t fid);
-static int32_t tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, int32_t keyLen, void *pData, int32_t dataLen,
-                                    TXN *txn);
-static int64_t tsdbGetIntervalByPrecision(int64_t interval, uint8_t intervalUnit, int8_t precision, bool adjusted);
-static int32_t tsdbGetTSmaDays(STsdb *pTsdb, int64_t interval, int32_t storageLevel);
-static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, int64_t indexUid, int32_t fid);
-static int32_t tsdbInitTSmaFile(STSmaReadH *pSmaH, int64_t indexUid, TSKEY skey);
-static bool    tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, TSKEY *queryKey);
-static void    tsdbGetSmaDir(int32_t vgId, ETsdbSmaType smaType, char dirName[]);
-static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char *msg);
-static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, const char *msg);
-
-static FORCE_INLINE int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid);
-static FORCE_INLINE int32_t tsdbUpdateTbUidListImpl(STsdb *pTsdb, tb_uid_t *suid, SArray *tbUids);
-static FORCE_INLINE int32_t tsdbExecuteRSmaImpl(STsdb *pTsdb, const void *pMsg, int32_t inputType,
-                                                qTaskInfo_t *taskInfo, STSchema *pTSchema, tb_uid_t suid, tb_uid_t uid,
-                                                int8_t level);
-// mgmt interface
-static int32_t tsdbDropTSmaDataImpl(STsdb *pTsdb, int64_t indexUid);
-
-// Pool Memory
-static SPoolMem *openPool();
-static void      clearPool(SPoolMem *pPool);
-static void      closePool(SPoolMem *pPool);
-static void     *poolMalloc(void *arg, size_t size);
-static void      poolFree(void *arg, void *ptr);
-
-static int tsdbSmaBeginCommit(SSmaEnv *pEnv);
-static int tsdbSmaEndCommit(SSmaEnv *pEnv);
-
-// implementation
-static FORCE_INLINE int16_t tsdbTSmaAdd(STsdb *pTsdb, int16_t n) {
-  return atomic_add_fetch_16(&REPO_TSMA_NUM(pTsdb), n);
-}
-static FORCE_INLINE int16_t tsdbTSmaSub(STsdb *pTsdb, int16_t n) {
-  return atomic_sub_fetch_16(&REPO_TSMA_NUM(pTsdb), n);
-}
-
-static FORCE_INLINE int32_t tsdbRLockSma(SSmaEnv *pEnv) {
-  int code = taosThreadRwlockRdlock(&(pEnv->lock));
-  if (code != 0) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    return -1;
-  }
-  return 0;
-}
-
-static FORCE_INLINE int32_t tsdbWLockSma(SSmaEnv *pEnv) {
-  int code = taosThreadRwlockWrlock(&(pEnv->lock));
-  if (code != 0) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    return -1;
-  }
-  return 0;
-}
-
-static FORCE_INLINE int32_t tsdbUnLockSma(SSmaEnv *pEnv) {
-  int code = taosThreadRwlockUnlock(&(pEnv->lock));
-  if (code != 0) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    return -1;
-  }
-  return 0;
-}
-
-static SPoolMem *openPool() {
-  SPoolMem *pPool = (SPoolMem *)taosMemoryMalloc(sizeof(*pPool));
-
-  pPool->prev = pPool->next = pPool;
-  pPool->size = 0;
-
-  return pPool;
-}
-
-static void clearPool(SPoolMem *pPool) {
-  if (!pPool) return;
-
-  SPoolMem *pMem;
-
-  do {
-    pMem = pPool->next;
-
-    if (pMem == pPool) break;
-
-    pMem->next->prev = pMem->prev;
-    pMem->prev->next = pMem->next;
-    pPool->size -= pMem->size;
-
-    taosMemoryFree(pMem);
-  } while (1);
-
-  assert(pPool->size == 0);
-}
-
-static void closePool(SPoolMem *pPool) {
-  if (pPool) {
-    clearPool(pPool);
-    taosMemoryFree(pPool);
-  }
-}
-
-static void *poolMalloc(void *arg, size_t size) {
-  void     *ptr = NULL;
-  SPoolMem *pPool = (SPoolMem *)arg;
-  SPoolMem *pMem;
-
-  pMem = (SPoolMem *)taosMemoryMalloc(sizeof(*pMem) + size);
-  if (!pMem) {
-    assert(0);
-  }
-
-  pMem->size = sizeof(*pMem) + size;
-  pMem->next = pPool->next;
-  pMem->prev = pPool;
-
-  pPool->next->prev = pMem;
-  pPool->next = pMem;
-  pPool->size += pMem->size;
-
-  ptr = (void *)(&pMem[1]);
-  return ptr;
-}
-
-static void poolFree(void *arg, void *ptr) {
-  SPoolMem *pPool = (SPoolMem *)arg;
-  SPoolMem *pMem;
-
-  pMem = &(((SPoolMem *)ptr)[-1]);
-
-  pMem->next->prev = pMem->prev;
-  pMem->prev->next = pMem->next;
-  pPool->size -= pMem->size;
-
-  taosMemoryFree(pMem);
-}
-
-int32_t tsdbInitSma(STsdb *pTsdb) {
-  // tSma
-  int32_t numOfTSma = taosArrayGetSize(metaGetSmaTbUids(REPO_META(pTsdb), false));
-  if (numOfTSma > 0) {
-    atomic_store_16(&REPO_TSMA_NUM(pTsdb), (int16_t)numOfTSma);
-  }
-  // TODO: rSma
-  return TSDB_CODE_SUCCESS;
-}
-
-static FORCE_INLINE int8_t tsdbSmaStat(SSmaStatItem *pStatItem) {
-  if (pStatItem) {
-    return atomic_load_8(&pStatItem->state);
-  }
-  return TSDB_SMA_STAT_UNKNOWN;
-}
-
-static FORCE_INLINE bool tsdbSmaStatIsOK(SSmaStatItem *pStatItem, int8_t *state) {
-  if (!pStatItem) {
-    return false;
-  }
-
-  if (state) {
-    *state = atomic_load_8(&pStatItem->state);
-    return *state == TSDB_SMA_STAT_OK;
-  }
-  return atomic_load_8(&pStatItem->state) == TSDB_SMA_STAT_OK;
-}
-
-static FORCE_INLINE bool tsdbSmaStatIsExpired(SSmaStatItem *pStatItem) {
-  return pStatItem ? (atomic_load_8(&pStatItem->state) & TSDB_SMA_STAT_EXPIRED) : true;
-}
-
-static FORCE_INLINE bool tsdbSmaStatIsDropped(SSmaStatItem *pStatItem) {
-  return pStatItem ? (atomic_load_8(&pStatItem->state) & TSDB_SMA_STAT_DROPPED) : true;
-}
-
-static FORCE_INLINE void tsdbSmaStatSetOK(SSmaStatItem *pStatItem) {
-  if (pStatItem) {
-    atomic_store_8(&pStatItem->state, TSDB_SMA_STAT_OK);
-  }
-}
-
-static FORCE_INLINE void tsdbSmaStatSetExpired(SSmaStatItem *pStatItem) {
-  if (pStatItem) {
-    atomic_or_fetch_8(&pStatItem->state, TSDB_SMA_STAT_EXPIRED);
-  }
-}
-
-static FORCE_INLINE void tsdbSmaStatSetDropped(SSmaStatItem *pStatItem) {
-  if (pStatItem) {
-    atomic_or_fetch_8(&pStatItem->state, TSDB_SMA_STAT_DROPPED);
-  }
-}
-
-static void tsdbGetSmaDir(int32_t vgId, ETsdbSmaType smaType, char dirName[]) {
-  snprintf(dirName, TSDB_FILENAME_LEN, "vnode%svnode%d%s%s", TD_DIRSEP, vgId, TD_DIRSEP, TSDB_SMA_DNAME[smaType]);
-}
-
-static SSmaEnv *tsdbNewSmaEnv(const STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did) {
-  SSmaEnv *pEnv = NULL;
-
-  pEnv = (SSmaEnv *)taosMemoryCalloc(1, sizeof(SSmaEnv));
-  if (!pEnv) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  SMA_ENV_TYPE(pEnv) = smaType;
-
-  int code = taosThreadRwlockInit(&(pEnv->lock), NULL);
-  if (code) {
-    terrno = TAOS_SYSTEM_ERROR(code);
-    taosMemoryFree(pEnv);
-    return NULL;
-  }
-
-  ASSERT(path && (strlen(path) > 0));
-  SMA_ENV_PATH(pEnv) = strdup(path);
-  if (!SMA_ENV_PATH(pEnv)) {
-    tsdbFreeSmaEnv(pEnv);
-    return NULL;
-  }
-
-  SMA_ENV_DID(pEnv) = did;
-
-  if (tsdbInitSmaStat(&SMA_ENV_STAT(pEnv), smaType) != TSDB_CODE_SUCCESS) {
-    tsdbFreeSmaEnv(pEnv);
-    return NULL;
-  }
-
-  char aname[TSDB_FILENAME_LEN] = {0};
-  tfsAbsoluteName(REPO_TFS(pTsdb), did, path, aname);
-  if (tsdbOpenDBEnv(&pEnv->dbEnv, aname) != TSDB_CODE_SUCCESS) {
-    tsdbFreeSmaEnv(pEnv);
-    return NULL;
-  }
-
-  if (!(pEnv->pPool = openPool())) {
-    tsdbFreeSmaEnv(pEnv);
-    return NULL;
-  }
-
-  return pEnv;
-}
-
-static int32_t tsdbInitSmaEnv(STsdb *pTsdb, int8_t smaType, const char *path, SDiskID did, SSmaEnv **pEnv) {
-  if (!pEnv) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (!(*pEnv)) {
-    if (!(*pEnv = tsdbNewSmaEnv(pTsdb, smaType, path, did))) {
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Release resources allocated for its member fields, not including itself.
- *
- * @param pSmaEnv
- * @return int32_t
- */
-void tsdbDestroySmaEnv(SSmaEnv *pSmaEnv) {
-  if (pSmaEnv) {
-    tsdbDestroySmaState(pSmaEnv->pStat, SMA_ENV_TYPE(pSmaEnv));
-    taosMemoryFreeClear(pSmaEnv->pStat);
-    taosMemoryFreeClear(pSmaEnv->path);
-    taosThreadRwlockDestroy(&(pSmaEnv->lock));
-    tsdbCloseDBEnv(pSmaEnv->dbEnv);
-    closePool(pSmaEnv->pPool);
-  }
-}
-
-void *tsdbFreeSmaEnv(SSmaEnv *pSmaEnv) {
-  tsdbDestroySmaEnv(pSmaEnv);
-  taosMemoryFreeClear(pSmaEnv);
-  return NULL;
-}
-
-static int32_t tsdbRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
-  if (!pStat) return 0;
-
-  int ref = T_REF_INC(pStat);
-  tsdbDebug("vgId:%d ref sma stat:%p, val:%d", REPO_ID(pTsdb), pStat, ref);
-  return 0;
-}
-
-static int32_t tsdbUnRefSmaStat(STsdb *pTsdb, SSmaStat *pStat) {
-  if (!pStat) return 0;
-
-  int ref = T_REF_DEC(pStat);
-  tsdbDebug("vgId:%d unref sma stat:%p, val:%d", REPO_ID(pTsdb), pStat, ref);
-  return 0;
-}
-
-static int32_t tsdbInitSmaStat(SSmaStat **pSmaStat, int8_t smaType) {
-  ASSERT(pSmaStat != NULL);
-
-  if (*pSmaStat) {  // no lock
-    return TSDB_CODE_SUCCESS;
-  }
-
-  /**
-   *  1. Lazy mode utilized when init SSmaStat to update expired window(or hungry mode when tsdbNew).
-   *  2. Currently, there is mutex lock when init SSmaEnv, thus no need add lock on SSmaStat, and please add lock if
-   * tsdbInitSmaStat invoked in other multithread environment later.
-   */
-  if (!(*pSmaStat)) {
-    *pSmaStat = (SSmaStat *)taosMemoryCalloc(1, sizeof(SSmaStat));
-    if (!(*pSmaStat)) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return TSDB_CODE_FAILED;
-    }
-
-    if (smaType == TSDB_SMA_TYPE_ROLLUP) {
-      SMA_STAT_INFO_HASH(*pSmaStat) = taosHashInit(
-          RSMA_TASK_INFO_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
-
-      if (!SMA_STAT_INFO_HASH(*pSmaStat)) {
-        taosMemoryFreeClear(*pSmaStat);
-        return TSDB_CODE_FAILED;
-      }
-    } else if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
-      SMA_STAT_ITEMS(*pSmaStat) =
-          taosHashInit(SMA_STATE_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
-
-      if (!SMA_STAT_ITEMS(*pSmaStat)) {
-        taosMemoryFreeClear(*pSmaStat);
-        return TSDB_CODE_FAILED;
-      }
-    } else {
-      ASSERT(0);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static SSmaStatItem *tsdbNewSmaStatItem(int8_t state) {
-  SSmaStatItem *pItem = NULL;
-
-  pItem = (SSmaStatItem *)taosMemoryCalloc(1, sizeof(SSmaStatItem));
-  if (pItem) {
-    pItem->state = state;
-    pItem->expiredWindows = taosHashInit(SMA_STATE_ITEM_HASH_SLOT, taosGetDefaultHashFunction(TSDB_DATA_TYPE_TIMESTAMP),
-                                         true, HASH_ENTRY_LOCK);
-    if (!pItem->expiredWindows) {
-      taosMemoryFreeClear(pItem);
-    }
-  }
-  return pItem;
-}
-
-static void *tsdbFreeSmaStatItem(SSmaStatItem *pSmaStatItem) {
-  if (pSmaStatItem) {
-    tdDestroyTSma(pSmaStatItem->pSma);
-    taosMemoryFreeClear(pSmaStatItem->pSma);
-    taosHashCleanup(pSmaStatItem->expiredWindows);
-    taosMemoryFreeClear(pSmaStatItem);
-  }
-  return NULL;
-}
-
-/**
- * @brief Release resources allocated for its member fields, not including itself.
- *
- * @param pSmaStat
- * @return int32_t
- */
-int32_t tsdbDestroySmaState(SSmaStat *pSmaStat, int8_t smaType) {
-  if (pSmaStat) {
-    // TODO: use taosHashSetFreeFp when taosHashSetFreeFp is ready.
-    if (smaType == TSDB_SMA_TYPE_TIME_RANGE) {
-      void *item = taosHashIterate(SMA_STAT_ITEMS(pSmaStat), NULL);
-      while (item) {
-        SSmaStatItem *pItem = *(SSmaStatItem **)item;
-        tsdbFreeSmaStatItem(pItem);
-        item = taosHashIterate(SMA_STAT_ITEMS(pSmaStat), item);
-      }
-      taosHashCleanup(SMA_STAT_ITEMS(pSmaStat));
-    } else if (smaType == TSDB_SMA_TYPE_ROLLUP) {
-      void *infoHash = taosHashIterate(SMA_STAT_INFO_HASH(pSmaStat), NULL);
-      while (infoHash) {
-        SRSmaInfo *pInfoHash = *(SRSmaInfo **)infoHash;
-        tsdbFreeRSmaInfo(pInfoHash);
-        infoHash = taosHashIterate(SMA_STAT_INFO_HASH(pSmaStat), infoHash);
-      }
-      taosHashCleanup(SMA_STAT_INFO_HASH(pSmaStat));
-    } else {
-      ASSERT(0);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbCheckAndInitSmaEnv(STsdb *pTsdb, int8_t smaType) {
-  SSmaEnv *pEnv = NULL;
-
-  // return if already init
-  switch (smaType) {
-    case TSDB_SMA_TYPE_TIME_RANGE:
-      if ((pEnv = (SSmaEnv *)atomic_load_ptr(&REPO_TSMA_ENV(pTsdb)))) {
-        return TSDB_CODE_SUCCESS;
-      }
-      break;
-    case TSDB_SMA_TYPE_ROLLUP:
-      if ((pEnv = (SSmaEnv *)atomic_load_ptr(&REPO_RSMA_ENV(pTsdb)))) {
-        return TSDB_CODE_SUCCESS;
-      }
-      break;
-    default:
-      terrno = TSDB_CODE_INVALID_PARA;
-      return TSDB_CODE_FAILED;
-  }
-
-  // init sma env
-  tsdbLockRepo(pTsdb);
-  pEnv = (smaType == TSDB_SMA_TYPE_TIME_RANGE) ? atomic_load_ptr(&REPO_TSMA_ENV(pTsdb))
-                                               : atomic_load_ptr(&REPO_RSMA_ENV(pTsdb));
-  if (!pEnv) {
-    char rname[TSDB_FILENAME_LEN] = {0};
-
-    SDiskID did = {0};
-    tfsAllocDisk(REPO_TFS(pTsdb), TFS_PRIMARY_LEVEL, &did);
-    if (did.level < 0 || did.id < 0) {
-      tsdbUnlockRepo(pTsdb);
-      return TSDB_CODE_FAILED;
-    }
-    tsdbGetSmaDir(REPO_ID(pTsdb), smaType, rname);
-
-    if (tfsMkdirRecurAt(REPO_TFS(pTsdb), rname, did) != TSDB_CODE_SUCCESS) {
-      tsdbUnlockRepo(pTsdb);
-      return TSDB_CODE_FAILED;
-    }
-
-    if (tsdbInitSmaEnv(pTsdb, smaType, rname, did, &pEnv) != TSDB_CODE_SUCCESS) {
-      tsdbUnlockRepo(pTsdb);
-      return TSDB_CODE_FAILED;
-    }
-
-    (smaType == TSDB_SMA_TYPE_TIME_RANGE) ? atomic_store_ptr(&REPO_TSMA_ENV(pTsdb), pEnv)
-                                          : atomic_store_ptr(&REPO_RSMA_ENV(pTsdb), pEnv);
-  }
-  tsdbUnlockRepo(pTsdb);
-
-  return TSDB_CODE_SUCCESS;
-};
-
-static int32_t tsdbSetExpiredWindow(STsdb *pTsdb, SHashObj *pItemsHash, int64_t indexUid, int64_t winSKey,
-                                    int64_t version) {
-  SSmaStatItem *pItem = taosHashGet(pItemsHash, &indexUid, sizeof(indexUid));
-  if (!pItem) {
-    // TODO: use TSDB_SMA_STAT_EXPIRED and update by stream computing later
-    pItem = tsdbNewSmaStatItem(TSDB_SMA_STAT_OK);  // TODO use the real state
-    if (!pItem) {
-      // Response to stream computing: OOM
-      // For query, if the indexUid not found, the TSDB should tell query module to query raw TS data.
-      return TSDB_CODE_FAILED;
-    }
-
-    // cache smaMeta
-    STSma *pSma = metaGetSmaInfoByIndex(REPO_META(pTsdb), indexUid, true);
-    if (!pSma) {
-      terrno = TSDB_CODE_TDB_NO_SMA_INDEX_IN_META;
-      taosHashCleanup(pItem->expiredWindows);
-      taosMemoryFree(pItem);
-      tsdbWarn("vgId:%d update expired window failed for smaIndex %" PRIi64 " since %s", REPO_ID(pTsdb), indexUid,
-               tstrerror(terrno));
-      return TSDB_CODE_FAILED;
-    }
-    pItem->pSma = pSma;
-
-    if (taosHashPut(pItemsHash, &indexUid, sizeof(indexUid), &pItem, sizeof(pItem)) != 0) {
-      // If error occurs during put smaStatItem, free the resources of pItem
-      taosHashCleanup(pItem->expiredWindows);
-      taosMemoryFree(pItem);
-      return TSDB_CODE_FAILED;
-    }
-  } else if (!(pItem = *(SSmaStatItem **)pItem)) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (taosHashPut(pItem->expiredWindows, &winSKey, sizeof(TSKEY), &version, sizeof(version)) != 0) {
-    // If error occurs during taosHashPut expired windows, remove the smaIndex from pTsdb->pSmaStat, thus TSDB would
-    // tell query module to query raw TS data.
-    // N.B.
-    //  1) It is assumed to be extemely little probability event of fail to taosHashPut.
-    //  2) This would solve the inconsistency to some extent, but not completely, unless we record all expired
-    // windows failed to put into hash table.
-    taosHashCleanup(pItem->expiredWindows);
-    taosMemoryFreeClear(pItem->pSma);
-    taosHashRemove(pItemsHash, &indexUid, sizeof(indexUid));
-    tsdbWarn("vgId:%d smaIndex %" PRIi64 ", put skey %" PRIi64 " to expire window fail", REPO_ID(pTsdb), indexUid,
-             winSKey);
-    return TSDB_CODE_FAILED;
-  }
-
-  tsdbDebug("vgId:%d smaIndex %" PRIi64 ", put skey %" PRIi64 " to expire window succeed", REPO_ID(pTsdb), indexUid,
-            winSKey);
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Update expired window according to msg from stream computing module.
- *
- * @param pTsdb
- * @param msg SSubmitReq
- * @return int32_t
- */
-int32_t tsdbUpdateExpiredWindowImpl(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version) {
-  // no time-range-sma, just return success
-  if (atomic_load_16(&REPO_TSMA_NUM(pTsdb)) <= 0) {
-    tsdbTrace("vgId:%d not update expire window since no tSma", REPO_ID(pTsdb));
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (!REPO_META(pTsdb)) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
-    terrno = TSDB_CODE_TDB_INIT_FAILED;
-    return TSDB_CODE_FAILED;
-  }
-
-  // Firstly, assume that tSma can only be created on super table/normal table.
-  // getActiveTimeWindow
-
-  SSmaEnv  *pEnv = REPO_TSMA_ENV(pTsdb);
-  SSmaStat *pStat = SMA_ENV_STAT(pEnv);
-  SHashObj *pItemsHash = SMA_ENV_STAT_ITEMS(pEnv);
-
-  TASSERT(pEnv && pStat && pItemsHash);
-
-  // basic procedure
-  // TODO: optimization
-  tsdbRefSmaStat(pTsdb, pStat);
-
-  SSubmitMsgIter msgIter = {0};
-  SSubmitBlk    *pBlock = NULL;
-  SInterval      interval = {0};
-  TSKEY          lastWinSKey = INT64_MIN;
-
-  if (tInitSubmitMsgIter(pMsg, &msgIter) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_FAILED;
-  }
-
-  while (true) {
-    tGetSubmitMsgNext(&msgIter, &pBlock);
-    if (!pBlock) break;
-
-    STSmaWrapper *pSW = NULL;
-    STSma        *pTSma = NULL;
-
-    SSubmitBlkIter blkIter = {0};
-    if (tInitSubmitBlkIter(&msgIter, pBlock, &blkIter) != TSDB_CODE_SUCCESS) {
-      pSW = tdFreeTSmaWrapper(pSW);
-      break;
-    }
-
-    while (true) {
-      STSRow *row = tGetSubmitBlkNext(&blkIter);
-      if (!row) {
-        tdFreeTSmaWrapper(pSW);
-        break;
-      }
-      if (!pSW || (pTSma->tableUid != pBlock->suid)) {
-        if (pSW) {
-          pSW = tdFreeTSmaWrapper(pSW);
-        }
-        if (!(pSW = metaGetSmaInfoByTable(REPO_META(pTsdb), pBlock->suid))) {
-          break;
-        }
-        if ((pSW->number) <= 0 || !pSW->tSma) {
-          pSW = tdFreeTSmaWrapper(pSW);
-          break;
-        }
-
-        pTSma = pSW->tSma;
-
-        interval.interval = pTSma->interval;
-        interval.intervalUnit = pTSma->intervalUnit;
-        interval.offset = pTSma->offset;
-        interval.precision = REPO_CFG(pTsdb)->precision;
-        interval.sliding = pTSma->sliding;
-        interval.slidingUnit = pTSma->slidingUnit;
-      }
-
-      TSKEY winSKey = taosTimeTruncate(TD_ROW_KEY(row), &interval, interval.precision);
-
-      if (lastWinSKey != winSKey) {
-        lastWinSKey = winSKey;
-        tsdbSetExpiredWindow(pTsdb, pItemsHash, pTSma->indexUid, winSKey, version);
-      } else {
-        tsdbDebug("vgId:%d smaIndex %" PRIi64 ", put skey %" PRIi64 " to expire window ignore as duplicated",
-                  REPO_ID(pTsdb), pTSma->indexUid, winSKey);
-      }
-    }
-  }
-
-  tsdbUnRefSmaStat(pTsdb, pStat);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief When sma data received from stream computing, make the relative expired window valid.
- *
- * @param pTsdb
- * @param pStat
- * @param indexUid
- * @param skey
- * @return int32_t
- */
-static int32_t tsdbResetExpiredWindow(STsdb *pTsdb, SSmaStat *pStat, int64_t indexUid, TSKEY skey) {
-  SSmaStatItem *pItem = NULL;
-
-  tsdbRefSmaStat(pTsdb, pStat);
-
-  if (pStat && SMA_STAT_ITEMS(pStat)) {
-    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
-  }
-  if ((pItem) && ((pItem = *(SSmaStatItem **)pItem))) {
-    // pItem resides in hash buffer all the time unless drop sma index
-    // TODO: multithread protect
-    if (taosHashRemove(pItem->expiredWindows, &skey, sizeof(TSKEY)) != 0) {
-      // error handling
-      tsdbUnRefSmaStat(pTsdb, pStat);
-      tsdbWarn("vgId:%d remove skey %" PRIi64 " from expired window for sma index %" PRIi64 " fail", REPO_ID(pTsdb),
-               skey, indexUid);
-      return TSDB_CODE_FAILED;
-    }
-    tsdbDebug("vgId:%d remove skey %" PRIi64 " from expired window for sma index %" PRIi64 " succeed", REPO_ID(pTsdb),
-              skey, indexUid);
-    // TODO: use a standalone interface to received state upate notification from stream computing module.
-    /**
-     * @brief state
-     *  - When SMA env init in TSDB, its status is TSDB_SMA_STAT_OK.
-     *  - In startup phase of stream computing module, it should notify the SMA env in TSDB to expired if needed(e.g.
-     * when batch data caculation not finised)
-     *  - When TSDB_SMA_STAT_OK, the stream computing module should also notify that to the SMA env in TSDB.
-     */
-    pItem->state = TSDB_SMA_STAT_OK;
-  } else {
-    // error handling
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    tsdbWarn("vgId:%d expired window %" PRIi64 " not exists for sma index %" PRIi64, REPO_ID(pTsdb), skey, indexUid);
-    return TSDB_CODE_FAILED;
-  }
-
-  tsdbUnRefSmaStat(pTsdb, pStat);
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Judge the tSma storage level
- *
- * @param interval
- * @param intervalUnit
- * @return int32_t
- */
-static int32_t tsdbGetSmaStorageLevel(int64_t interval, int8_t intervalUnit) {
-  // TODO: configurable for SMA_STORAGE_SPLIT_HOURS?
-  switch (intervalUnit) {
-    case TIME_UNIT_HOUR:
-      if (interval < SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_MINUTE:
-      if (interval < 60 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_SECOND:
-      if (interval < 3600 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_MILLISECOND:
-      if (interval < 3600 * 1e3 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_MICROSECOND:
-      if (interval < 3600 * 1e6 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    case TIME_UNIT_NANOSECOND:
-      if (interval < 3600 * 1e9 * SMA_STORAGE_SPLIT_HOURS) {
-        return SMA_STORAGE_LEVEL_DFILESET;
-      }
-      break;
-    default:
-      break;
-  }
-  return SMA_STORAGE_LEVEL_TSDB;
-}
-
-/**
- * @brief Insert TSma data blocks to DB File build by B+Tree
- *
- * @param pSmaH
- * @param smaKey  tableUid-colId-skeyOfWindow(8-2-8)
- * @param keyLen
- * @param pData
- * @param dataLen
- * @return int32_t
- */
-static int32_t tsdbInsertTSmaBlocks(STSmaWriteH *pSmaH, void *smaKey, int32_t keyLen, void *pData, int32_t dataLen,
-                                    TXN *txn) {
-  SDBFile *pDBFile = &pSmaH->dFile;
-
-  // TODO: insert tsma data blocks into B+Tree(TTB)
-  if (tsdbSaveSmaToDB(pDBFile, smaKey, keyLen, pData, dataLen, txn) != 0) {
-    tsdbWarn("vgId:%d insert tsma data blocks into %s: smaKey %" PRIx64 "-%" PRIx64 ", dataLen %" PRIu32 " fail",
-             REPO_ID(pSmaH->pTsdb), pDBFile->path, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), dataLen);
-    return TSDB_CODE_FAILED;
-  }
-  tsdbDebug("vgId:%d insert tsma data blocks into %s: smaKey %" PRIx64 "-%" PRIx64 ", dataLen %" PRIu32 " succeed",
-            REPO_ID(pSmaH->pTsdb), pDBFile->path, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), dataLen);
-
-#ifdef _TEST_SMA_PRINT_DEBUG_LOG_
-  uint32_t valueSize = 0;
-  void    *data = tsdbGetSmaDataByKey(pDBFile, smaKey, keyLen, &valueSize);
-  ASSERT(data != NULL);
-  for (uint32_t v = 0; v < valueSize; v += 8) {
-    tsdbWarn("vgId:%d insert sma data val[%d] %" PRIi64, REPO_ID(pSmaH->pTsdb), v, *(int64_t *)POINTER_SHIFT(data, v));
-  }
-#endif
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Approximate value for week/month/year.
- *
- * @param interval
- * @param intervalUnit
- * @param precision
- * @param adjusted Interval already adjusted according to DB precision
- * @return int64_t
- */
-static int64_t tsdbGetIntervalByPrecision(int64_t interval, uint8_t intervalUnit, int8_t precision, bool adjusted) {
-  if (adjusted) {
-    return interval;
-  }
-
-  switch (intervalUnit) {
-    case TIME_UNIT_YEAR:  // approximate value
-      interval *= 365 * 86400 * 1e3;
-      break;
-    case TIME_UNIT_MONTH:  // approximate value
-      interval *= 30 * 86400 * 1e3;
-      break;
-    case TIME_UNIT_WEEK:  // approximate value
-      interval *= 7 * 86400 * 1e3;
-      break;
-    case TIME_UNIT_DAY:  // the interval for tSma calculation must <= day
-      interval *= 86400 * 1e3;
-      break;
-    case TIME_UNIT_HOUR:
-      interval *= 3600 * 1e3;
-      break;
-    case TIME_UNIT_MINUTE:
-      interval *= 60 * 1e3;
-      break;
-    case TIME_UNIT_SECOND:
-      interval *= 1e3;
-      break;
-    default:
-      break;
-  }
-
-  switch (precision) {
-    case TSDB_TIME_PRECISION_MILLI:
-      if (TIME_UNIT_MICROSECOND == intervalUnit) {  // us
-        return interval / 1e3;
-      } else if (TIME_UNIT_NANOSECOND == intervalUnit) {  //  nano second
-        return interval / 1e6;
-      } else {  // ms
-        return interval;
-      }
-      break;
-    case TSDB_TIME_PRECISION_MICRO:
-      if (TIME_UNIT_MICROSECOND == intervalUnit) {  // us
-        return interval;
-      } else if (TIME_UNIT_NANOSECOND == intervalUnit) {  //  ns
-        return interval / 1e3;
-      } else {  // ms
-        return interval * 1e3;
-      }
-      break;
-    case TSDB_TIME_PRECISION_NANO:
-      if (TIME_UNIT_MICROSECOND == intervalUnit) {  // us
-        return interval * 1e3;
-      } else if (TIME_UNIT_NANOSECOND == intervalUnit) {  // ns
-        return interval;
-      } else {  // ms
-        return interval * 1e6;
-      }
-      break;
-    default:                                        // ms
-      if (TIME_UNIT_MICROSECOND == intervalUnit) {  // us
-        return interval / 1e3;
-      } else if (TIME_UNIT_NANOSECOND == intervalUnit) {  //  ns
-        return interval / 1e6;
-      } else {  // ms
-        return interval;
-      }
-      break;
-  }
-  return interval;
-}
-
-static int32_t tsdbInitTSmaWriteH(STSmaWriteH *pSmaH, STsdb *pTsdb, const SArray *pDataBlocks, int64_t interval,
-                                  int8_t intervalUnit) {
-  pSmaH->pTsdb = pTsdb;
-  pSmaH->interval = tsdbGetIntervalByPrecision(interval, intervalUnit, REPO_CFG(pTsdb)->precision, true);
-  pSmaH->pDataBlocks = pDataBlocks;
-  pSmaH->dFile.fid = TSDB_IVLD_FID;
-  return TSDB_CODE_SUCCESS;
-}
-
-static void tsdbDestroyTSmaWriteH(STSmaWriteH *pSmaH) {
-  if (pSmaH) {
-    tsdbCloseDBF(&pSmaH->dFile);
-  }
-}
-
-static int32_t tsdbSetTSmaDataFile(STSmaWriteH *pSmaH, int64_t indexUid, int32_t fid) {
-  STsdb *pTsdb = pSmaH->pTsdb;
-  ASSERT(!pSmaH->dFile.path && !pSmaH->dFile.pDB);
-
-  pSmaH->dFile.fid = fid;
-  char tSmaFile[TSDB_FILENAME_LEN] = {0};
-  snprintf(tSmaFile, TSDB_FILENAME_LEN, "%" PRIi64 "%sv%df%d.tsma", indexUid, TD_DIRSEP, REPO_ID(pTsdb), fid);
-  pSmaH->dFile.path = strdup(tSmaFile);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief
- *
- * @param pTsdb
- * @param interval Interval calculated by DB's precision
- * @param storageLevel
- * @return int32_t
- */
-static int32_t tsdbGetTSmaDays(STsdb *pTsdb, int64_t interval, int32_t storageLevel) {
-  STsdbKeepCfg *pCfg = REPO_KEEP_CFG(pTsdb);
-  int32_t       daysPerFile = pCfg->days;
-
-  if (storageLevel == SMA_STORAGE_LEVEL_TSDB) {
-    int32_t days = SMA_STORAGE_TSDB_TIMES * (interval / tsTickPerMin[pCfg->precision]);
-    daysPerFile = days > SMA_STORAGE_TSDB_DAYS ? days : SMA_STORAGE_TSDB_DAYS;
-  }
-
-  return daysPerFile;
-}
-
-static int tsdbSmaBeginCommit(SSmaEnv *pEnv) {
-  TXN *pTxn = &pEnv->txn;
-  // start a new txn
-  tdbTxnOpen(pTxn, 0, poolMalloc, poolFree, pEnv->pPool, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED);
-  if (tdbBegin(pEnv->dbEnv, pTxn) != 0) {
-    tsdbWarn("tsdbSma tdb begin commit fail");
-    return -1;
-  }
-  return 0;
-}
-
-static int tsdbSmaEndCommit(SSmaEnv *pEnv) {
-  TXN *pTxn = &pEnv->txn;
-
-  // Commit current txn
-  if (tdbCommit(pEnv->dbEnv, pTxn) != 0) {
-    tsdbWarn("tsdbSma tdb end commit fail");
-    return -1;
-  }
-  tdbTxnClose(pTxn);
-  clearPool(pEnv->pPool);
-  return 0;
-}
-
-/**
- * @brief Insert/Update Time-range-wise SMA data.
- *  - If interval < SMA_STORAGE_SPLIT_HOURS(e.g. 24), save the SMA data as a part of DFileSet to e.g.
- * v3f1900.tsma.${sma_index_name}. The days is the same with that for TS data files.
- *  - If interval >= SMA_STORAGE_SPLIT_HOURS, save the SMA data to e.g. vnode3/tsma/v3f632.tsma.${sma_index_name}. The
- * days is 30 times of the interval, and the minimum days is SMA_STORAGE_TSDB_DAYS(30d).
- *  - The destination file of one data block for some interval is determined by its start TS key.
- *
- * @param pTsdb
- * @param msg
- * @return int32_t
- */
-static int32_t tsdbInsertTSmaDataImpl(STsdb *pTsdb, int64_t indexUid, const char *msg) {
-  STsdbCfg     *pCfg = REPO_CFG(pTsdb);
-  const SArray *pDataBlocks = (const SArray *)msg;
-
-  // TODO: destroy SSDataBlocks(msg)
-
-  // For super table aggregation, the sma data is stored in vgroup calculated from the hash value of stable name. Thus
-  // the sma data would arrive ahead of the update-expired-window msg.
-  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_TIME_RANGE) != TSDB_CODE_SUCCESS) {
-    terrno = TSDB_CODE_TDB_INIT_FAILED;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (!pDataBlocks) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d insert tSma data failed since pDataBlocks is NULL", REPO_ID(pTsdb));
-    return terrno;
-  }
-
-  if (taosArrayGetSize(pDataBlocks) <= 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    tsdbWarn("vgId:%d insert tSma data failed since pDataBlocks is empty", REPO_ID(pTsdb));
-    return TSDB_CODE_FAILED;
-  }
-
-  SSmaEnv      *pEnv = REPO_TSMA_ENV(pTsdb);
-  SSmaStat     *pStat = SMA_ENV_STAT(pEnv);
-  SSmaStatItem *pItem = NULL;
-
-  tsdbRefSmaStat(pTsdb, pStat);
-
-  if (pStat && SMA_STAT_ITEMS(pStat)) {
-    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
-  }
-
-  if (!pItem || !(pItem = *(SSmaStatItem **)pItem) || tsdbSmaStatIsDropped(pItem)) {
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    return TSDB_CODE_FAILED;
-  }
-
-  STSma      *pSma = pItem->pSma;
-  STSmaWriteH tSmaH = {0};
-
-  if (tsdbInitTSmaWriteH(&tSmaH, pTsdb, pDataBlocks, pSma->interval, pSma->intervalUnit) != 0) {
-    return TSDB_CODE_FAILED;
-  }
-
-  char rPath[TSDB_FILENAME_LEN] = {0};
-  char aPath[TSDB_FILENAME_LEN] = {0};
-  snprintf(rPath, TSDB_FILENAME_LEN, "%s%s%" PRIi64, SMA_ENV_PATH(pEnv), TD_DIRSEP, indexUid);
-  tfsAbsoluteName(REPO_TFS(pTsdb), SMA_ENV_DID(pEnv), rPath, aPath);
-  if (!taosCheckExistFile(aPath)) {
-    if (tfsMkdirRecurAt(REPO_TFS(pTsdb), rPath, SMA_ENV_DID(pEnv)) != TSDB_CODE_SUCCESS) {
-      tsdbUnRefSmaStat(pTsdb, pStat);
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  // Step 1: Judge the storage level and days
-  int32_t storageLevel = tsdbGetSmaStorageLevel(pSma->interval, pSma->intervalUnit);
-  int32_t daysPerFile = tsdbGetTSmaDays(pTsdb, tSmaH.interval, storageLevel);
-
-  char    smaKey[SMA_KEY_LEN] = {0};  // key: skey + groupId
-  char    dataBuf[512] = {0};         // val: aggr data // TODO: handle 512 buffer?
-  void   *pDataBuf = NULL;
-  int32_t sz = taosArrayGetSize(pDataBlocks);
-  for (int32_t i = 0; i < sz; ++i) {
-    SSDataBlock *pDataBlock = taosArrayGet(pDataBlocks, i);
-    int32_t      colNum = pDataBlock->info.numOfCols;
-    int32_t      rows = pDataBlock->info.rows;
-    int32_t      rowSize = pDataBlock->info.rowSize;
-    int64_t      groupId = pDataBlock->info.groupId;
-    for (int32_t j = 0; j < rows; ++j) {
-      printf("|");
-      TSKEY skey = TSKEY_INITIAL_VAL;  //  the start key of TS window by interval
-      void *pSmaKey = &smaKey;
-      bool  isStartKey = false;
-
-      int32_t tlen = 0;     // reset the len
-      pDataBuf = &dataBuf;  // reset the buf
-      for (int32_t k = 0; k < colNum; ++k) {
-        SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock->pDataBlock, k);
-        void            *var = POINTER_SHIFT(pColInfoData->pData, j * pColInfoData->info.bytes);
-        switch (pColInfoData->info.type) {
-          case TSDB_DATA_TYPE_TIMESTAMP:
-            if (!isStartKey) {
-              isStartKey = true;
-              skey = *(TSKEY *)var;
-              printf("= skey %" PRIi64 " groupId = %" PRIi64 "|", skey, groupId);
-              tsdbEncodeTSmaKey(groupId, skey, &pSmaKey);
-            } else {
-              printf(" %" PRIi64 " |", *(int64_t *)var);
-              tlen += taosEncodeFixedI64(&pDataBuf, *(int64_t *)var);
-              break;
-            }
-            break;
-          case TSDB_DATA_TYPE_BOOL:
-          case TSDB_DATA_TYPE_UTINYINT:
-            printf(" %15d |", *(uint8_t *)var);
-            tlen += taosEncodeFixedU8(&pDataBuf, *(uint8_t *)var);
-            break;
-          case TSDB_DATA_TYPE_TINYINT:
-            printf(" %15d |", *(int8_t *)var);
-            tlen += taosEncodeFixedI8(&pDataBuf, *(int8_t *)var);
-            break;
-          case TSDB_DATA_TYPE_SMALLINT:
-            printf(" %15d |", *(int16_t *)var);
-            tlen += taosEncodeFixedI16(&pDataBuf, *(int16_t *)var);
-            break;
-          case TSDB_DATA_TYPE_USMALLINT:
-            printf(" %15d |", *(uint16_t *)var);
-            tlen += taosEncodeFixedU16(&pDataBuf, *(uint16_t *)var);
-            break;
-          case TSDB_DATA_TYPE_INT:
-            printf(" %15d |", *(int32_t *)var);
-            tlen += taosEncodeFixedI32(&pDataBuf, *(int32_t *)var);
-            break;
-          case TSDB_DATA_TYPE_FLOAT:
-            printf(" %15f |", *(float *)var);
-            tlen += taosEncodeBinary(&pDataBuf, var, sizeof(float));
-            break;
-          case TSDB_DATA_TYPE_UINT:
-            printf(" %15u |", *(uint32_t *)var);
-            tlen += taosEncodeFixedU32(&pDataBuf, *(uint32_t *)var);
-            break;
-          case TSDB_DATA_TYPE_BIGINT:
-            printf(" %15ld |", *(int64_t *)var);
-            tlen += taosEncodeFixedI64(&pDataBuf, *(int64_t *)var);
-            break;
-          case TSDB_DATA_TYPE_DOUBLE:
-            printf(" %15lf |", *(double *)var);
-            tlen += taosEncodeBinary(&pDataBuf, var, sizeof(double));
-          case TSDB_DATA_TYPE_UBIGINT:
-            printf(" %15lu |", *(uint64_t *)var);
-            tlen += taosEncodeFixedU64(&pDataBuf, *(uint64_t *)var);
-            break;
-          case TSDB_DATA_TYPE_NCHAR: {
-            char tmpChar[100] = {0};
-            strncpy(tmpChar, varDataVal(var), varDataLen(var));
-            printf(" %s |", tmpChar);
-            tlen += taosEncodeBinary(&pDataBuf, varDataVal(var), varDataLen(var));
-            break;
-          }
-          case TSDB_DATA_TYPE_VARCHAR: {  // TSDB_DATA_TYPE_BINARY
-            char tmpChar[100] = {0};
-            strncpy(tmpChar, varDataVal(var), varDataLen(var));
-            printf(" %s |", tmpChar);
-            tlen += taosEncodeBinary(&pDataBuf, varDataVal(var), varDataLen(var));
-            break;
-          }
-          case TSDB_DATA_TYPE_VARBINARY:
-            // TODO: add binary/varbinary
-            TASSERT(0);
-          default:
-            printf("the column type %" PRIi16 " is undefined\n", pColInfoData->info.type);
-            TASSERT(0);
-            break;
-        }
-      }
-      // if ((tlen > 0) && (skey != TSKEY_INITIAL_VAL)) {
-      if (tlen > 0) {
-        int32_t fid = (int32_t)(TSDB_KEY_FID(skey, daysPerFile, pCfg->precision));
-
-        // Step 2: Set the DFile for storage of SMA index, and iterate/split the TSma data and store to B+Tree index
-        // file
-        //         - Set and open the DFile or the B+Tree file
-        // TODO: tsdbStartTSmaCommit();
-        if (fid != tSmaH.dFile.fid) {
-          if (tSmaH.dFile.fid != TSDB_IVLD_FID) {
-            tsdbSmaEndCommit(pEnv);
-            tsdbCloseDBF(&tSmaH.dFile);
-          }
-          tsdbSetTSmaDataFile(&tSmaH, indexUid, fid);
-          if (tsdbOpenDBF(pEnv->dbEnv, &tSmaH.dFile) != 0) {
-            tsdbWarn("vgId:%d open DB file %s failed since %s", REPO_ID(pTsdb),
-                     tSmaH.dFile.path ? tSmaH.dFile.path : "path is NULL", tstrerror(terrno));
-            tsdbDestroyTSmaWriteH(&tSmaH);
-            tsdbUnRefSmaStat(pTsdb, pStat);
-            return TSDB_CODE_FAILED;
-          }
-          tsdbSmaBeginCommit(pEnv);
-        }
-
-        if (tsdbInsertTSmaBlocks(&tSmaH, &smaKey, SMA_KEY_LEN, dataBuf, tlen, &pEnv->txn) != 0) {
-          tsdbWarn("vgId:%d insert tsma data blocks fail for index %" PRIi64 ", skey %" PRIi64 ", groupId %" PRIi64
-                   " since %s",
-                   REPO_ID(pTsdb), indexUid, skey, groupId, tstrerror(terrno));
-          tsdbSmaEndCommit(pEnv);
-          tsdbDestroyTSmaWriteH(&tSmaH);
-          tsdbUnRefSmaStat(pTsdb, pStat);
-          return TSDB_CODE_FAILED;
-        }
-        tsdbDebug("vgId:%d insert tsma data blocks success for index %" PRIi64 ", skey %" PRIi64 ", groupId %" PRIi64,
-                  REPO_ID(pTsdb), indexUid, skey, groupId);
-        // TODO:tsdbEndTSmaCommit();
-
-        // Step 3: reset the SSmaStat
-        tsdbResetExpiredWindow(pTsdb, pStat, indexUid, skey);
-      } else {
-        tsdbWarn("vgId:%d invalid data skey:%" PRIi64 ", tlen %" PRIi32 " during insert tSma data for %" PRIi64,
-                 REPO_ID(pTsdb), skey, tlen, indexUid);
-      }
-
-      printf("\n");
-    }
-  }
-  tsdbSmaEndCommit(pEnv);  // TODO: not commit for every insert
-  tsdbDestroyTSmaWriteH(&tSmaH);
-  tsdbUnRefSmaStat(pTsdb, pStat);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Drop tSma data and local cache
- *        - insert/query reference
- * @param pTsdb
- * @param msg
- * @return int32_t
- */
-static int32_t tsdbDropTSmaDataImpl(STsdb *pTsdb, int64_t indexUid) {
-  SSmaEnv *pEnv = atomic_load_ptr(&REPO_TSMA_ENV(pTsdb));
-
-  // clear local cache
-  if (pEnv) {
-    tsdbDebug("vgId:%d drop tSma local cache for %" PRIi64, REPO_ID(pTsdb), indexUid);
-
-    SSmaStatItem *pItem = taosHashGet(SMA_ENV_STAT_ITEMS(pEnv), &indexUid, sizeof(indexUid));
-    if ((pItem) || ((pItem = *(SSmaStatItem **)pItem))) {
-      if (tsdbSmaStatIsDropped(pItem)) {
-        tsdbDebug("vgId:%d tSma stat is already dropped for %" PRIi64, REPO_ID(pTsdb), indexUid);
-        return TSDB_CODE_TDB_INVALID_ACTION;  // TODO: duplicate drop msg would be intercepted by mnode
-      }
-
-      tsdbWLockSma(pEnv);
-      if (tsdbSmaStatIsDropped(pItem)) {
-        tsdbUnLockSma(pEnv);
-        tsdbDebug("vgId:%d tSma stat is already dropped for %" PRIi64, REPO_ID(pTsdb), indexUid);
-        return TSDB_CODE_TDB_INVALID_ACTION;  // TODO: duplicate drop msg would be intercepted by mnode
-      }
-      tsdbSmaStatSetDropped(pItem);
-      tsdbUnLockSma(pEnv);
-
-      int32_t nSleep = 0;
-      int32_t refVal = INT32_MAX;
-      while (true) {
-        if ((refVal = T_REF_VAL_GET(SMA_ENV_STAT(pEnv))) <= 0) {
-          tsdbDebug("vgId:%d drop index %" PRIi64 " since refVal=%d", REPO_ID(pTsdb), indexUid, refVal);
-          break;
-        }
-        tsdbDebug("vgId:%d wait 1s to drop index %" PRIi64 " since refVal=%d", REPO_ID(pTsdb), indexUid, refVal);
-        taosSsleep(1);
-        if (++nSleep > SMA_DROP_EXPIRED_TIME) {
-          tsdbDebug("vgId:%d drop index %" PRIi64 " after wait %d (refVal=%d)", REPO_ID(pTsdb), indexUid, nSleep,
-                    refVal);
-          break;
-        };
-      }
-
-      tsdbFreeSmaStatItem(pItem);
-      tsdbDebug("vgId:%d getTSmaDataImpl failed since no index %" PRIi64 " in local cache", REPO_ID(pTsdb), indexUid);
-    }
-  }
-  // clear sma data files
-  // TODO:
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbSetRSmaDataFile(STSmaWriteH *pSmaH, int32_t fid) {
-  STsdb *pTsdb = pSmaH->pTsdb;
-
-  char tSmaFile[TSDB_FILENAME_LEN] = {0};
-  snprintf(tSmaFile, TSDB_FILENAME_LEN, "v%df%d.rsma", REPO_ID(pTsdb), fid);
-  pSmaH->dFile.path = strdup(tSmaFile);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbInsertRSmaDataImpl(STsdb *pTsdb, const char *msg) {
-  STsdbCfg     *pCfg = REPO_CFG(pTsdb);
-  const SArray *pDataBlocks = (const SArray *)msg;
-  SSmaEnv      *pEnv = atomic_load_ptr(&REPO_RSMA_ENV(pTsdb));
-  int64_t       indexUid = SMA_TEST_INDEX_UID;
-
-  if (!pEnv) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d insert rSma data failed since pTSmaEnv is NULL", REPO_ID(pTsdb));
-    return terrno;
-  }
-
-  if (!pDataBlocks) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d insert rSma data failed since pDataBlocks is NULL", REPO_ID(pTsdb));
-    return terrno;
-  }
-
-  if (taosArrayGetSize(pDataBlocks) <= 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    tsdbWarn("vgId:%d insert rSma data failed since pDataBlocks is empty", REPO_ID(pTsdb));
-    return TSDB_CODE_FAILED;
-  }
-
-  SSmaStat     *pStat = SMA_ENV_STAT(pEnv);
-  SSmaStatItem *pItem = NULL;
-
-  tsdbRefSmaStat(pTsdb, pStat);
-
-  if (pStat && SMA_STAT_ITEMS(pStat)) {
-    pItem = taosHashGet(SMA_STAT_ITEMS(pStat), &indexUid, sizeof(indexUid));
-  }
-
-  if (!pItem || !(pItem = *(SSmaStatItem **)pItem) || tsdbSmaStatIsDropped(pItem)) {
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    return TSDB_CODE_FAILED;
-  }
-
-  STSma *pSma = pItem->pSma;
-
-  STSmaWriteH tSmaH = {0};
-
-  if (tsdbInitTSmaWriteH(&tSmaH, pTsdb, pDataBlocks, pSma->interval, pSma->intervalUnit) != 0) {
-    return TSDB_CODE_FAILED;
-  }
-
-  char rPath[TSDB_FILENAME_LEN] = {0};
-  char aPath[TSDB_FILENAME_LEN] = {0};
-  snprintf(rPath, TSDB_FILENAME_LEN, "%s%s%" PRIi64, SMA_ENV_PATH(pEnv), TD_DIRSEP, indexUid);
-  tfsAbsoluteName(REPO_TFS(pTsdb), SMA_ENV_DID(pEnv), rPath, aPath);
-  if (!taosCheckExistFile(aPath)) {
-    if (tfsMkdirRecurAt(REPO_TFS(pTsdb), rPath, SMA_ENV_DID(pEnv)) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  // Step 1: Judge the storage level and days
-  int32_t storageLevel = tsdbGetSmaStorageLevel(pSma->interval, pSma->intervalUnit);
-  int32_t daysPerFile = tsdbGetTSmaDays(pTsdb, tSmaH.interval, storageLevel);
-#if 0
-  int32_t fid = (int32_t)(TSDB_KEY_FID(pData->skey, daysPerFile, pCfg->precision));
-
-  // Step 2: Set the DFile for storage of SMA index, and iterate/split the TSma data and store to B+Tree index file
-  //         - Set and open the DFile or the B+Tree file
-  // TODO: tsdbStartTSmaCommit();
-  tsdbSetTSmaDataFile(&tSmaH, pData, indexUid, fid);
-  if (tsdbOpenDBF(pTsdb->pTSmaEnv->dbEnv, &tSmaH.dFile) != 0) {
-    tsdbWarn("vgId:%d open DB file %s failed since %s", REPO_ID(pTsdb),
-             tSmaH.dFile.path ? tSmaH.dFile.path : "path is NULL", tstrerror(terrno));
-    tsdbDestroyTSmaWriteH(&tSmaH);
-    return TSDB_CODE_FAILED;
-  }
-
-  if (tsdbInsertTSmaDataSection(&tSmaH, pData) != 0) {
-    tsdbWarn("vgId:%d insert tSma data section failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-    tsdbDestroyTSmaWriteH(&tSmaH);
-    return TSDB_CODE_FAILED;
-  }
-  // TODO:tsdbEndTSmaCommit();
-
-  // Step 3: reset the SSmaStat
-  tsdbResetExpiredWindow(pTsdb, SMA_ENV_STAT(pTsdb->pTSmaEnv), pData->indexUid, pData->skey);
-#endif
-
-  tsdbDestroyTSmaWriteH(&tSmaH);
-  tsdbUnRefSmaStat(pTsdb, pStat);
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief
- *
- * @param pSmaH
- * @param pTsdb
- * @param interval
- * @param intervalUnit
- * @return int32_t
- */
-static int32_t tsdbInitTSmaReadH(STSmaReadH *pSmaH, STsdb *pTsdb, int64_t interval, int8_t intervalUnit) {
-  pSmaH->pTsdb = pTsdb;
-  pSmaH->interval = tsdbGetIntervalByPrecision(interval, intervalUnit, REPO_CFG(pTsdb)->precision, true);
-  pSmaH->storageLevel = tsdbGetSmaStorageLevel(interval, intervalUnit);
-  pSmaH->days = tsdbGetTSmaDays(pTsdb, pSmaH->interval, pSmaH->storageLevel);
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Init of tSma FS
- *
- * @param pReadH
- * @param indexUid
- * @param skey
- * @return int32_t
- */
-static int32_t tsdbInitTSmaFile(STSmaReadH *pSmaH, int64_t indexUid, TSKEY skey) {
-  STsdb *pTsdb = pSmaH->pTsdb;
-
-  int32_t fid = (int32_t)(TSDB_KEY_FID(skey, pSmaH->days, REPO_CFG(pTsdb)->precision));
-  char    tSmaFile[TSDB_FILENAME_LEN] = {0};
-  snprintf(tSmaFile, TSDB_FILENAME_LEN, "%" PRIi64 "%sv%df%d.tsma", indexUid, TD_DIRSEP, REPO_ID(pTsdb), fid);
-  pSmaH->dFile.path = strdup(tSmaFile);
-  pSmaH->smaFsIter.iter = 0;
-  pSmaH->smaFsIter.fid = fid;
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Set and open tSma file if it has key locates in queryWin.
- *
- * @param pReadH
- * @param param
- * @param queryWin
- * @return true
- * @return false
- */
-static bool tsdbSetAndOpenTSmaFile(STSmaReadH *pReadH, TSKEY *queryKey) {
-  SArray *smaFs = pReadH->pTsdb->fs->cstatus->sf;
-  int32_t nSmaFs = taosArrayGetSize(smaFs);
-
-  tsdbCloseDBF(&pReadH->dFile);
-
-#if 0
-  while (pReadH->smaFsIter.iter < nSmaFs) {
-    void *pSmaFile = taosArrayGet(smaFs, pReadH->smaFsIter.iter);
-    if (pSmaFile) {  // match(indexName, queryWindow)
-      // TODO: select the file by index_name ...
-      pReadH->dFile = pSmaFile;
-      ++pReadH->smaFsIter.iter;
-      break;
-    }
-    ++pReadH->smaFsIter.iter;
-  }
-
-  if (pReadH->pDFile) {
-    tsdbDebug("vg%d: smaFile %s matched", REPO_ID(pReadH->pTsdb), "[pSmaFile dir]");
-    return true;
-  }
-#endif
-
-  return false;
-}
-
-/**
- * @brief
- *
- * @param pTsdb Return the data between queryWin and fill the pData.
- * @param pData
- * @param indexUid
- * @param pQuerySKey
- * @param nMaxResult The query invoker should control the nMaxResult need to return to avoid OOM.
- * @return int32_t
- */
-static int32_t tsdbGetTSmaDataImpl(STsdb *pTsdb, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult) {
-  SSmaEnv  *pEnv = atomic_load_ptr(&REPO_TSMA_ENV(pTsdb));
-  SSmaStat *pStat = NULL;
-
-  if (!pEnv) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbWarn("vgId:%d getTSmaDataImpl failed since pTSmaEnv is NULL", REPO_ID(pTsdb));
-    return TSDB_CODE_FAILED;
-  }
-
-  pStat = SMA_ENV_STAT(pEnv);
-
-  tsdbRefSmaStat(pTsdb, pStat);
-  SSmaStatItem *pItem = taosHashGet(SMA_ENV_STAT_ITEMS(pEnv), &indexUid, sizeof(indexUid));
-  if (!pItem || !(pItem = *(SSmaStatItem **)pItem)) {
-    // Normally pItem should not be NULL, mark all windows as expired and notify query module to fetch raw TS data if
-    // it's NULL.
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    terrno = TSDB_CODE_TDB_INVALID_ACTION;
-    tsdbDebug("vgId:%d getTSmaDataImpl failed since no index %" PRIi64, REPO_ID(pTsdb), indexUid);
-    return TSDB_CODE_FAILED;
-  }
-
-#if 0
-  int32_t nQueryWin = taosArrayGetSize(pQuerySKey);
-  for (int32_t n = 0; n < nQueryWin; ++n) {
-    TSKEY skey = taosArrayGet(pQuerySKey, n);
-    if (taosHashGet(pItem->expiredWindows, &skey, sizeof(TSKEY))) {
-      // TODO: mark this window as expired.
-    }
-  }
-#endif
-
-#if 1
-  int8_t smaStat = 0;
-  if (!tsdbSmaStatIsOK(pItem, &smaStat)) {  // TODO: multiple check for large scale sma query
-    tsdbUnRefSmaStat(pTsdb, pStat);
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    tsdbWarn("vgId:%d getTSmaDataImpl failed from index %" PRIi64 " since %s %" PRIi8, REPO_ID(pTsdb), indexUid,
-             tstrerror(terrno), smaStat);
-    return TSDB_CODE_FAILED;
-  }
-
-  if (taosHashGet(pItem->expiredWindows, &querySKey, sizeof(TSKEY))) {
-    // TODO: mark this window as expired.
-    tsdbDebug("vgId:%d skey %" PRIi64 " of window exists in expired window for index %" PRIi64, REPO_ID(pTsdb),
-              querySKey, indexUid);
-  } else {
-    tsdbDebug("vgId:%d skey %" PRIi64 " of window not in expired window for index %" PRIi64, REPO_ID(pTsdb), querySKey,
-              indexUid);
-  }
-
-  STSma *pTSma = pItem->pSma;
-#endif
-
-  STSmaReadH tReadH = {0};
-  tsdbInitTSmaReadH(&tReadH, pTsdb, pTSma->interval, pTSma->intervalUnit);
-  tsdbCloseDBF(&tReadH.dFile);
-
-  tsdbUnRefSmaStat(pTsdb, pStat);
-
-  tsdbInitTSmaFile(&tReadH, indexUid, querySKey);
-  if (tsdbOpenDBF(pEnv->dbEnv, &tReadH.dFile) != 0) {
-    tsdbWarn("vgId:%d open DBF %s failed since %s", REPO_ID(pTsdb), tReadH.dFile.path, tstrerror(terrno));
-    return TSDB_CODE_FAILED;
-  }
-
-  char    smaKey[SMA_KEY_LEN] = {0};
-  void   *pSmaKey = &smaKey;
-  int64_t queryGroupId = 1;
-  tsdbEncodeTSmaKey(queryGroupId, querySKey, (void **)&pSmaKey);
-
-  tsdbDebug("vgId:%d get sma data from %s: smaKey %" PRIx64 "-%" PRIx64 ", keyLen %d", REPO_ID(pTsdb),
-            tReadH.dFile.path, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), SMA_KEY_LEN);
-
-  void   *result = NULL;
-  int32_t valueSize = 0;
-  if (!(result = tsdbGetSmaDataByKey(&tReadH.dFile, smaKey, SMA_KEY_LEN, &valueSize))) {
-    tsdbWarn("vgId:%d get sma data failed from smaIndex %" PRIi64 ", smaKey %" PRIx64 "-%" PRIx64 " since %s",
-             REPO_ID(pTsdb), indexUid, *(int64_t *)smaKey, *(int64_t *)POINTER_SHIFT(smaKey, 8), tstrerror(terrno));
-    tsdbCloseDBF(&tReadH.dFile);
-    return TSDB_CODE_FAILED;
-  }
-
-#ifdef _TEST_SMA_PRINT_DEBUG_LOG_
-  for (uint32_t v = 0; v < valueSize; v += 8) {
-    tsdbWarn("vgId:%d get sma data v[%d]=%" PRIi64, REPO_ID(pTsdb), v, *(int64_t *)POINTER_SHIFT(result, v));
-  }
-#endif
-  taosMemoryFreeClear(result);  // TODO: fill the result to output
-
-#if 0
-  int32_t nResult = 0;
-  int64_t lastKey = 0;
-
-  while (true) {
-    if (nResult >= nMaxResult) {
-      break;
-    }
-
-    // set and open the file according to the STSma param
-    if (tsdbSetAndOpenTSmaFile(&tReadH, queryWin)) {
-      char bTree[100] = "\0";
-      while (strncmp(bTree, "has more nodes", 100) == 0) {
-        if (nResult >= nMaxResult) {
-          break;
-        }
-        // tsdbGetDataFromBTree(bTree, queryWin, lastKey)
-        // fill the pData
-        ++nResult;
-      }
-    }
-  }
-#endif
-  // read data from file and fill the result
-  tsdbCloseDBF(&tReadH.dFile);
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t tsdbCreateTSma(STsdb *pTsdb, char *pMsg) {
-  SSmaCfg vCreateSmaReq = {0};
-  if (!tDeserializeSVCreateTSmaReq(pMsg, &vCreateSmaReq)) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tsdbWarn("vgId:%d tsma create msg received but deserialize failed since %s", REPO_ID(pTsdb), terrstr(terrno));
-    return -1;
-  }
-
-  tsdbDebug("vgId:%d tsma create msg %s:%" PRIi64 " for table %" PRIi64 " received", REPO_ID(pTsdb),
-            vCreateSmaReq.tSma.indexName, vCreateSmaReq.tSma.indexUid, vCreateSmaReq.tSma.tableUid);
-
-  // record current timezone of server side
-  vCreateSmaReq.tSma.timezoneInt = tsTimezone;
-
-  if (metaCreateTSma(REPO_META(pTsdb), &vCreateSmaReq) < 0) {
-    // TODO: handle error
-    tsdbWarn("vgId:%d tsma %s:%" PRIi64 " create failed for table %" PRIi64 " since %s", REPO_ID(pTsdb),
-             vCreateSmaReq.tSma.indexName, vCreateSmaReq.tSma.indexUid, vCreateSmaReq.tSma.tableUid, terrstr(terrno));
-    tdDestroyTSma(&vCreateSmaReq.tSma);
-    return -1;
-  }
-
-  tsdbTSmaAdd(pTsdb, 1);
-
-  tdDestroyTSma(&vCreateSmaReq.tSma);
-  // TODO: return directly or go on follow steps?
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t tsdbDropTSma(STsdb *pTsdb, char *pMsg) {
-  SVDropTSmaReq vDropSmaReq = {0};
-  if (!tDeserializeSVDropTSmaReq(pMsg, &vDropSmaReq)) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
-  }
-
-  // TODO: send msg to stream computing to drop tSma
-  // if ((send msg to stream computing) < 0) {
-  //   tdDestroyTSma(&vCreateSmaReq);
-  //   return -1;
-  // }
-  //
-
-  if (metaDropTSma(REPO_META(pTsdb), vDropSmaReq.indexUid) < 0) {
-    // TODO: handle error
-    return -1;
-  }
-
-  if (tsdbDropTSmaData(pTsdb, vDropSmaReq.indexUid) < 0) {
-    // TODO: handle error
-    return -1;
-  }
-
-  tsdbTSmaSub(pTsdb, 1);
-
-  // TODO: return directly or go on follow steps?
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Check and init qTaskInfo_t, only applicable to stable with SRSmaParam.
- *
- * @param pTsdb
- * @param pMeta
- * @param pReq
- * @return int32_t
- */
-int32_t tsdbRegisterRSma(STsdb *pTsdb, SMeta *pMeta, SVCreateStbReq *pReq, SMsgCb *pMsgCb) {
-  if (!pReq->rollup) {
-    tsdbDebug("vgId:%d return directly since no rollup for stable %s %" PRIi64, REPO_ID(pTsdb), pReq->name, pReq->suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SRSmaParam *param = &pReq->pRSmaParam;
-
-  if ((param->qmsg1Len == 0) && (param->qmsg2Len == 0)) {
-    tsdbWarn("vgId:%d no qmsg1/qmsg2 for rollup stable %s %" PRIi64, REPO_ID(pTsdb), pReq->name, pReq->suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (tsdbCheckAndInitSmaEnv(pTsdb, TSDB_SMA_TYPE_ROLLUP) != TSDB_CODE_SUCCESS) {
-    terrno = TSDB_CODE_TDB_INIT_FAILED;
-    return TSDB_CODE_FAILED;
-  }
-
-  SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
-  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
-  SRSmaInfo *pRSmaInfo = NULL;
-
-  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), &pReq->suid, sizeof(tb_uid_t));
-  if (pRSmaInfo) {
-    tsdbWarn("vgId:%d rsma info already exists for stb: %s, %" PRIi64, REPO_ID(pTsdb), pReq->name, pReq->suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  pRSmaInfo = (SRSmaInfo *)taosMemoryCalloc(1, sizeof(SRSmaInfo));
-  if (!pRSmaInfo) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return TSDB_CODE_FAILED;
-  }
-
-  STqReadHandle *pReadHandle = tqInitSubmitMsgScanner(pMeta);
-  if (!pReadHandle) {
-    taosMemoryFree(pRSmaInfo);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return TSDB_CODE_FAILED;
-  }
-
-  SReadHandle handle = {
-      .reader = pReadHandle,
-      .meta = pMeta,
-      .pMsgCb = pMsgCb,
-  };
-
-  if (param->qmsg1) {
-    pRSmaInfo->taskInfo[0] = qCreateStreamExecTaskInfo(param->qmsg1, &handle);
-    if (!pRSmaInfo->taskInfo[0]) {
-      taosMemoryFree(pRSmaInfo);
-      taosMemoryFree(pReadHandle);
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  if (param->qmsg2) {
-    pRSmaInfo->taskInfo[1] = qCreateStreamExecTaskInfo(param->qmsg2, &handle);
-    if (!pRSmaInfo->taskInfo[1]) {
-      taosMemoryFree(pRSmaInfo);
-      taosMemoryFree(pReadHandle);
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  if (taosHashPut(SMA_STAT_INFO_HASH(pStat), &pReq->suid, sizeof(tb_uid_t), &pRSmaInfo, sizeof(pRSmaInfo)) !=
-      TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_FAILED;
-  } else {
-    tsdbDebug("vgId:%d register rsma info succeed for suid:%" PRIi64, REPO_ID(pTsdb), pReq->suid);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief store suid/[uids], prefer to use array and then hash
- *
- * @param pStore
- * @param suid
- * @param uid
- * @return int32_t
- */
-static int32_t tsdbUidStorePut(STbUidStore *pStore, tb_uid_t suid, tb_uid_t *uid) {
-  // prefer to store suid/uids in array
-  if ((suid == pStore->suid) || (pStore->suid == 0)) {
-    if (pStore->suid == 0) {
-      pStore->suid = suid;
-    }
-    if (uid) {
-      if (!pStore->tbUids) {
-        if (!(pStore->tbUids = taosArrayInit(1, sizeof(tb_uid_t)))) {
-          terrno = TSDB_CODE_OUT_OF_MEMORY;
-          return TSDB_CODE_FAILED;
-        }
-      }
-      if (!taosArrayPush(pStore->tbUids, uid)) {
-        return TSDB_CODE_FAILED;
-      }
-    }
-  } else {
-    // store other suid/uids in hash when multiple stable/table included in 1 batch of request
-    if (!pStore->uidHash) {
-      pStore->uidHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
-      if (!pStore->uidHash) {
-        return TSDB_CODE_FAILED;
-      }
-    }
-    if (uid) {
-      SArray *uidArray = taosHashGet(pStore->uidHash, &suid, sizeof(tb_uid_t));
-      if (uidArray && ((uidArray = *(SArray **)uidArray))) {
-        taosArrayPush(uidArray, uid);
-      } else {
-        SArray *pUidArray = taosArrayInit(1, sizeof(tb_uid_t));
-        if (!pUidArray) {
-          terrno = TSDB_CODE_OUT_OF_MEMORY;
-          return TSDB_CODE_FAILED;
-        }
-        if (!taosArrayPush(pUidArray, uid)) {
-          terrno = TSDB_CODE_OUT_OF_MEMORY;
-          return TSDB_CODE_FAILED;
-        }
-        if (taosHashPut(pStore->uidHash, &suid, sizeof(suid), &pUidArray, sizeof(pUidArray)) != 0) {
-          return TSDB_CODE_FAILED;
-        }
-      }
-    } else {
-      if (taosHashPut(pStore->uidHash, &suid, sizeof(suid), NULL, 0) != 0) {
-        return TSDB_CODE_FAILED;
-      }
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-void tsdbUidStoreDestory(STbUidStore *pStore) {
-  if (pStore) {
-    if (pStore->uidHash) {
-      if (pStore->tbUids) {
-        // When pStore->tbUids not NULL, the pStore->uidHash has k/v; otherwise pStore->uidHash only has keys.
-        void *pIter = taosHashIterate(pStore->uidHash, NULL);
-        while (pIter) {
-          SArray *arr = *(SArray **)pIter;
-          taosArrayDestroy(arr);
-          pIter = taosHashIterate(pStore->uidHash, pIter);
-        }
-      }
-      taosHashCleanup(pStore->uidHash);
-    }
-    taosArrayDestroy(pStore->tbUids);
-  }
-}
-
-void *tsdbUidStoreFree(STbUidStore *pStore) {
-  if (pStore) {
-    tsdbUidStoreDestory(pStore);
-    taosMemoryFree(pStore);
-  }
-  return NULL;
-}
-
-/**
- * @brief fetch suid/uids when create child tables of rollup SMA
- *
- * @param pTsdb
- * @param ppStore
- * @param suid
- * @param uid
- * @return int32_t
- */
-int32_t tsdbFetchTbUidList(STsdb *pTsdb, STbUidStore **ppStore, tb_uid_t suid, tb_uid_t uid) {
-  SSmaEnv *pEnv = REPO_RSMA_ENV((STsdb *)pTsdb);
-
-  // only applicable to rollup SMA ctables
-  if (!pEnv) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  SSmaStat *pStat = SMA_ENV_STAT(pEnv);
-  SHashObj *infoHash = NULL;
-  if (!pStat || !(infoHash = SMA_STAT_INFO_HASH(pStat))) {
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    return TSDB_CODE_FAILED;
-  }
-
-  // info cached when create rsma stable and return directly for non-rsma ctables
-  if (!taosHashGet(infoHash, &suid, sizeof(tb_uid_t))) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  ASSERT(ppStore != NULL);
-
-  if (!(*ppStore)) {
-    if (tsdbUidStoreInit(ppStore) != 0) {
-      return TSDB_CODE_FAILED;
-    }
-  }
-
-  if (tsdbUidStorePut(*ppStore, suid, &uid) != 0) {
-    *ppStore = tsdbUidStoreFree(*ppStore);
-    return TSDB_CODE_FAILED;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static FORCE_INLINE int32_t tsdbUpdateTbUidListImpl(STsdb *pTsdb, tb_uid_t *suid, SArray *tbUids) {
-  SSmaEnv   *pEnv = REPO_RSMA_ENV(pTsdb);
-  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
-  SRSmaInfo *pRSmaInfo = NULL;
-
-  if (!suid || !tbUids) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    tsdbError("vgId:%d failed to get rsma info for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
-    return TSDB_CODE_FAILED;
-  }
-
-  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), suid, sizeof(tb_uid_t));
-  if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
-    tsdbError("vgId:%d failed to get rsma info for uid:%" PRIi64, REPO_ID(pTsdb), *suid);
-    terrno = TSDB_CODE_TDB_INVALID_SMA_STAT;
-    return TSDB_CODE_FAILED;
-  }
-
-  if (pRSmaInfo->taskInfo[0] && (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[0], tbUids, true) != 0)) {
-    tsdbError("vgId:%d update tbUidList failed for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
-    return TSDB_CODE_FAILED;
-  } else {
-    tsdbDebug("vgId:%d update tbUidList succeed for qTaskInfo:%p with suid:%" PRIi64 ", uid:%" PRIi64, REPO_ID(pTsdb),
-              pRSmaInfo->taskInfo[0], *suid, *(int64_t *)taosArrayGet(tbUids, 0));
-  }
-
-  if (pRSmaInfo->taskInfo[1] && (qUpdateQualifiedTableId(pRSmaInfo->taskInfo[1], tbUids, true) != 0)) {
-    tsdbError("vgId:%d update tbUidList failed for uid:%" PRIi64 " since %s", REPO_ID(pTsdb), *suid, terrstr(terrno));
-    return TSDB_CODE_FAILED;
-  } else {
-    tsdbDebug("vgId:%d update tbUidList succeed for qTaskInfo:%p with suid:%" PRIi64 ", uid:%" PRIi64, REPO_ID(pTsdb),
-              pRSmaInfo->taskInfo[1], *suid, *(int64_t *)taosArrayGet(tbUids, 0));
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t tsdbUpdateTbUidList(STsdb *pTsdb, STbUidStore *pStore) {
-  if (!pStore || (taosArrayGetSize(pStore->tbUids) == 0)) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (tsdbUpdateTbUidListImpl(pTsdb, &pStore->suid, pStore->tbUids) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_FAILED;
-  }
-
-  void *pIter = taosHashIterate(pStore->uidHash, NULL);
-  while (pIter) {
-    tb_uid_t *pTbSuid = (tb_uid_t *)taosHashGetKey(pIter, NULL);
-    SArray   *pTbUids = *(SArray **)pIter;
-
-    if (tsdbUpdateTbUidListImpl(pTsdb, pTbSuid, pTbUids) != TSDB_CODE_SUCCESS) {
-      taosHashCancelIterate(pStore->uidHash, pIter);
-      return TSDB_CODE_FAILED;
-    }
-
-    pIter = taosHashIterate(pStore->uidHash, pIter);
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbProcessSubmitReq(STsdb *pTsdb, int64_t version, void *pReq) {
-  if (!pReq) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return TSDB_CODE_FAILED;
-  }
-
-  SSubmitReq *pSubmitReq = (SSubmitReq *)pReq;
-
-  if (tsdbInsertData(pTsdb, version, pSubmitReq, NULL) < 0) {
-    return TSDB_CODE_FAILED;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbFetchSubmitReqSuids(SSubmitReq *pMsg, STbUidStore *pStore) {
-  ASSERT(pMsg != NULL);
-  SSubmitMsgIter msgIter = {0};
-  SSubmitBlk    *pBlock = NULL;
-  SSubmitBlkIter blkIter = {0};
-  STSRow        *row = NULL;
-
-  terrno = TSDB_CODE_SUCCESS;
-
-  if (tInitSubmitMsgIter(pMsg, &msgIter) < 0) return -1;
-  while (true) {
-    if (tGetSubmitMsgNext(&msgIter, &pBlock) < 0) return -1;
-
-    if (!pBlock) break;
-    tsdbUidStorePut(pStore, msgIter.suid, NULL);
-    pStore->uid = msgIter.uid;  // TODO: remove, just for debugging
-  }
-
-  if (terrno != TSDB_CODE_SUCCESS) return -1;
-  return 0;
-}
-
-static FORCE_INLINE int32_t tsdbExecuteRSmaImpl(STsdb *pTsdb, const void *pMsg, int32_t inputType,
-                                                qTaskInfo_t *taskInfo, STSchema *pTSchema, tb_uid_t suid, tb_uid_t uid,
-                                                int8_t level) {
-  SArray *pResult = NULL;
-
-  if (!taskInfo) {
-    tsdbDebug("vgId:%d no qTaskInfo to execute rsma %" PRIi8 " task for suid:%" PRIu64, REPO_ID(pTsdb), level, suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  tsdbDebug("vgId:%d execute rsma %" PRIi8 " task for qTaskInfo:%p suid:%" PRIu64, REPO_ID(pTsdb), level, taskInfo,
-            suid);
-
-  qSetStreamInput(taskInfo, pMsg, inputType, false);
-  while (1) {
-    SSDataBlock *output = NULL;
-    uint64_t     ts;
-    if (qExecTask(taskInfo, &output, &ts) < 0) {
-      ASSERT(false);
-    }
-    if (!output) {
-      break;
-    }
-    if (!pResult) {
-      pResult = taosArrayInit(0, sizeof(SSDataBlock));
-      if (!pResult) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
-        return TSDB_CODE_FAILED;
-      }
-    }
-
-    taosArrayPush(pResult, output);
-  }
-
-  if (taosArrayGetSize(pResult) > 0) {
-    blockDebugShowData(pResult);
-    STsdb      *sinkTsdb = (level == TSDB_RETENTION_L1 ? pTsdb->pVnode->pRSma1 : pTsdb->pVnode->pRSma2);
-    SSubmitReq *pReq = NULL;
-    if (buildSubmitReqFromDataBlock(&pReq, pResult, pTSchema, TD_VID(pTsdb->pVnode), suid) != 0) {
-      taosArrayDestroy(pResult);
-      return TSDB_CODE_FAILED;
-    }
-    if (tsdbProcessSubmitReq(sinkTsdb, INT64_MAX, pReq) != 0) {
-      taosArrayDestroy(pResult);
-      taosMemoryFreeClear(pReq);
-      return TSDB_CODE_FAILED;
-    }
-    taosMemoryFreeClear(pReq);
-  } else {
-    tsdbWarn("vgId:%d no rsma % " PRIi8 " data generated since %s", REPO_ID(pTsdb), level, tstrerror(terrno));
-  }
-
-  taosArrayDestroy(pResult);
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t tsdbExecuteRSma(STsdb *pTsdb, const void *pMsg, int32_t inputType, tb_uid_t suid, tb_uid_t uid) {
-  SSmaEnv *pEnv = REPO_RSMA_ENV(pTsdb);
-  if (!pEnv) {
-    // only applicable when rsma env exists
-    return TSDB_CODE_SUCCESS;
-  }
-
-  ASSERT(uid != 0);  // TODO: remove later
-
-  SSmaStat  *pStat = SMA_ENV_STAT(pEnv);
-  SRSmaInfo *pRSmaInfo = NULL;
-
-  pRSmaInfo = taosHashGet(SMA_STAT_INFO_HASH(pStat), &suid, sizeof(tb_uid_t));
-
-  if (!pRSmaInfo || !(pRSmaInfo = *(SRSmaInfo **)pRSmaInfo)) {
-    tsdbDebug("vgId:%d no rsma info for suid:%" PRIu64, REPO_ID(pTsdb), suid);
-    return TSDB_CODE_SUCCESS;
-  }
-  if (!pRSmaInfo->taskInfo[0]) {
-    tsdbDebug("vgId:%d no rsma qTaskInfo for suid:%" PRIu64, REPO_ID(pTsdb), suid);
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-    // TODO: use the proper schema instead of 1, and cache STSchema in cache
-    STSchema *pTSchema = metaGetTbTSchema(pTsdb->pVnode->pMeta, suid, 1);
-    if (!pTSchema) {
-      terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
-      return TSDB_CODE_FAILED;
-    }
-    tsdbExecuteRSmaImpl(pTsdb, pMsg, inputType, pRSmaInfo->taskInfo[0], pTSchema, suid, uid, TSDB_RETENTION_L1);
-    tsdbExecuteRSmaImpl(pTsdb, pMsg, inputType, pRSmaInfo->taskInfo[1], pTSchema, suid, uid, TSDB_RETENTION_L2);
-    taosMemoryFree(pTSchema);
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t tsdbTriggerRSma(STsdb *pTsdb, void *pMsg, int32_t inputType) {
-  SSmaEnv *pEnv = REPO_RSMA_ENV(pTsdb);
-  if (!pEnv) {
-    // only applicable when rsma env exists
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (inputType == STREAM_DATA_TYPE_SUBMIT_BLOCK) {
-    STbUidStore uidStore = {0};
-    tsdbFetchSubmitReqSuids(pMsg, &uidStore);
-
-    if (uidStore.suid != 0) {
-      tsdbExecuteRSma(pTsdb, pMsg, inputType, uidStore.suid, uidStore.uid);
-
-      void *pIter = taosHashIterate(uidStore.uidHash, NULL);
-      while (pIter) {
-        tb_uid_t *pTbSuid = (tb_uid_t *)taosHashGetKey(pIter, NULL);
-        tsdbExecuteRSma(pTsdb, pMsg, inputType, *pTbSuid, 0);
-        pIter = taosHashIterate(uidStore.uidHash, pIter);
-      }
-
-      tsdbUidStoreDestory(&uidStore);
-    }
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-#if 0
-/**
- * @brief Get the start TS key of the last data block of one interval/sliding.
- *
- * @param pTsdb
- * @param param
- * @param result
- * @return int32_t
- *         1) Return 0 and fill the result if the check procedure is normal;
- *         2) Return -1 if error occurs during the check procedure.
- */
-int32_t tsdbGetTSmaStatus(STsdb *pTsdb, void *smaIndex, void *result) {
-  const char *procedure = "";
-  if (strncmp(procedure, "get the start TS key of the last data block", 100) != 0) {
-    return -1;
-  }
-  // fill the result
-  return TSDB_CODE_SUCCESS;
-}
-
-/**
- * @brief Remove the tSma data files related to param between pWin.
- *
- * @param pTsdb
- * @param param
- * @param pWin
- * @return int32_t
- */
-int32_t tsdbRemoveTSmaData(STsdb *pTsdb, void *smaIndex, STimeWindow *pWin) {
-  // for ("tSmaFiles of param-interval-sliding between pWin") {
-  //   // remove the tSmaFile
-  // }
-  return TSDB_CODE_SUCCESS;
-}
-#endif
-
-// TODO: Who is responsible for resource allocate and release?
-int32_t tsdbInsertTSmaData(STsdb *pTsdb, int64_t indexUid, const char *msg) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbInsertTSmaDataImpl(pTsdb, indexUid, msg)) < 0) {
-    tsdbWarn("vgId:%d insert tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  // TODO: destroy SSDataBlocks(msg)
-  return code;
-}
-
-int32_t tsdbUpdateSmaWindow(STsdb *pTsdb, SSubmitReq *pMsg, int64_t version) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbUpdateExpiredWindowImpl(pTsdb, pMsg, version)) < 0) {
-    tsdbWarn("vgId:%d update expired sma window failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  return code;
-}
-
-int32_t tsdbInsertRSmaData(STsdb *pTsdb, char *msg) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbInsertRSmaDataImpl(pTsdb, msg)) < 0) {
-    tsdbWarn("vgId:%d insert rSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  return code;
-}
-
-int32_t tsdbGetTSmaData(STsdb *pTsdb, char *pData, int64_t indexUid, TSKEY querySKey, int32_t nMaxResult) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbGetTSmaDataImpl(pTsdb, pData, indexUid, querySKey, nMaxResult)) < 0) {
-    tsdbWarn("vgId:%d get tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  return code;
-}
-
-int32_t tsdbDropTSmaData(STsdb *pTsdb, int64_t indexUid) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  if ((code = tsdbDropTSmaDataImpl(pTsdb, indexUid)) < 0) {
-    tsdbWarn("vgId:%d drop tSma data failed since %s", REPO_ID(pTsdb), tstrerror(terrno));
-  }
-  return code;
-}
\ No newline at end of file

source/dnode/vnode/src/tsdb/tsdbTDBImpl.c

-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define ALLOW_FORBID_FUNC
-
-#include "tsdb.h"
-
-int32_t tsdbOpenDBEnv(TDB **ppEnv, const char *path) {
-  int ret = 0;
-
-  if (path == NULL) return -1;
-
-  ret = tdbOpen(path, 4096, 256, ppEnv);  // use as param
-
-  if (ret != 0) {
-    tsdbError("Failed to create tsdb db env, ret = %d", ret);
-    return -1;
-  }
-
-  return 0;
-}
-
-int32_t tsdbCloseDBEnv(TDB *pEnv) { return tdbClose(pEnv); }
-
-static inline int tsdbSmaKeyCmpr(const void *arg1, int len1, const void *arg2, int len2) {
-  const SSmaKey *pKey1 = (const SSmaKey *)arg1;
-  const SSmaKey *pKey2 = (const SSmaKey *)arg2;
-
-  ASSERT(len1 == len2 && len1 == sizeof(SSmaKey));
-
-  if (pKey1->skey < pKey2->skey) {
-    return -1;
-  } else if (pKey1->skey > pKey2->skey) {
-    return 1;
-  }
-  if (pKey1->groupId < pKey2->groupId) {
-    return -1;
-  } else if (pKey1->groupId > pKey2->groupId) {
-    return 1;
-  }
-
-  return 0;
-}
-
-static int32_t tsdbOpenDBDb(TTB **ppDB, TDB *pEnv, const char *pFName) {
-  int           ret;
-  tdb_cmpr_fn_t compFunc;
-
-  // Create a database
-  compFunc = tsdbSmaKeyCmpr;
-  ret = tdbTbOpen(pFName, -1, -1, compFunc, pEnv, ppDB);
-
-  return 0;
-}
-
-static int32_t tsdbCloseDBDb(TTB *pDB) { return tdbTbClose(pDB); }
-
-int32_t tsdbOpenDBF(TDB *pEnv, SDBFile *pDBF) {
-  // TEnv is shared by a group of SDBFile
-  if (!pEnv || !pDBF) {
-    terrno = TSDB_CODE_INVALID_PTR;
-    return -1;
-  }
-
-  // Open DBF
-  if (tsdbOpenDBDb(&(pDBF->pDB), pEnv, pDBF->path) < 0) {
-    terrno = TSDB_CODE_TDB_INIT_FAILED;
-    tsdbCloseDBDb(pDBF->pDB);
-    return -1;
-  }
-
-  return 0;
-}
-
-int32_t tsdbCloseDBF(SDBFile *pDBF) {
-  int32_t ret = 0;
-  if (pDBF->pDB) {
-    ret = tsdbCloseDBDb(pDBF->pDB);
-    pDBF->pDB = NULL;
-  }
-  taosMemoryFreeClear(pDBF->path);
-  return ret;
-}
-
-int32_t tsdbSaveSmaToDB(SDBFile *pDBF, void *pKey, int32_t keyLen, void *pVal, int32_t valLen, TXN *txn) {
-  int32_t ret;
-
-  ret = tdbTbInsert(pDBF->pDB, pKey, keyLen, pVal, valLen, txn);
-  if (ret < 0) {
-    tsdbError("Failed to create insert sma data into db, ret = %d", ret);
-    return -1;
-  }
-
-  return 0;
-}
-
-void *tsdbGetSmaDataByKey(SDBFile *pDBF, const void *pKey, int32_t keyLen, int32_t *valLen) {
-  void *pVal = NULL;
-  int   ret;
-
-  ret = tdbTbGet(pDBF->pDB, pKey, keyLen, &pVal, valLen);
-
-  if (ret < 0) {
-    tsdbError("Failed to get sma data from db, ret = %d", ret);
-    return NULL;
-  }
-
-  ASSERT(*valLen >= 0);
-
-  // TODO: lock?
-  // TODO: Would the key/value be destoryed during return the data?
-  // TODO: How about the key is updated while value length is changed? The original value buffer would be freed
-  // automatically?
-
-  return pVal;
-}
\ No newline at end of file

source/dnode/vnode/src/vnd/vnodeOpen.c

@@ -189,4 +189,4 @@ void vnodeStop(SVnode *pVnode) {}
 
 int64_t vnodeGetSyncHandle(SVnode *pVnode) { return pVnode->sync; }
 
-void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot) { pSnapshot->lastApplyIndex = pVnode->state.committed; }
\ No newline at end of file
+void vnodeGetSnapshot(SVnode *pVnode, SSnapshot *pSnapshot) { pSnapshot->lastApplyIndex = pVnode->state.committed; }

source/dnode/vnode/src/vnd/vnodeSvr.c

@@ -22,7 +22,7 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pReq,
 static int vnodeProcessAlterTbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int vnodeProcessDropTbReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 static int vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
-static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq, int len, SRpcMsg *pRsp);
+static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp);
 
 int32_t vnodePreprocessReq(SVnode *pVnode, SRpcMsg *pMsg) {
   SDecoder dc = {0};
@@ -88,6 +88,9 @@ int32_t vnodePreprocessReq(SVnode *pVnode, SRpcMsg *pMsg) {
       }
 
     } break;
+    case TDMT_VND_ALTER_REPLICA: {
+      vnodeSyncAlter(pVnode, pMsg);
+    } break;
     default:
       break;
   }
@@ -154,7 +157,7 @@ int vnodeProcessWriteReq(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRpcMsg
                               pMsg->contLen - sizeof(SMsgHead)) < 0) {
       }
     } break;
-    case TDMT_VND_ALTER_VNODE:
+    case TDMT_VND_ALTER_CONFIG:
       break;
     default:
       ASSERT(0);
@@ -783,7 +786,7 @@ _exit:
   return 0;
 }
 
-static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq, int len, SRpcMsg *pRsp) {
+static int vnodeProcessCreateTSmaReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) {
   SVCreateTSmaReq req = {0};
   SDecoder        coder;
 

source/dnode/vnode/src/vnd/vnodeSync.c

@@ -27,6 +27,7 @@ static int32_t   vnodeSyncGetSnapshot(SSyncFSM *pFsm, SSnapshot *pSnapshot);
 int32_t vnodeSyncOpen(SVnode *pVnode, char *path) {
   SSyncInfo syncInfo = {
       .vgId = pVnode->config.vgId,
+      .isStandBy = pVnode->config.standby,
       .syncCfg = pVnode->config.syncCfg,
       .pWal = pVnode->pWal,
       .msgcb = NULL,
@@ -49,28 +50,72 @@ int32_t vnodeSyncOpen(SVnode *pVnode, char *path) {
   return 0;
 }
 
+void vnodeSyncAlter(SVnode *pVnode, SRpcMsg *pMsg) {
+  SAlterVnodeReq req = {0};
+  if (tDeserializeSAlterVnodeReq((char *)pMsg->pCont + sizeof(SMsgHead), pMsg->contLen - sizeof(SMsgHead), &req) != 0) {
+    terrno = TSDB_CODE_INVALID_MSG;
+    vError("vgId:%d, failed to alter replica since %s", TD_VID(pVnode), terrstr());
+    SRpcMsg rsp = {.info = pMsg->info, .code = terrno};
+    tmsgSendRsp(&rsp);
+  }
+
+  vInfo("vgId:%d, start to alter vnode replica to %d", TD_VID(pVnode), req.replica);
+  SSyncCfg cfg = {.replicaNum = req.replica, .myIndex = req.selfIndex};
+  for (int32_t r = 0; r < req.replica; ++r) {
+    SNodeInfo *pNode = &cfg.nodeInfo[r];
+    tstrncpy(pNode->nodeFqdn, req.replicas[r].fqdn, sizeof(pNode->nodeFqdn));
+    pNode->nodePort = req.replicas[r].port;
+    vInfo("vgId:%d, replica:%d %s:%u", TD_VID(pVnode), r, pNode->nodeFqdn, pNode->nodePort);
+  }
+
+  if (syncReconfig(pVnode->sync, &cfg) != 0) {
+    vError("vgId:%d, failed to propose sync reconfig since %s", TD_VID(pVnode), terrstr());
+    SRpcMsg rsp = {.info = pMsg->info, .code = terrno};
+    tmsgSendRsp(&rsp);
+  }
+}
+
 void vnodeSyncStart(SVnode *pVnode) {
   syncSetMsgCb(pVnode->sync, &pVnode->msgCb);
-  syncStart(pVnode->sync);
+  if (pVnode->config.standby) {
+    syncStartStandBy(pVnode->sync);
+  } else {
+    syncStart(pVnode->sync);
+  }
 }
 
 void vnodeSyncClose(SVnode *pVnode) { syncStop(pVnode->sync); }
 
-int32_t vnodeSyncEqMsg(const SMsgCb *msgcb, SRpcMsg *pMsg) { 
+int32_t vnodeSyncEqMsg(const SMsgCb *msgcb, SRpcMsg *pMsg) {
   int32_t code = tmsgPutToQueue(msgcb, SYNC_QUEUE, pMsg);
   if (code != 0) {
     rpcFreeCont(pMsg->pCont);
+    pMsg->pCont = NULL;
   }
   return code;
 }
 
-int32_t vnodeSyncSendMsg(const SEpSet *pEpSet, SRpcMsg *pMsg) { return tmsgSendReq(pEpSet, pMsg); }
+int32_t vnodeSyncSendMsg(const SEpSet *pEpSet, SRpcMsg *pMsg) {
+  int32_t code = tmsgSendReq(pEpSet, pMsg);
+  if (code != 0) {
+    rpcFreeCont(pMsg->pCont);
+    pMsg->pCont = NULL;
+  }
+  return code;
+}
 
 int32_t vnodeSyncGetSnapshot(SSyncFSM *pFsm, SSnapshot *pSnapshot) {
   vnodeGetSnapshot(pFsm->data, pSnapshot);
   return 0;
 }
 
+void vnodeSyncReconfig(struct SSyncFSM *pFsm, SSyncCfg newCfg, SReConfigCbMeta cbMeta) {
+  SVnode *pVnode = pFsm->data;
+  vInfo("vgId:%d, sync reconfig is confirmed", TD_VID(pVnode));
+
+  // todo rpc response here
+}
+
 void vnodeSyncCommitMsg(SSyncFSM *pFsm, const SRpcMsg *pMsg, SFsmCbMeta cbMeta) {
   SyncIndex beginIndex = SYNC_INDEX_INVALID;
   if (pFsm->FpGetSnapshot != NULL) {
@@ -87,20 +132,12 @@ void vnodeSyncCommitMsg(SSyncFSM *pFsm, const SRpcMsg *pMsg, SFsmCbMeta cbMeta)
         pFsm, cbMeta.index, cbMeta.isWeak, cbMeta.code, cbMeta.state, syncUtilState2String(cbMeta.state), beginIndex);
     syncRpcMsgLog2(logBuf, (SRpcMsg *)pMsg);
 
-    SVnode       *pVnode = (SVnode *)(pFsm->data);
+    SVnode       *pVnode = pFsm->data;
     SyncApplyMsg *pSyncApplyMsg = syncApplyMsgBuild2(pMsg, pVnode->config.vgId, &cbMeta);
     SRpcMsg       applyMsg;
     syncApplyMsg2RpcMsg(pSyncApplyMsg, &applyMsg);
     syncApplyMsgDestroy(pSyncApplyMsg);
 
-    /*
-        SRpcMsg applyMsg;
-        applyMsg = *pMsg;
-        applyMsg.pCont = rpcMallocCont(applyMsg.contLen);
-        assert(applyMsg.contLen == pMsg->contLen);
-        memcpy(applyMsg.pCont, pMsg->pCont, applyMsg.contLen);
-    */
-
     // recover handle for response
     SRpcMsg saveRpcMsg;
     int32_t ret = syncGetAndDelRespRpc(pVnode->sync, cbMeta.seqNum, &saveRpcMsg);
@@ -142,14 +179,13 @@ void vnodeSyncRollBackMsg(SSyncFSM *pFsm, const SRpcMsg *pMsg, SFsmCbMeta cbMeta
 
 SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
   SSyncFSM *pFsm = taosMemoryCalloc(1, sizeof(SSyncFSM));
-  memset(pFsm, 0, sizeof(*pFsm));
   pFsm->data = pVnode;
   pFsm->FpCommitCb = vnodeSyncCommitMsg;
   pFsm->FpPreCommitCb = vnodeSyncPreCommitMsg;
   pFsm->FpRollBackCb = vnodeSyncRollBackMsg;
   pFsm->FpGetSnapshot = vnodeSyncGetSnapshot;
   pFsm->FpRestoreFinishCb = NULL;
-  pFsm->FpReConfigCb = NULL;
+  pFsm->FpReConfigCb = vnodeSyncReconfig;
 
   return pFsm;
 }
\ No newline at end of file

source/libs/parser/inc/sql.y

@@ -15,11 +15,15 @@
 #include <assert.h>
 #include <stdbool.h>
 
+#define ALLOW_FORBID_FUNC
+
 #include "functionMgt.h"
 #include "nodes.h"
 #include "parToken.h"
 #include "ttokendef.h"
 #include "parAst.h"
+
+#define YYSTACKDEPTH 0
 }
 
 %syntax_error {

source/libs/parser/src/parInsert.c

@@ -780,8 +780,8 @@ static void buildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTa
   return;
 }
 
-static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema,
-                             int16_t timePrec, STagVal *val, SMsgBuf* pMsgBuf) {
+static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, STagVal* val,
+                             SMsgBuf* pMsgBuf) {
   int64_t  iv;
   uint64_t uv;
   char*    endptr = NULL;
@@ -937,8 +937,8 @@ static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema,
 
     case TSDB_DATA_TYPE_NCHAR: {
       int32_t output = 0;
-      void *p = taosMemoryCalloc(1, pToken->n * TSDB_NCHAR_SIZE);
-      if(p == NULL){
+      void*   p = taosMemoryCalloc(1, pToken->n * TSDB_NCHAR_SIZE);
+      if (p == NULL) {
         return TSDB_CODE_OUT_OF_MEMORY;
       }
       if (!taosMbsToUcs4(pToken->z, pToken->n, (TdUcs4*)(p), pSchema->bytes - VARSTR_HEADER_SIZE, &output)) {
@@ -971,11 +971,11 @@ static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema,
 // pSql -> tag1_value, ...)
 static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint8_t precision, const char* tName) {
   int32_t code = TSDB_CODE_SUCCESS;
-  SArray *pTagVals = taosArrayInit(pCxt->tags.numOfBound, sizeof(STagVal));
-  SToken   sToken;
-  bool     isParseBindParam = false;
-  bool isJson = false;
-  STag* pTag = NULL;
+  SArray* pTagVals = taosArrayInit(pCxt->tags.numOfBound, sizeof(STagVal));
+  SToken  sToken;
+  bool    isParseBindParam = false;
+  bool    isJson = false;
+  STag*   pTag = NULL;
   for (int i = 0; i < pCxt->tags.numOfBound; ++i) {
     NEXT_TOKEN_WITH_PREV(pCxt->pSql, sToken);
 
@@ -995,13 +995,13 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
     }
 
     SSchema* pTagSchema = &pSchema[pCxt->tags.boundColumns[i]];
-    char *tmpTokenBuf = taosMemoryCalloc(1, sToken.n); // this can be optimize with parse column
+    char*    tmpTokenBuf = taosMemoryCalloc(1, sToken.n);  // this can be optimize with parse column
     code = checkAndTrimValue(&sToken, tmpTokenBuf, &pCxt->msg);
     if (code != TSDB_CODE_SUCCESS) {
       taosMemoryFree(tmpTokenBuf);
       goto end;
     }
-    if(pTagSchema->type == TSDB_DATA_TYPE_JSON){
+    if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
       if (sToken.n > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
         code = buildSyntaxErrMsg(&pCxt->msg, "json string too long than 4095", sToken.z);
         taosMemoryFree(tmpTokenBuf);
@@ -1009,18 +1009,18 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
       }
       code = parseJsontoTagData(sToken.z, pTagVals, &pTag, &pCxt->msg);
       taosMemoryFree(tmpTokenBuf);
-      if(code != TSDB_CODE_SUCCESS){
+      if (code != TSDB_CODE_SUCCESS) {
         goto end;
       }
       isJson = true;
-    }else{
+    } else {
       STagVal val = {0};
       code = parseTagToken(&pCxt->pSql, &sToken, pTagSchema, precision, &val, &pCxt->msg);
       if (TSDB_CODE_SUCCESS != code) {
         taosMemoryFree(tmpTokenBuf);
         goto end;
       }
-      if (pTagSchema->type != TSDB_DATA_TYPE_BINARY){
+      if (pTagSchema->type != TSDB_DATA_TYPE_BINARY) {
         taosMemoryFree(tmpTokenBuf);
       }
       taosArrayPush(pTagVals, &val);
@@ -1032,7 +1032,7 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
     goto end;
   }
 
-  if(!isJson && (code = tTagNew(pTagVals, 1, false, &pTag)) != TSDB_CODE_SUCCESS) {
+  if (!isJson && (code = tTagNew(pTagVals, 1, false, &pTag)) != TSDB_CODE_SUCCESS) {
     goto end;
   }
 
@@ -1040,8 +1040,8 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
 
 end:
   for (int i = 0; i < taosArrayGetSize(pTagVals); ++i) {
-    STagVal *p = (STagVal *)taosArrayGet(pTagVals, i);
-    if(IS_VAR_DATA_TYPE(p->type)){
+    STagVal* p = (STagVal*)taosArrayGet(pTagVals, i);
+    if (IS_VAR_DATA_TYPE(p->type)) {
       taosMemoryFree(p->pData);
     }
   }
@@ -1701,10 +1701,10 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
     return buildInvalidOperationMsg(&pBuf, "out of memory");
   }
 
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t  code = TSDB_CODE_SUCCESS;
   SSchema* pSchema = pDataBlock->pTableMeta->schema;
 
-  bool isJson = false;
+  bool  isJson = false;
   STag* pTag = NULL;
 
   for (int c = 0; c < tags->numOfBound; ++c) {
@@ -1713,7 +1713,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
     }
 
     SSchema* pTagSchema = &pSchema[tags->boundColumns[c]];
-    int32_t colLen = pTagSchema->bytes;
+    int32_t  colLen = pTagSchema->bytes;
     if (IS_VAR_DATA_TYPE(pTagSchema->type)) {
       colLen = bind[c].length[0];
     }
@@ -1724,22 +1724,22 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
       }
 
       isJson = true;
-      char *tmp = taosMemoryCalloc(1, colLen + 1);
+      char* tmp = taosMemoryCalloc(1, colLen + 1);
       memcpy(tmp, bind[c].buffer, colLen);
       code = parseJsontoTagData(tmp, pTagArray, &pTag, &pBuf);
       taosMemoryFree(tmp);
-      if(code != TSDB_CODE_SUCCESS){
+      if (code != TSDB_CODE_SUCCESS) {
         goto end;
       }
-    }else{
+    } else {
       STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};
-      if(pTagSchema->type == TSDB_DATA_TYPE_BINARY){
+      if (pTagSchema->type == TSDB_DATA_TYPE_BINARY) {
         val.pData = (uint8_t*)bind[c].buffer;
         val.nData = colLen;
-      }else if(pTagSchema->type == TSDB_DATA_TYPE_NCHAR){
+      } else if (pTagSchema->type == TSDB_DATA_TYPE_NCHAR) {
         int32_t output = 0;
-        void *p = taosMemoryCalloc(1, colLen * TSDB_NCHAR_SIZE);
-        if(p == NULL){
+        void*   p = taosMemoryCalloc(1, colLen * TSDB_NCHAR_SIZE);
+        if (p == NULL) {
           code = TSDB_CODE_OUT_OF_MEMORY;
           goto end;
         }
@@ -1757,7 +1757,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
         }
         val.pData = p;
         val.nData = output;
-      }else{
+      } else {
         memcpy(&val.i64, bind[c].buffer, colLen);
       }
       taosArrayPush(pTagArray, &val);
@@ -1775,8 +1775,8 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, char* tN
 
 end:
   for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) {
-    STagVal *p = (STagVal *)taosArrayGet(pTagArray, i);
-    if(p->type == TSDB_DATA_TYPE_NCHAR){
+    STagVal* p = (STagVal*)taosArrayGet(pTagArray, i);
+    if (p->type == TSDB_DATA_TYPE_NCHAR) {
       taosMemoryFree(p->pData);
     }
   }
@@ -1951,7 +1951,8 @@ int32_t qBindStmtSingleColValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBu
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t buildBoundFields(SParsedDataColInfo* boundInfo, SSchema* pSchema, int32_t* fieldNum, TAOS_FIELD_E** fields, uint8_t timePrec) {
+int32_t buildBoundFields(SParsedDataColInfo* boundInfo, SSchema* pSchema, int32_t* fieldNum, TAOS_FIELD_E** fields,
+                         uint8_t timePrec) {
   if (fields) {
     *fields = taosMemoryCalloc(boundInfo->numOfBound, sizeof(TAOS_FIELD));
     if (NULL == *fields) {
@@ -1962,7 +1963,7 @@ int32_t buildBoundFields(SParsedDataColInfo* boundInfo, SSchema* pSchema, int32_
     if (TSDB_DATA_TYPE_TIMESTAMP == schema->type) {
       (*fields)[0].precision = timePrec;
     }
-    
+
     for (int32_t i = 0; i < boundInfo->numOfBound; ++i) {
       schema = &pSchema[boundInfo->boundColumns[i]];
       strcpy((*fields)[i].name, schema->name);
@@ -2008,7 +2009,8 @@ int32_t qBuildStmtColFields(void* pBlock, int32_t* fieldNum, TAOS_FIELD_E** fiel
     return TSDB_CODE_SUCCESS;
   }
 
-  CHECK_CODE(buildBoundFields(&pDataBlock->boundColumnInfo, pSchema, fieldNum, fields, pDataBlock->pTableMeta->tableInfo.precision));
+  CHECK_CODE(buildBoundFields(&pDataBlock->boundColumnInfo, pSchema, fieldNum, fields,
+                              pDataBlock->pTableMeta->tableInfo.precision));
 
   return TSDB_CODE_SUCCESS;
 }
@@ -2122,16 +2124,16 @@ static int32_t smlBuildTagRow(SArray* cols, SParsedDataColInfo* tags, SSchema* p
   int32_t code = TSDB_CODE_SUCCESS;
   for (int i = 0; i < tags->numOfBound; ++i) {
     SSchema* pTagSchema = &pSchema[tags->boundColumns[i]];
-    SSmlKv* kv = taosArrayGetP(cols, i);
+    SSmlKv*  kv = taosArrayGetP(cols, i);
 
     STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type};
-    if(pTagSchema->type == TSDB_DATA_TYPE_BINARY){
-      val.pData = (uint8_t *)kv->value;
+    if (pTagSchema->type == TSDB_DATA_TYPE_BINARY) {
+      val.pData = (uint8_t*)kv->value;
       val.nData = kv->length;
-    }else if(pTagSchema->type == TSDB_DATA_TYPE_NCHAR){
+    } else if (pTagSchema->type == TSDB_DATA_TYPE_NCHAR) {
       int32_t output = 0;
-      void *p = taosMemoryCalloc(1, pTagSchema->bytes - VARSTR_HEADER_SIZE);
-      if(p == NULL){
+      void*   p = taosMemoryCalloc(1, pTagSchema->bytes - VARSTR_HEADER_SIZE);
+      if (p == NULL) {
         code = TSDB_CODE_OUT_OF_MEMORY;
         goto end;
       }
@@ -2149,7 +2151,7 @@ static int32_t smlBuildTagRow(SArray* cols, SParsedDataColInfo* tags, SSchema* p
       }
       val.pData = p;
       val.nData = output;
-    }else{
+    } else {
       memcpy(&val.i64, &(kv->value), kv->length);
     }
     taosArrayPush(pTagArray, &val);
@@ -2158,8 +2160,8 @@ static int32_t smlBuildTagRow(SArray* cols, SParsedDataColInfo* tags, SSchema* p
   code = tTagNew(pTagArray, 1, false, ppTag);
 end:
   for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) {
-    STagVal *p = (STagVal *)taosArrayGet(pTagArray, i);
-    if(p->type == TSDB_DATA_TYPE_NCHAR){
+    STagVal* p = (STagVal*)taosArrayGet(pTagArray, i);
+    if (p->type == TSDB_DATA_TYPE_NCHAR) {
       taosMemoryFree(p->pData);
     }
   }

source/libs/parser/src/parser.c

@@ -76,28 +76,8 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
   int32_t inputSize = (NULL != pParam->length ? *(pParam->length) : tDataTypes[pParam->buffer_type].bytes);
   pVal->node.resType.type = pParam->buffer_type;
   pVal->node.resType.bytes = inputSize;
+  
   switch (pParam->buffer_type) {
-    case TSDB_DATA_TYPE_BOOL:
-      pVal->datum.b = *((bool*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_TINYINT:
-      pVal->datum.i = *((int8_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_SMALLINT:
-      pVal->datum.i = *((int16_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_INT:
-      pVal->datum.i = *((int32_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_BIGINT:
-      pVal->datum.i = *((int64_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_FLOAT:
-      pVal->datum.d = *((float*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_DOUBLE:
-      pVal->datum.d = *((double*)pParam->buffer);
-      break;
     case TSDB_DATA_TYPE_VARCHAR:
     case TSDB_DATA_TYPE_VARBINARY:
       pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1);
@@ -124,28 +104,13 @@ static int32_t setValueByBindParam(SValueNode* pVal, TAOS_MULTI_BIND* pParam) {
       pVal->node.resType.bytes = output + VARSTR_HEADER_SIZE;
       break;
     }
-    case TSDB_DATA_TYPE_TIMESTAMP:
-      pVal->datum.i = *((int64_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_UTINYINT:
-      pVal->datum.u = *((uint8_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_USMALLINT:
-      pVal->datum.u = *((uint16_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_UINT:
-      pVal->datum.u = *((uint32_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_UBIGINT:
-      pVal->datum.u = *((uint64_t*)pParam->buffer);
-      break;
-    case TSDB_DATA_TYPE_JSON:
-    case TSDB_DATA_TYPE_DECIMAL:
-    case TSDB_DATA_TYPE_BLOB:
-    case TSDB_DATA_TYPE_MEDIUMBLOB:
-      // todo
-    default:
+    default: {
+      int32_t code = nodesSetValueNodeValue(pVal, pParam->buffer);
+      if (code) {
+        return code;
+      }
       break;
+    }
   }
   pVal->translate = true;
   return TSDB_CODE_SUCCESS;

source/libs/parser/src/sql.c

@@ -32,11 +32,15 @@
 #include <assert.h>
 #include <stdbool.h>
 
+#define ALLOW_FORBID_FUNC
+
 #include "functionMgt.h"
 #include "nodes.h"
 #include "parToken.h"
 #include "ttokendef.h"
 #include "parAst.h"
+
+#define YYSTACKDEPTH 0
 /**************** End of %include directives **********************************/
 /* These constants specify the various numeric values for terminal symbols
 ** in a format understandable to "makeheaders".  This section is blank unless
@@ -136,6 +140,7 @@ typedef union {
 #define YYFALLBACK 1
 #define YYNSTATE             612
 #define YYNRULE              451
+#define YYNRULE_WITH_ACTION  451
 #define YYNTOKEN             237
 #define YY_MAX_SHIFT         611
 #define YY_MIN_SHIFTREDUCE   898
@@ -640,7 +645,31 @@ static const YYCODETYPE yy_lookahead[] = {
  /*  2090 */   357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
  /*  2100 */   328,  329,  330,  357,  332,  357,  357,  335,  357,  357,
  /*  2110 */   357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
- /*  2120 */   348,  357,  357,  357,  352,
+ /*  2120 */   348,  357,  357,  357,  352,  237,  237,  237,  237,  237,
+ /*  2130 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2140 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2150 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2160 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2170 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2180 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2190 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2200 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2210 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2220 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2230 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2240 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2250 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2260 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2270 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2280 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2290 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2300 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2310 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2320 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2330 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2340 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2350 */   237,  237,  237,  237,  237,  237,  237,  237,  237,  237,
+ /*  2360 */   237,  237,
 };
 #define YY_SHIFT_COUNT    (611)
 #define YY_SHIFT_MIN      (0)
@@ -2382,15 +2411,18 @@ static YYACTIONTYPE yy_find_shift_action(
   do{
     i = yy_shift_ofst[stateno];
     assert( i>=0 );
-    /* assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); */
+    assert( i<=YY_ACTTAB_COUNT );
+    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
     assert( iLookAhead!=YYNOCODE );
     assert( iLookAhead < YYNTOKEN );
     i += iLookAhead;
-    if( i>=YY_NLOOKAHEAD || yy_lookahead[i]!=iLookAhead ){
+    assert( i<(int)YY_NLOOKAHEAD );
+    if( yy_lookahead[i]!=iLookAhead ){
 #ifdef YYFALLBACK
       YYCODETYPE iFallback;            /* Fallback token */
-      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
-             && (iFallback = yyFallback[iLookAhead])!=0 ){
+      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
+      iFallback = yyFallback[iLookAhead];
+      if( iFallback!=0 ){
 #ifndef NDEBUG
         if( yyTraceFILE ){
           fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
@@ -2405,16 +2437,8 @@ static YYACTIONTYPE yy_find_shift_action(
 #ifdef YYWILDCARD
       {
         int j = i - iLookAhead + YYWILDCARD;
-        if( 
-#if YY_SHIFT_MIN+YYWILDCARD<0
-          j>=0 &&
-#endif
-#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
-          j<YY_ACTTAB_COUNT &&
-#endif
-          j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) &&
-          yy_lookahead[j]==YYWILDCARD && iLookAhead>0
-        ){
+        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
+        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
 #ifndef NDEBUG
           if( yyTraceFILE ){
             fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
@@ -2428,6 +2452,7 @@ static YYACTIONTYPE yy_find_shift_action(
 #endif /* YYWILDCARD */
       return yy_default[stateno];
     }else{
+      assert( i>=0 && i<sizeof(yy_action)/sizeof(yy_action[0]) );
       return yy_action[i];
     }
   }while(1);
@@ -2546,464 +2571,916 @@ static void yy_shift(
   yyTraceShift(yypParser, yyNewState, "Shift");
 }
 
-/* The following table contains information about every rule that
-** is used during the reduce.
-*/
-static const struct {
-  YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
-  signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
-} yyRuleInfo[] = {
-  {  237,   -6 }, /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
-  {  237,   -4 }, /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
-  {  238,    0 }, /* (2) account_options ::= */
-  {  238,   -3 }, /* (3) account_options ::= account_options PPS literal */
-  {  238,   -3 }, /* (4) account_options ::= account_options TSERIES literal */
-  {  238,   -3 }, /* (5) account_options ::= account_options STORAGE literal */
-  {  238,   -3 }, /* (6) account_options ::= account_options STREAMS literal */
-  {  238,   -3 }, /* (7) account_options ::= account_options QTIME literal */
-  {  238,   -3 }, /* (8) account_options ::= account_options DBS literal */
-  {  238,   -3 }, /* (9) account_options ::= account_options USERS literal */
-  {  238,   -3 }, /* (10) account_options ::= account_options CONNS literal */
-  {  238,   -3 }, /* (11) account_options ::= account_options STATE literal */
-  {  239,   -1 }, /* (12) alter_account_options ::= alter_account_option */
-  {  239,   -2 }, /* (13) alter_account_options ::= alter_account_options alter_account_option */
-  {  241,   -2 }, /* (14) alter_account_option ::= PASS literal */
-  {  241,   -2 }, /* (15) alter_account_option ::= PPS literal */
-  {  241,   -2 }, /* (16) alter_account_option ::= TSERIES literal */
-  {  241,   -2 }, /* (17) alter_account_option ::= STORAGE literal */
-  {  241,   -2 }, /* (18) alter_account_option ::= STREAMS literal */
-  {  241,   -2 }, /* (19) alter_account_option ::= QTIME literal */
-  {  241,   -2 }, /* (20) alter_account_option ::= DBS literal */
-  {  241,   -2 }, /* (21) alter_account_option ::= USERS literal */
-  {  241,   -2 }, /* (22) alter_account_option ::= CONNS literal */
-  {  241,   -2 }, /* (23) alter_account_option ::= STATE literal */
-  {  237,   -5 }, /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
-  {  237,   -5 }, /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
-  {  237,   -5 }, /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
-  {  237,   -3 }, /* (27) cmd ::= DROP USER user_name */
-  {  237,   -6 }, /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */
-  {  237,   -6 }, /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */
-  {  243,   -1 }, /* (30) privileges ::= ALL */
-  {  243,   -1 }, /* (31) privileges ::= priv_type_list */
-  {  245,   -1 }, /* (32) priv_type_list ::= priv_type */
-  {  245,   -3 }, /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */
-  {  246,   -1 }, /* (34) priv_type ::= READ */
-  {  246,   -1 }, /* (35) priv_type ::= WRITE */
-  {  244,   -3 }, /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */
-  {  244,   -3 }, /* (37) priv_level ::= db_name NK_DOT NK_STAR */
-  {  237,   -3 }, /* (38) cmd ::= CREATE DNODE dnode_endpoint */
-  {  237,   -5 }, /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
-  {  237,   -3 }, /* (40) cmd ::= DROP DNODE NK_INTEGER */
-  {  237,   -3 }, /* (41) cmd ::= DROP DNODE dnode_endpoint */
-  {  237,   -4 }, /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
-  {  237,   -5 }, /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
-  {  237,   -4 }, /* (44) cmd ::= ALTER ALL DNODES NK_STRING */
-  {  237,   -5 }, /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
-  {  248,   -1 }, /* (46) dnode_endpoint ::= NK_STRING */
-  {  249,   -1 }, /* (47) dnode_host_name ::= NK_ID */
-  {  249,   -1 }, /* (48) dnode_host_name ::= NK_IPTOKEN */
-  {  237,   -3 }, /* (49) cmd ::= ALTER LOCAL NK_STRING */
-  {  237,   -4 }, /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
-  {  237,   -5 }, /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
-  {  237,   -5 }, /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
-  {  237,   -4 }, /* (60) cmd ::= DROP DATABASE exists_opt db_name */
-  {  237,   -2 }, /* (61) cmd ::= USE db_name */
-  {  237,   -4 }, /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */
-  {  250,   -3 }, /* (63) not_exists_opt ::= IF NOT EXISTS */
-  {  250,    0 }, /* (64) not_exists_opt ::= */
-  {  252,   -2 }, /* (65) exists_opt ::= IF EXISTS */
-  {  252,    0 }, /* (66) exists_opt ::= */
-  {  251,    0 }, /* (67) db_options ::= */
-  {  251,   -3 }, /* (68) db_options ::= db_options BUFFER NK_INTEGER */
-  {  251,   -3 }, /* (69) db_options ::= db_options CACHELAST NK_INTEGER */
-  {  251,   -3 }, /* (70) db_options ::= db_options COMP NK_INTEGER */
-  {  251,   -3 }, /* (71) db_options ::= db_options DAYS NK_INTEGER */
-  {  251,   -3 }, /* (72) db_options ::= db_options DAYS NK_VARIABLE */
-  {  251,   -3 }, /* (73) db_options ::= db_options FSYNC NK_INTEGER */
-  {  251,   -3 }, /* (74) db_options ::= db_options MAXROWS NK_INTEGER */
-  {  251,   -3 }, /* (75) db_options ::= db_options MINROWS NK_INTEGER */
-  {  251,   -3 }, /* (76) db_options ::= db_options KEEP integer_list */
-  {  251,   -3 }, /* (77) db_options ::= db_options KEEP variable_list */
-  {  251,   -3 }, /* (78) db_options ::= db_options PAGES NK_INTEGER */
-  {  251,   -3 }, /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */
-  {  251,   -3 }, /* (80) db_options ::= db_options PRECISION NK_STRING */
-  {  251,   -3 }, /* (81) db_options ::= db_options REPLICA NK_INTEGER */
-  {  251,   -3 }, /* (82) db_options ::= db_options STRICT NK_INTEGER */
-  {  251,   -3 }, /* (83) db_options ::= db_options WAL NK_INTEGER */
-  {  251,   -3 }, /* (84) db_options ::= db_options VGROUPS NK_INTEGER */
-  {  251,   -3 }, /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
-  {  251,   -3 }, /* (86) db_options ::= db_options RETENTIONS retention_list */
-  {  251,   -3 }, /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */
-  {  253,   -1 }, /* (88) alter_db_options ::= alter_db_option */
-  {  253,   -2 }, /* (89) alter_db_options ::= alter_db_options alter_db_option */
-  {  257,   -2 }, /* (90) alter_db_option ::= BUFFER NK_INTEGER */
-  {  257,   -2 }, /* (91) alter_db_option ::= CACHELAST NK_INTEGER */
-  {  257,   -2 }, /* (92) alter_db_option ::= FSYNC NK_INTEGER */
-  {  257,   -2 }, /* (93) alter_db_option ::= KEEP integer_list */
-  {  257,   -2 }, /* (94) alter_db_option ::= KEEP variable_list */
-  {  257,   -2 }, /* (95) alter_db_option ::= PAGES NK_INTEGER */
-  {  257,   -2 }, /* (96) alter_db_option ::= REPLICA NK_INTEGER */
-  {  257,   -2 }, /* (97) alter_db_option ::= STRICT NK_INTEGER */
-  {  257,   -2 }, /* (98) alter_db_option ::= WAL NK_INTEGER */
-  {  254,   -1 }, /* (99) integer_list ::= NK_INTEGER */
-  {  254,   -3 }, /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */
-  {  255,   -1 }, /* (101) variable_list ::= NK_VARIABLE */
-  {  255,   -3 }, /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
-  {  256,   -1 }, /* (103) retention_list ::= retention */
-  {  256,   -3 }, /* (104) retention_list ::= retention_list NK_COMMA retention */
-  {  258,   -3 }, /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
-  {  237,   -9 }, /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
-  {  237,   -3 }, /* (107) cmd ::= CREATE TABLE multi_create_clause */
-  {  237,   -9 }, /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
-  {  237,   -3 }, /* (109) cmd ::= DROP TABLE multi_drop_clause */
-  {  237,   -4 }, /* (110) cmd ::= DROP STABLE exists_opt full_table_name */
-  {  237,   -3 }, /* (111) cmd ::= ALTER TABLE alter_table_clause */
-  {  237,   -3 }, /* (112) cmd ::= ALTER STABLE alter_table_clause */
-  {  266,   -2 }, /* (113) alter_table_clause ::= full_table_name alter_table_options */
-  {  266,   -5 }, /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
-  {  266,   -4 }, /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */
-  {  266,   -5 }, /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
-  {  266,   -5 }, /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
-  {  266,   -5 }, /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
-  {  266,   -4 }, /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */
-  {  266,   -5 }, /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
-  {  266,   -5 }, /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
-  {  266,   -6 }, /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
-  {  263,   -1 }, /* (123) multi_create_clause ::= create_subtable_clause */
-  {  263,   -2 }, /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */
-  {  271,  -10 }, /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */
-  {  265,   -1 }, /* (126) multi_drop_clause ::= drop_table_clause */
-  {  265,   -2 }, /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */
-  {  274,   -2 }, /* (128) drop_table_clause ::= exists_opt full_table_name */
-  {  272,    0 }, /* (129) specific_tags_opt ::= */
-  {  272,   -3 }, /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */
-  {  259,   -1 }, /* (131) full_table_name ::= table_name */
-  {  259,   -3 }, /* (132) full_table_name ::= db_name NK_DOT table_name */
-  {  260,   -1 }, /* (133) column_def_list ::= column_def */
-  {  260,   -3 }, /* (134) column_def_list ::= column_def_list NK_COMMA column_def */
-  {  277,   -2 }, /* (135) column_def ::= column_name type_name */
-  {  277,   -4 }, /* (136) column_def ::= column_name type_name COMMENT NK_STRING */
-  {  269,   -1 }, /* (137) type_name ::= BOOL */
-  {  269,   -1 }, /* (138) type_name ::= TINYINT */
-  {  269,   -1 }, /* (139) type_name ::= SMALLINT */
-  {  269,   -1 }, /* (140) type_name ::= INT */
-  {  269,   -1 }, /* (141) type_name ::= INTEGER */
-  {  269,   -1 }, /* (142) type_name ::= BIGINT */
-  {  269,   -1 }, /* (143) type_name ::= FLOAT */
-  {  269,   -1 }, /* (144) type_name ::= DOUBLE */
-  {  269,   -4 }, /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
-  {  269,   -1 }, /* (146) type_name ::= TIMESTAMP */
-  {  269,   -4 }, /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
-  {  269,   -2 }, /* (148) type_name ::= TINYINT UNSIGNED */
-  {  269,   -2 }, /* (149) type_name ::= SMALLINT UNSIGNED */
-  {  269,   -2 }, /* (150) type_name ::= INT UNSIGNED */
-  {  269,   -2 }, /* (151) type_name ::= BIGINT UNSIGNED */
-  {  269,   -1 }, /* (152) type_name ::= JSON */
-  {  269,   -4 }, /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
-  {  269,   -1 }, /* (154) type_name ::= MEDIUMBLOB */
-  {  269,   -1 }, /* (155) type_name ::= BLOB */
-  {  269,   -4 }, /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
-  {  269,   -1 }, /* (157) type_name ::= DECIMAL */
-  {  269,   -4 }, /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
-  {  269,   -6 }, /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
-  {  261,    0 }, /* (160) tags_def_opt ::= */
-  {  261,   -1 }, /* (161) tags_def_opt ::= tags_def */
-  {  264,   -4 }, /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */
-  {  262,    0 }, /* (163) table_options ::= */
-  {  262,   -3 }, /* (164) table_options ::= table_options COMMENT NK_STRING */
-  {  262,   -3 }, /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */
-  {  262,   -5 }, /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
-  {  262,   -3 }, /* (167) table_options ::= table_options TTL NK_INTEGER */
-  {  262,   -5 }, /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
-  {  267,   -1 }, /* (169) alter_table_options ::= alter_table_option */
-  {  267,   -2 }, /* (170) alter_table_options ::= alter_table_options alter_table_option */
-  {  279,   -2 }, /* (171) alter_table_option ::= COMMENT NK_STRING */
-  {  279,   -2 }, /* (172) alter_table_option ::= TTL NK_INTEGER */
-  {  275,   -1 }, /* (173) col_name_list ::= col_name */
-  {  275,   -3 }, /* (174) col_name_list ::= col_name_list NK_COMMA col_name */
-  {  280,   -1 }, /* (175) col_name ::= column_name */
-  {  237,   -2 }, /* (176) cmd ::= SHOW DNODES */
-  {  237,   -2 }, /* (177) cmd ::= SHOW USERS */
-  {  237,   -2 }, /* (178) cmd ::= SHOW DATABASES */
-  {  237,   -4 }, /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
-  {  237,   -4 }, /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
-  {  237,   -3 }, /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */
-  {  237,   -2 }, /* (182) cmd ::= SHOW MNODES */
-  {  237,   -2 }, /* (183) cmd ::= SHOW MODULES */
-  {  237,   -2 }, /* (184) cmd ::= SHOW QNODES */
-  {  237,   -2 }, /* (185) cmd ::= SHOW FUNCTIONS */
-  {  237,   -5 }, /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
-  {  237,   -2 }, /* (187) cmd ::= SHOW STREAMS */
-  {  237,   -2 }, /* (188) cmd ::= SHOW ACCOUNTS */
-  {  237,   -2 }, /* (189) cmd ::= SHOW APPS */
-  {  237,   -2 }, /* (190) cmd ::= SHOW CONNECTIONS */
-  {  237,   -2 }, /* (191) cmd ::= SHOW LICENCE */
-  {  237,   -2 }, /* (192) cmd ::= SHOW GRANTS */
-  {  237,   -4 }, /* (193) cmd ::= SHOW CREATE DATABASE db_name */
-  {  237,   -4 }, /* (194) cmd ::= SHOW CREATE TABLE full_table_name */
-  {  237,   -4 }, /* (195) cmd ::= SHOW CREATE STABLE full_table_name */
-  {  237,   -2 }, /* (196) cmd ::= SHOW QUERIES */
-  {  237,   -2 }, /* (197) cmd ::= SHOW SCORES */
-  {  237,   -2 }, /* (198) cmd ::= SHOW TOPICS */
-  {  237,   -2 }, /* (199) cmd ::= SHOW VARIABLES */
-  {  237,   -2 }, /* (200) cmd ::= SHOW BNODES */
-  {  237,   -2 }, /* (201) cmd ::= SHOW SNODES */
-  {  237,   -2 }, /* (202) cmd ::= SHOW CLUSTER */
-  {  237,   -2 }, /* (203) cmd ::= SHOW TRANSACTIONS */
-  {  281,    0 }, /* (204) db_name_cond_opt ::= */
-  {  281,   -2 }, /* (205) db_name_cond_opt ::= db_name NK_DOT */
-  {  282,    0 }, /* (206) like_pattern_opt ::= */
-  {  282,   -2 }, /* (207) like_pattern_opt ::= LIKE NK_STRING */
-  {  283,   -1 }, /* (208) table_name_cond ::= table_name */
-  {  284,    0 }, /* (209) from_db_opt ::= */
-  {  284,   -2 }, /* (210) from_db_opt ::= FROM db_name */
-  {  278,   -1 }, /* (211) func_name_list ::= func_name */
-  {  278,   -3 }, /* (212) func_name_list ::= func_name_list NK_COMMA func_name */
-  {  285,   -1 }, /* (213) func_name ::= function_name */
-  {  237,   -8 }, /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
-  {  237,  -10 }, /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
-  {  237,   -6 }, /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */
-  {  288,    0 }, /* (217) index_options ::= */
-  {  288,   -9 }, /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
-  {  288,  -11 }, /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
-  {  289,   -1 }, /* (220) func_list ::= func */
-  {  289,   -3 }, /* (221) func_list ::= func_list NK_COMMA func */
-  {  292,   -4 }, /* (222) func ::= function_name NK_LP expression_list NK_RP */
-  {  237,   -6 }, /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
-  {  237,   -7 }, /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */
-  {  237,   -7 }, /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */
-  {  237,   -4 }, /* (226) cmd ::= DROP TOPIC exists_opt topic_name */
-  {  237,   -7 }, /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
-  {  237,   -2 }, /* (228) cmd ::= DESC full_table_name */
-  {  237,   -2 }, /* (229) cmd ::= DESCRIBE full_table_name */
-  {  237,   -3 }, /* (230) cmd ::= RESET QUERY CACHE */
-  {  237,   -4 }, /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
-  {  297,    0 }, /* (232) analyze_opt ::= */
-  {  297,   -1 }, /* (233) analyze_opt ::= ANALYZE */
-  {  298,    0 }, /* (234) explain_options ::= */
-  {  298,   -3 }, /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */
-  {  298,   -3 }, /* (236) explain_options ::= explain_options RATIO NK_FLOAT */
-  {  237,   -6 }, /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
-  {  237,  -10 }, /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
-  {  237,   -4 }, /* (239) cmd ::= DROP FUNCTION exists_opt function_name */
-  {  299,    0 }, /* (240) agg_func_opt ::= */
-  {  299,   -1 }, /* (241) agg_func_opt ::= AGGREGATE */
-  {  300,    0 }, /* (242) bufsize_opt ::= */
-  {  300,   -2 }, /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */
-  {  237,   -8 }, /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */
-  {  237,   -4 }, /* (245) cmd ::= DROP STREAM exists_opt stream_name */
-  {  303,    0 }, /* (246) into_opt ::= */
-  {  303,   -2 }, /* (247) into_opt ::= INTO full_table_name */
-  {  302,    0 }, /* (248) stream_options ::= */
-  {  302,   -3 }, /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */
-  {  302,   -3 }, /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
-  {  302,   -3 }, /* (251) stream_options ::= stream_options WATERMARK duration_literal */
-  {  237,   -3 }, /* (252) cmd ::= KILL CONNECTION NK_INTEGER */
-  {  237,   -3 }, /* (253) cmd ::= KILL QUERY NK_INTEGER */
-  {  237,   -3 }, /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */
-  {  237,   -4 }, /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
-  {  237,   -4 }, /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
-  {  237,   -3 }, /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */
-  {  304,   -2 }, /* (258) dnode_list ::= DNODE NK_INTEGER */
-  {  304,   -3 }, /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */
-  {  237,   -3 }, /* (260) cmd ::= SYNCDB db_name REPLICA */
-  {  237,   -1 }, /* (261) cmd ::= query_expression */
-  {  240,   -1 }, /* (262) literal ::= NK_INTEGER */
-  {  240,   -1 }, /* (263) literal ::= NK_FLOAT */
-  {  240,   -1 }, /* (264) literal ::= NK_STRING */
-  {  240,   -1 }, /* (265) literal ::= NK_BOOL */
-  {  240,   -2 }, /* (266) literal ::= TIMESTAMP NK_STRING */
-  {  240,   -1 }, /* (267) literal ::= duration_literal */
-  {  240,   -1 }, /* (268) literal ::= NULL */
-  {  240,   -1 }, /* (269) literal ::= NK_QUESTION */
-  {  290,   -1 }, /* (270) duration_literal ::= NK_VARIABLE */
-  {  305,   -1 }, /* (271) signed ::= NK_INTEGER */
-  {  305,   -2 }, /* (272) signed ::= NK_PLUS NK_INTEGER */
-  {  305,   -2 }, /* (273) signed ::= NK_MINUS NK_INTEGER */
-  {  305,   -1 }, /* (274) signed ::= NK_FLOAT */
-  {  305,   -2 }, /* (275) signed ::= NK_PLUS NK_FLOAT */
-  {  305,   -2 }, /* (276) signed ::= NK_MINUS NK_FLOAT */
-  {  270,   -1 }, /* (277) signed_literal ::= signed */
-  {  270,   -1 }, /* (278) signed_literal ::= NK_STRING */
-  {  270,   -1 }, /* (279) signed_literal ::= NK_BOOL */
-  {  270,   -2 }, /* (280) signed_literal ::= TIMESTAMP NK_STRING */
-  {  270,   -1 }, /* (281) signed_literal ::= duration_literal */
-  {  270,   -1 }, /* (282) signed_literal ::= NULL */
-  {  270,   -1 }, /* (283) signed_literal ::= literal_func */
-  {  273,   -1 }, /* (284) literal_list ::= signed_literal */
-  {  273,   -3 }, /* (285) literal_list ::= literal_list NK_COMMA signed_literal */
-  {  247,   -1 }, /* (286) db_name ::= NK_ID */
-  {  276,   -1 }, /* (287) table_name ::= NK_ID */
-  {  268,   -1 }, /* (288) column_name ::= NK_ID */
-  {  286,   -1 }, /* (289) function_name ::= NK_ID */
-  {  307,   -1 }, /* (290) table_alias ::= NK_ID */
-  {  308,   -1 }, /* (291) column_alias ::= NK_ID */
-  {  242,   -1 }, /* (292) user_name ::= NK_ID */
-  {  287,   -1 }, /* (293) index_name ::= NK_ID */
-  {  294,   -1 }, /* (294) topic_name ::= NK_ID */
-  {  301,   -1 }, /* (295) stream_name ::= NK_ID */
-  {  296,   -1 }, /* (296) cgroup_name ::= NK_ID */
-  {  309,   -1 }, /* (297) expression ::= literal */
-  {  309,   -1 }, /* (298) expression ::= pseudo_column */
-  {  309,   -1 }, /* (299) expression ::= column_reference */
-  {  309,   -1 }, /* (300) expression ::= function_expression */
-  {  309,   -1 }, /* (301) expression ::= subquery */
-  {  309,   -3 }, /* (302) expression ::= NK_LP expression NK_RP */
-  {  309,   -2 }, /* (303) expression ::= NK_PLUS expression */
-  {  309,   -2 }, /* (304) expression ::= NK_MINUS expression */
-  {  309,   -3 }, /* (305) expression ::= expression NK_PLUS expression */
-  {  309,   -3 }, /* (306) expression ::= expression NK_MINUS expression */
-  {  309,   -3 }, /* (307) expression ::= expression NK_STAR expression */
-  {  309,   -3 }, /* (308) expression ::= expression NK_SLASH expression */
-  {  309,   -3 }, /* (309) expression ::= expression NK_REM expression */
-  {  309,   -3 }, /* (310) expression ::= column_reference NK_ARROW NK_STRING */
-  {  293,   -1 }, /* (311) expression_list ::= expression */
-  {  293,   -3 }, /* (312) expression_list ::= expression_list NK_COMMA expression */
-  {  311,   -1 }, /* (313) column_reference ::= column_name */
-  {  311,   -3 }, /* (314) column_reference ::= table_name NK_DOT column_name */
-  {  310,   -1 }, /* (315) pseudo_column ::= ROWTS */
-  {  310,   -1 }, /* (316) pseudo_column ::= TBNAME */
-  {  310,   -3 }, /* (317) pseudo_column ::= table_name NK_DOT TBNAME */
-  {  310,   -1 }, /* (318) pseudo_column ::= QSTARTTS */
-  {  310,   -1 }, /* (319) pseudo_column ::= QENDTS */
-  {  310,   -1 }, /* (320) pseudo_column ::= WSTARTTS */
-  {  310,   -1 }, /* (321) pseudo_column ::= WENDTS */
-  {  310,   -1 }, /* (322) pseudo_column ::= WDURATION */
-  {  312,   -4 }, /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */
-  {  312,   -4 }, /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
-  {  312,   -6 }, /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
-  {  312,   -1 }, /* (326) function_expression ::= literal_func */
-  {  306,   -3 }, /* (327) literal_func ::= noarg_func NK_LP NK_RP */
-  {  306,   -1 }, /* (328) literal_func ::= NOW */
-  {  316,   -1 }, /* (329) noarg_func ::= NOW */
-  {  316,   -1 }, /* (330) noarg_func ::= TODAY */
-  {  316,   -1 }, /* (331) noarg_func ::= TIMEZONE */
-  {  314,   -1 }, /* (332) star_func ::= COUNT */
-  {  314,   -1 }, /* (333) star_func ::= FIRST */
-  {  314,   -1 }, /* (334) star_func ::= LAST */
-  {  314,   -1 }, /* (335) star_func ::= LAST_ROW */
-  {  315,   -1 }, /* (336) star_func_para_list ::= NK_STAR */
-  {  315,   -1 }, /* (337) star_func_para_list ::= other_para_list */
-  {  317,   -1 }, /* (338) other_para_list ::= star_func_para */
-  {  317,   -3 }, /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */
-  {  318,   -1 }, /* (340) star_func_para ::= expression */
-  {  318,   -3 }, /* (341) star_func_para ::= table_name NK_DOT NK_STAR */
-  {  319,   -3 }, /* (342) predicate ::= expression compare_op expression */
-  {  319,   -5 }, /* (343) predicate ::= expression BETWEEN expression AND expression */
-  {  319,   -6 }, /* (344) predicate ::= expression NOT BETWEEN expression AND expression */
-  {  319,   -3 }, /* (345) predicate ::= expression IS NULL */
-  {  319,   -4 }, /* (346) predicate ::= expression IS NOT NULL */
-  {  319,   -3 }, /* (347) predicate ::= expression in_op in_predicate_value */
-  {  320,   -1 }, /* (348) compare_op ::= NK_LT */
-  {  320,   -1 }, /* (349) compare_op ::= NK_GT */
-  {  320,   -1 }, /* (350) compare_op ::= NK_LE */
-  {  320,   -1 }, /* (351) compare_op ::= NK_GE */
-  {  320,   -1 }, /* (352) compare_op ::= NK_NE */
-  {  320,   -1 }, /* (353) compare_op ::= NK_EQ */
-  {  320,   -1 }, /* (354) compare_op ::= LIKE */
-  {  320,   -2 }, /* (355) compare_op ::= NOT LIKE */
-  {  320,   -1 }, /* (356) compare_op ::= MATCH */
-  {  320,   -1 }, /* (357) compare_op ::= NMATCH */
-  {  320,   -1 }, /* (358) compare_op ::= CONTAINS */
-  {  321,   -1 }, /* (359) in_op ::= IN */
-  {  321,   -2 }, /* (360) in_op ::= NOT IN */
-  {  322,   -3 }, /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */
-  {  323,   -1 }, /* (362) boolean_value_expression ::= boolean_primary */
-  {  323,   -2 }, /* (363) boolean_value_expression ::= NOT boolean_primary */
-  {  323,   -3 }, /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
-  {  323,   -3 }, /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
-  {  324,   -1 }, /* (366) boolean_primary ::= predicate */
-  {  324,   -3 }, /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
-  {  325,   -1 }, /* (368) common_expression ::= expression */
-  {  325,   -1 }, /* (369) common_expression ::= boolean_value_expression */
-  {  326,   -2 }, /* (370) from_clause ::= FROM table_reference_list */
-  {  327,   -1 }, /* (371) table_reference_list ::= table_reference */
-  {  327,   -3 }, /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */
-  {  328,   -1 }, /* (373) table_reference ::= table_primary */
-  {  328,   -1 }, /* (374) table_reference ::= joined_table */
-  {  329,   -2 }, /* (375) table_primary ::= table_name alias_opt */
-  {  329,   -4 }, /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */
-  {  329,   -2 }, /* (377) table_primary ::= subquery alias_opt */
-  {  329,   -1 }, /* (378) table_primary ::= parenthesized_joined_table */
-  {  331,    0 }, /* (379) alias_opt ::= */
-  {  331,   -1 }, /* (380) alias_opt ::= table_alias */
-  {  331,   -2 }, /* (381) alias_opt ::= AS table_alias */
-  {  332,   -3 }, /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
-  {  332,   -3 }, /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
-  {  330,   -6 }, /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
-  {  333,    0 }, /* (385) join_type ::= */
-  {  333,   -1 }, /* (386) join_type ::= INNER */
-  {  335,   -9 }, /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
-  {  336,    0 }, /* (388) set_quantifier_opt ::= */
-  {  336,   -1 }, /* (389) set_quantifier_opt ::= DISTINCT */
-  {  336,   -1 }, /* (390) set_quantifier_opt ::= ALL */
-  {  337,   -1 }, /* (391) select_list ::= NK_STAR */
-  {  337,   -1 }, /* (392) select_list ::= select_sublist */
-  {  343,   -1 }, /* (393) select_sublist ::= select_item */
-  {  343,   -3 }, /* (394) select_sublist ::= select_sublist NK_COMMA select_item */
-  {  344,   -1 }, /* (395) select_item ::= common_expression */
-  {  344,   -2 }, /* (396) select_item ::= common_expression column_alias */
-  {  344,   -3 }, /* (397) select_item ::= common_expression AS column_alias */
-  {  344,   -3 }, /* (398) select_item ::= table_name NK_DOT NK_STAR */
-  {  338,    0 }, /* (399) where_clause_opt ::= */
-  {  338,   -2 }, /* (400) where_clause_opt ::= WHERE search_condition */
-  {  339,    0 }, /* (401) partition_by_clause_opt ::= */
-  {  339,   -3 }, /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */
-  {  340,    0 }, /* (403) twindow_clause_opt ::= */
-  {  340,   -6 }, /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
-  {  340,   -4 }, /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
-  {  340,   -6 }, /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
-  {  340,   -8 }, /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
-  {  291,    0 }, /* (408) sliding_opt ::= */
-  {  291,   -4 }, /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
-  {  345,    0 }, /* (410) fill_opt ::= */
-  {  345,   -4 }, /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */
-  {  345,   -6 }, /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
-  {  346,   -1 }, /* (413) fill_mode ::= NONE */
-  {  346,   -1 }, /* (414) fill_mode ::= PREV */
-  {  346,   -1 }, /* (415) fill_mode ::= NULL */
-  {  346,   -1 }, /* (416) fill_mode ::= LINEAR */
-  {  346,   -1 }, /* (417) fill_mode ::= NEXT */
-  {  341,    0 }, /* (418) group_by_clause_opt ::= */
-  {  341,   -3 }, /* (419) group_by_clause_opt ::= GROUP BY group_by_list */
-  {  347,   -1 }, /* (420) group_by_list ::= expression */
-  {  347,   -3 }, /* (421) group_by_list ::= group_by_list NK_COMMA expression */
-  {  342,    0 }, /* (422) having_clause_opt ::= */
-  {  342,   -2 }, /* (423) having_clause_opt ::= HAVING search_condition */
-  {  295,   -4 }, /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
-  {  348,   -1 }, /* (425) query_expression_body ::= query_primary */
-  {  348,   -4 }, /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
-  {  348,   -3 }, /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */
-  {  352,   -1 }, /* (428) query_primary ::= query_specification */
-  {  352,   -6 }, /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
-  {  349,    0 }, /* (430) order_by_clause_opt ::= */
-  {  349,   -3 }, /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */
-  {  350,    0 }, /* (432) slimit_clause_opt ::= */
-  {  350,   -2 }, /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */
-  {  350,   -4 }, /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
-  {  350,   -4 }, /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  351,    0 }, /* (436) limit_clause_opt ::= */
-  {  351,   -2 }, /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */
-  {  351,   -4 }, /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
-  {  351,   -4 }, /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
-  {  313,   -3 }, /* (440) subquery ::= NK_LP query_expression NK_RP */
-  {  334,   -1 }, /* (441) search_condition ::= common_expression */
-  {  353,   -1 }, /* (442) sort_specification_list ::= sort_specification */
-  {  353,   -3 }, /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
-  {  354,   -3 }, /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
-  {  355,    0 }, /* (445) ordering_specification_opt ::= */
-  {  355,   -1 }, /* (446) ordering_specification_opt ::= ASC */
-  {  355,   -1 }, /* (447) ordering_specification_opt ::= DESC */
-  {  356,    0 }, /* (448) null_ordering_opt ::= */
-  {  356,   -2 }, /* (449) null_ordering_opt ::= NULLS FIRST */
-  {  356,   -2 }, /* (450) null_ordering_opt ::= NULLS LAST */
+/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
+** of that rule */
+static const YYCODETYPE yyRuleInfoLhs[] = {
+   237,  /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
+   237,  /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
+   238,  /* (2) account_options ::= */
+   238,  /* (3) account_options ::= account_options PPS literal */
+   238,  /* (4) account_options ::= account_options TSERIES literal */
+   238,  /* (5) account_options ::= account_options STORAGE literal */
+   238,  /* (6) account_options ::= account_options STREAMS literal */
+   238,  /* (7) account_options ::= account_options QTIME literal */
+   238,  /* (8) account_options ::= account_options DBS literal */
+   238,  /* (9) account_options ::= account_options USERS literal */
+   238,  /* (10) account_options ::= account_options CONNS literal */
+   238,  /* (11) account_options ::= account_options STATE literal */
+   239,  /* (12) alter_account_options ::= alter_account_option */
+   239,  /* (13) alter_account_options ::= alter_account_options alter_account_option */
+   241,  /* (14) alter_account_option ::= PASS literal */
+   241,  /* (15) alter_account_option ::= PPS literal */
+   241,  /* (16) alter_account_option ::= TSERIES literal */
+   241,  /* (17) alter_account_option ::= STORAGE literal */
+   241,  /* (18) alter_account_option ::= STREAMS literal */
+   241,  /* (19) alter_account_option ::= QTIME literal */
+   241,  /* (20) alter_account_option ::= DBS literal */
+   241,  /* (21) alter_account_option ::= USERS literal */
+   241,  /* (22) alter_account_option ::= CONNS literal */
+   241,  /* (23) alter_account_option ::= STATE literal */
+   237,  /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
+   237,  /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
+   237,  /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
+   237,  /* (27) cmd ::= DROP USER user_name */
+   237,  /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */
+   237,  /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */
+   243,  /* (30) privileges ::= ALL */
+   243,  /* (31) privileges ::= priv_type_list */
+   245,  /* (32) priv_type_list ::= priv_type */
+   245,  /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */
+   246,  /* (34) priv_type ::= READ */
+   246,  /* (35) priv_type ::= WRITE */
+   244,  /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */
+   244,  /* (37) priv_level ::= db_name NK_DOT NK_STAR */
+   237,  /* (38) cmd ::= CREATE DNODE dnode_endpoint */
+   237,  /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
+   237,  /* (40) cmd ::= DROP DNODE NK_INTEGER */
+   237,  /* (41) cmd ::= DROP DNODE dnode_endpoint */
+   237,  /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
+   237,  /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
+   237,  /* (44) cmd ::= ALTER ALL DNODES NK_STRING */
+   237,  /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
+   248,  /* (46) dnode_endpoint ::= NK_STRING */
+   249,  /* (47) dnode_host_name ::= NK_ID */
+   249,  /* (48) dnode_host_name ::= NK_IPTOKEN */
+   237,  /* (49) cmd ::= ALTER LOCAL NK_STRING */
+   237,  /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
+   237,  /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
+   237,  /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
+   237,  /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
+   237,  /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
+   237,  /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
+   237,  /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
+   237,  /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
+   237,  /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
+   237,  /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
+   237,  /* (60) cmd ::= DROP DATABASE exists_opt db_name */
+   237,  /* (61) cmd ::= USE db_name */
+   237,  /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */
+   250,  /* (63) not_exists_opt ::= IF NOT EXISTS */
+   250,  /* (64) not_exists_opt ::= */
+   252,  /* (65) exists_opt ::= IF EXISTS */
+   252,  /* (66) exists_opt ::= */
+   251,  /* (67) db_options ::= */
+   251,  /* (68) db_options ::= db_options BUFFER NK_INTEGER */
+   251,  /* (69) db_options ::= db_options CACHELAST NK_INTEGER */
+   251,  /* (70) db_options ::= db_options COMP NK_INTEGER */
+   251,  /* (71) db_options ::= db_options DAYS NK_INTEGER */
+   251,  /* (72) db_options ::= db_options DAYS NK_VARIABLE */
+   251,  /* (73) db_options ::= db_options FSYNC NK_INTEGER */
+   251,  /* (74) db_options ::= db_options MAXROWS NK_INTEGER */
+   251,  /* (75) db_options ::= db_options MINROWS NK_INTEGER */
+   251,  /* (76) db_options ::= db_options KEEP integer_list */
+   251,  /* (77) db_options ::= db_options KEEP variable_list */
+   251,  /* (78) db_options ::= db_options PAGES NK_INTEGER */
+   251,  /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */
+   251,  /* (80) db_options ::= db_options PRECISION NK_STRING */
+   251,  /* (81) db_options ::= db_options REPLICA NK_INTEGER */
+   251,  /* (82) db_options ::= db_options STRICT NK_INTEGER */
+   251,  /* (83) db_options ::= db_options WAL NK_INTEGER */
+   251,  /* (84) db_options ::= db_options VGROUPS NK_INTEGER */
+   251,  /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
+   251,  /* (86) db_options ::= db_options RETENTIONS retention_list */
+   251,  /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */
+   253,  /* (88) alter_db_options ::= alter_db_option */
+   253,  /* (89) alter_db_options ::= alter_db_options alter_db_option */
+   257,  /* (90) alter_db_option ::= BUFFER NK_INTEGER */
+   257,  /* (91) alter_db_option ::= CACHELAST NK_INTEGER */
+   257,  /* (92) alter_db_option ::= FSYNC NK_INTEGER */
+   257,  /* (93) alter_db_option ::= KEEP integer_list */
+   257,  /* (94) alter_db_option ::= KEEP variable_list */
+   257,  /* (95) alter_db_option ::= PAGES NK_INTEGER */
+   257,  /* (96) alter_db_option ::= REPLICA NK_INTEGER */
+   257,  /* (97) alter_db_option ::= STRICT NK_INTEGER */
+   257,  /* (98) alter_db_option ::= WAL NK_INTEGER */
+   254,  /* (99) integer_list ::= NK_INTEGER */
+   254,  /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */
+   255,  /* (101) variable_list ::= NK_VARIABLE */
+   255,  /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
+   256,  /* (103) retention_list ::= retention */
+   256,  /* (104) retention_list ::= retention_list NK_COMMA retention */
+   258,  /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
+   237,  /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
+   237,  /* (107) cmd ::= CREATE TABLE multi_create_clause */
+   237,  /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
+   237,  /* (109) cmd ::= DROP TABLE multi_drop_clause */
+   237,  /* (110) cmd ::= DROP STABLE exists_opt full_table_name */
+   237,  /* (111) cmd ::= ALTER TABLE alter_table_clause */
+   237,  /* (112) cmd ::= ALTER STABLE alter_table_clause */
+   266,  /* (113) alter_table_clause ::= full_table_name alter_table_options */
+   266,  /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+   266,  /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */
+   266,  /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+   266,  /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
+   266,  /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+   266,  /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */
+   266,  /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+   266,  /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
+   266,  /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
+   263,  /* (123) multi_create_clause ::= create_subtable_clause */
+   263,  /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */
+   271,  /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */
+   265,  /* (126) multi_drop_clause ::= drop_table_clause */
+   265,  /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */
+   274,  /* (128) drop_table_clause ::= exists_opt full_table_name */
+   272,  /* (129) specific_tags_opt ::= */
+   272,  /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */
+   259,  /* (131) full_table_name ::= table_name */
+   259,  /* (132) full_table_name ::= db_name NK_DOT table_name */
+   260,  /* (133) column_def_list ::= column_def */
+   260,  /* (134) column_def_list ::= column_def_list NK_COMMA column_def */
+   277,  /* (135) column_def ::= column_name type_name */
+   277,  /* (136) column_def ::= column_name type_name COMMENT NK_STRING */
+   269,  /* (137) type_name ::= BOOL */
+   269,  /* (138) type_name ::= TINYINT */
+   269,  /* (139) type_name ::= SMALLINT */
+   269,  /* (140) type_name ::= INT */
+   269,  /* (141) type_name ::= INTEGER */
+   269,  /* (142) type_name ::= BIGINT */
+   269,  /* (143) type_name ::= FLOAT */
+   269,  /* (144) type_name ::= DOUBLE */
+   269,  /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+   269,  /* (146) type_name ::= TIMESTAMP */
+   269,  /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+   269,  /* (148) type_name ::= TINYINT UNSIGNED */
+   269,  /* (149) type_name ::= SMALLINT UNSIGNED */
+   269,  /* (150) type_name ::= INT UNSIGNED */
+   269,  /* (151) type_name ::= BIGINT UNSIGNED */
+   269,  /* (152) type_name ::= JSON */
+   269,  /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+   269,  /* (154) type_name ::= MEDIUMBLOB */
+   269,  /* (155) type_name ::= BLOB */
+   269,  /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+   269,  /* (157) type_name ::= DECIMAL */
+   269,  /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+   269,  /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+   261,  /* (160) tags_def_opt ::= */
+   261,  /* (161) tags_def_opt ::= tags_def */
+   264,  /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */
+   262,  /* (163) table_options ::= */
+   262,  /* (164) table_options ::= table_options COMMENT NK_STRING */
+   262,  /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */
+   262,  /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
+   262,  /* (167) table_options ::= table_options TTL NK_INTEGER */
+   262,  /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+   267,  /* (169) alter_table_options ::= alter_table_option */
+   267,  /* (170) alter_table_options ::= alter_table_options alter_table_option */
+   279,  /* (171) alter_table_option ::= COMMENT NK_STRING */
+   279,  /* (172) alter_table_option ::= TTL NK_INTEGER */
+   275,  /* (173) col_name_list ::= col_name */
+   275,  /* (174) col_name_list ::= col_name_list NK_COMMA col_name */
+   280,  /* (175) col_name ::= column_name */
+   237,  /* (176) cmd ::= SHOW DNODES */
+   237,  /* (177) cmd ::= SHOW USERS */
+   237,  /* (178) cmd ::= SHOW DATABASES */
+   237,  /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+   237,  /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+   237,  /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */
+   237,  /* (182) cmd ::= SHOW MNODES */
+   237,  /* (183) cmd ::= SHOW MODULES */
+   237,  /* (184) cmd ::= SHOW QNODES */
+   237,  /* (185) cmd ::= SHOW FUNCTIONS */
+   237,  /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+   237,  /* (187) cmd ::= SHOW STREAMS */
+   237,  /* (188) cmd ::= SHOW ACCOUNTS */
+   237,  /* (189) cmd ::= SHOW APPS */
+   237,  /* (190) cmd ::= SHOW CONNECTIONS */
+   237,  /* (191) cmd ::= SHOW LICENCE */
+   237,  /* (192) cmd ::= SHOW GRANTS */
+   237,  /* (193) cmd ::= SHOW CREATE DATABASE db_name */
+   237,  /* (194) cmd ::= SHOW CREATE TABLE full_table_name */
+   237,  /* (195) cmd ::= SHOW CREATE STABLE full_table_name */
+   237,  /* (196) cmd ::= SHOW QUERIES */
+   237,  /* (197) cmd ::= SHOW SCORES */
+   237,  /* (198) cmd ::= SHOW TOPICS */
+   237,  /* (199) cmd ::= SHOW VARIABLES */
+   237,  /* (200) cmd ::= SHOW BNODES */
+   237,  /* (201) cmd ::= SHOW SNODES */
+   237,  /* (202) cmd ::= SHOW CLUSTER */
+   237,  /* (203) cmd ::= SHOW TRANSACTIONS */
+   281,  /* (204) db_name_cond_opt ::= */
+   281,  /* (205) db_name_cond_opt ::= db_name NK_DOT */
+   282,  /* (206) like_pattern_opt ::= */
+   282,  /* (207) like_pattern_opt ::= LIKE NK_STRING */
+   283,  /* (208) table_name_cond ::= table_name */
+   284,  /* (209) from_db_opt ::= */
+   284,  /* (210) from_db_opt ::= FROM db_name */
+   278,  /* (211) func_name_list ::= func_name */
+   278,  /* (212) func_name_list ::= func_name_list NK_COMMA func_name */
+   285,  /* (213) func_name ::= function_name */
+   237,  /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
+   237,  /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
+   237,  /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */
+   288,  /* (217) index_options ::= */
+   288,  /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
+   288,  /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
+   289,  /* (220) func_list ::= func */
+   289,  /* (221) func_list ::= func_list NK_COMMA func */
+   292,  /* (222) func ::= function_name NK_LP expression_list NK_RP */
+   237,  /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
+   237,  /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */
+   237,  /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */
+   237,  /* (226) cmd ::= DROP TOPIC exists_opt topic_name */
+   237,  /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
+   237,  /* (228) cmd ::= DESC full_table_name */
+   237,  /* (229) cmd ::= DESCRIBE full_table_name */
+   237,  /* (230) cmd ::= RESET QUERY CACHE */
+   237,  /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
+   297,  /* (232) analyze_opt ::= */
+   297,  /* (233) analyze_opt ::= ANALYZE */
+   298,  /* (234) explain_options ::= */
+   298,  /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */
+   298,  /* (236) explain_options ::= explain_options RATIO NK_FLOAT */
+   237,  /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
+   237,  /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
+   237,  /* (239) cmd ::= DROP FUNCTION exists_opt function_name */
+   299,  /* (240) agg_func_opt ::= */
+   299,  /* (241) agg_func_opt ::= AGGREGATE */
+   300,  /* (242) bufsize_opt ::= */
+   300,  /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */
+   237,  /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */
+   237,  /* (245) cmd ::= DROP STREAM exists_opt stream_name */
+   303,  /* (246) into_opt ::= */
+   303,  /* (247) into_opt ::= INTO full_table_name */
+   302,  /* (248) stream_options ::= */
+   302,  /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */
+   302,  /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
+   302,  /* (251) stream_options ::= stream_options WATERMARK duration_literal */
+   237,  /* (252) cmd ::= KILL CONNECTION NK_INTEGER */
+   237,  /* (253) cmd ::= KILL QUERY NK_INTEGER */
+   237,  /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */
+   237,  /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+   237,  /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+   237,  /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */
+   304,  /* (258) dnode_list ::= DNODE NK_INTEGER */
+   304,  /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */
+   237,  /* (260) cmd ::= SYNCDB db_name REPLICA */
+   237,  /* (261) cmd ::= query_expression */
+   240,  /* (262) literal ::= NK_INTEGER */
+   240,  /* (263) literal ::= NK_FLOAT */
+   240,  /* (264) literal ::= NK_STRING */
+   240,  /* (265) literal ::= NK_BOOL */
+   240,  /* (266) literal ::= TIMESTAMP NK_STRING */
+   240,  /* (267) literal ::= duration_literal */
+   240,  /* (268) literal ::= NULL */
+   240,  /* (269) literal ::= NK_QUESTION */
+   290,  /* (270) duration_literal ::= NK_VARIABLE */
+   305,  /* (271) signed ::= NK_INTEGER */
+   305,  /* (272) signed ::= NK_PLUS NK_INTEGER */
+   305,  /* (273) signed ::= NK_MINUS NK_INTEGER */
+   305,  /* (274) signed ::= NK_FLOAT */
+   305,  /* (275) signed ::= NK_PLUS NK_FLOAT */
+   305,  /* (276) signed ::= NK_MINUS NK_FLOAT */
+   270,  /* (277) signed_literal ::= signed */
+   270,  /* (278) signed_literal ::= NK_STRING */
+   270,  /* (279) signed_literal ::= NK_BOOL */
+   270,  /* (280) signed_literal ::= TIMESTAMP NK_STRING */
+   270,  /* (281) signed_literal ::= duration_literal */
+   270,  /* (282) signed_literal ::= NULL */
+   270,  /* (283) signed_literal ::= literal_func */
+   273,  /* (284) literal_list ::= signed_literal */
+   273,  /* (285) literal_list ::= literal_list NK_COMMA signed_literal */
+   247,  /* (286) db_name ::= NK_ID */
+   276,  /* (287) table_name ::= NK_ID */
+   268,  /* (288) column_name ::= NK_ID */
+   286,  /* (289) function_name ::= NK_ID */
+   307,  /* (290) table_alias ::= NK_ID */
+   308,  /* (291) column_alias ::= NK_ID */
+   242,  /* (292) user_name ::= NK_ID */
+   287,  /* (293) index_name ::= NK_ID */
+   294,  /* (294) topic_name ::= NK_ID */
+   301,  /* (295) stream_name ::= NK_ID */
+   296,  /* (296) cgroup_name ::= NK_ID */
+   309,  /* (297) expression ::= literal */
+   309,  /* (298) expression ::= pseudo_column */
+   309,  /* (299) expression ::= column_reference */
+   309,  /* (300) expression ::= function_expression */
+   309,  /* (301) expression ::= subquery */
+   309,  /* (302) expression ::= NK_LP expression NK_RP */
+   309,  /* (303) expression ::= NK_PLUS expression */
+   309,  /* (304) expression ::= NK_MINUS expression */
+   309,  /* (305) expression ::= expression NK_PLUS expression */
+   309,  /* (306) expression ::= expression NK_MINUS expression */
+   309,  /* (307) expression ::= expression NK_STAR expression */
+   309,  /* (308) expression ::= expression NK_SLASH expression */
+   309,  /* (309) expression ::= expression NK_REM expression */
+   309,  /* (310) expression ::= column_reference NK_ARROW NK_STRING */
+   293,  /* (311) expression_list ::= expression */
+   293,  /* (312) expression_list ::= expression_list NK_COMMA expression */
+   311,  /* (313) column_reference ::= column_name */
+   311,  /* (314) column_reference ::= table_name NK_DOT column_name */
+   310,  /* (315) pseudo_column ::= ROWTS */
+   310,  /* (316) pseudo_column ::= TBNAME */
+   310,  /* (317) pseudo_column ::= table_name NK_DOT TBNAME */
+   310,  /* (318) pseudo_column ::= QSTARTTS */
+   310,  /* (319) pseudo_column ::= QENDTS */
+   310,  /* (320) pseudo_column ::= WSTARTTS */
+   310,  /* (321) pseudo_column ::= WENDTS */
+   310,  /* (322) pseudo_column ::= WDURATION */
+   312,  /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */
+   312,  /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+   312,  /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+   312,  /* (326) function_expression ::= literal_func */
+   306,  /* (327) literal_func ::= noarg_func NK_LP NK_RP */
+   306,  /* (328) literal_func ::= NOW */
+   316,  /* (329) noarg_func ::= NOW */
+   316,  /* (330) noarg_func ::= TODAY */
+   316,  /* (331) noarg_func ::= TIMEZONE */
+   314,  /* (332) star_func ::= COUNT */
+   314,  /* (333) star_func ::= FIRST */
+   314,  /* (334) star_func ::= LAST */
+   314,  /* (335) star_func ::= LAST_ROW */
+   315,  /* (336) star_func_para_list ::= NK_STAR */
+   315,  /* (337) star_func_para_list ::= other_para_list */
+   317,  /* (338) other_para_list ::= star_func_para */
+   317,  /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */
+   318,  /* (340) star_func_para ::= expression */
+   318,  /* (341) star_func_para ::= table_name NK_DOT NK_STAR */
+   319,  /* (342) predicate ::= expression compare_op expression */
+   319,  /* (343) predicate ::= expression BETWEEN expression AND expression */
+   319,  /* (344) predicate ::= expression NOT BETWEEN expression AND expression */
+   319,  /* (345) predicate ::= expression IS NULL */
+   319,  /* (346) predicate ::= expression IS NOT NULL */
+   319,  /* (347) predicate ::= expression in_op in_predicate_value */
+   320,  /* (348) compare_op ::= NK_LT */
+   320,  /* (349) compare_op ::= NK_GT */
+   320,  /* (350) compare_op ::= NK_LE */
+   320,  /* (351) compare_op ::= NK_GE */
+   320,  /* (352) compare_op ::= NK_NE */
+   320,  /* (353) compare_op ::= NK_EQ */
+   320,  /* (354) compare_op ::= LIKE */
+   320,  /* (355) compare_op ::= NOT LIKE */
+   320,  /* (356) compare_op ::= MATCH */
+   320,  /* (357) compare_op ::= NMATCH */
+   320,  /* (358) compare_op ::= CONTAINS */
+   321,  /* (359) in_op ::= IN */
+   321,  /* (360) in_op ::= NOT IN */
+   322,  /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */
+   323,  /* (362) boolean_value_expression ::= boolean_primary */
+   323,  /* (363) boolean_value_expression ::= NOT boolean_primary */
+   323,  /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+   323,  /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+   324,  /* (366) boolean_primary ::= predicate */
+   324,  /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+   325,  /* (368) common_expression ::= expression */
+   325,  /* (369) common_expression ::= boolean_value_expression */
+   326,  /* (370) from_clause ::= FROM table_reference_list */
+   327,  /* (371) table_reference_list ::= table_reference */
+   327,  /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+   328,  /* (373) table_reference ::= table_primary */
+   328,  /* (374) table_reference ::= joined_table */
+   329,  /* (375) table_primary ::= table_name alias_opt */
+   329,  /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */
+   329,  /* (377) table_primary ::= subquery alias_opt */
+   329,  /* (378) table_primary ::= parenthesized_joined_table */
+   331,  /* (379) alias_opt ::= */
+   331,  /* (380) alias_opt ::= table_alias */
+   331,  /* (381) alias_opt ::= AS table_alias */
+   332,  /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+   332,  /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+   330,  /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+   333,  /* (385) join_type ::= */
+   333,  /* (386) join_type ::= INNER */
+   335,  /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+   336,  /* (388) set_quantifier_opt ::= */
+   336,  /* (389) set_quantifier_opt ::= DISTINCT */
+   336,  /* (390) set_quantifier_opt ::= ALL */
+   337,  /* (391) select_list ::= NK_STAR */
+   337,  /* (392) select_list ::= select_sublist */
+   343,  /* (393) select_sublist ::= select_item */
+   343,  /* (394) select_sublist ::= select_sublist NK_COMMA select_item */
+   344,  /* (395) select_item ::= common_expression */
+   344,  /* (396) select_item ::= common_expression column_alias */
+   344,  /* (397) select_item ::= common_expression AS column_alias */
+   344,  /* (398) select_item ::= table_name NK_DOT NK_STAR */
+   338,  /* (399) where_clause_opt ::= */
+   338,  /* (400) where_clause_opt ::= WHERE search_condition */
+   339,  /* (401) partition_by_clause_opt ::= */
+   339,  /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */
+   340,  /* (403) twindow_clause_opt ::= */
+   340,  /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+   340,  /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+   340,  /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+   340,  /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+   291,  /* (408) sliding_opt ::= */
+   291,  /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+   345,  /* (410) fill_opt ::= */
+   345,  /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+   345,  /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+   346,  /* (413) fill_mode ::= NONE */
+   346,  /* (414) fill_mode ::= PREV */
+   346,  /* (415) fill_mode ::= NULL */
+   346,  /* (416) fill_mode ::= LINEAR */
+   346,  /* (417) fill_mode ::= NEXT */
+   341,  /* (418) group_by_clause_opt ::= */
+   341,  /* (419) group_by_clause_opt ::= GROUP BY group_by_list */
+   347,  /* (420) group_by_list ::= expression */
+   347,  /* (421) group_by_list ::= group_by_list NK_COMMA expression */
+   342,  /* (422) having_clause_opt ::= */
+   342,  /* (423) having_clause_opt ::= HAVING search_condition */
+   295,  /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+   348,  /* (425) query_expression_body ::= query_primary */
+   348,  /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+   348,  /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */
+   352,  /* (428) query_primary ::= query_specification */
+   352,  /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+   349,  /* (430) order_by_clause_opt ::= */
+   349,  /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */
+   350,  /* (432) slimit_clause_opt ::= */
+   350,  /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+   350,  /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+   350,  /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   351,  /* (436) limit_clause_opt ::= */
+   351,  /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */
+   351,  /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+   351,  /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   313,  /* (440) subquery ::= NK_LP query_expression NK_RP */
+   334,  /* (441) search_condition ::= common_expression */
+   353,  /* (442) sort_specification_list ::= sort_specification */
+   353,  /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+   354,  /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+   355,  /* (445) ordering_specification_opt ::= */
+   355,  /* (446) ordering_specification_opt ::= ASC */
+   355,  /* (447) ordering_specification_opt ::= DESC */
+   356,  /* (448) null_ordering_opt ::= */
+   356,  /* (449) null_ordering_opt ::= NULLS FIRST */
+   356,  /* (450) null_ordering_opt ::= NULLS LAST */
+};
+
+/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
+** of symbols on the right-hand side of that rule. */
+static const signed char yyRuleInfoNRhs[] = {
+   -6,  /* (0) cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */
+   -4,  /* (1) cmd ::= ALTER ACCOUNT NK_ID alter_account_options */
+    0,  /* (2) account_options ::= */
+   -3,  /* (3) account_options ::= account_options PPS literal */
+   -3,  /* (4) account_options ::= account_options TSERIES literal */
+   -3,  /* (5) account_options ::= account_options STORAGE literal */
+   -3,  /* (6) account_options ::= account_options STREAMS literal */
+   -3,  /* (7) account_options ::= account_options QTIME literal */
+   -3,  /* (8) account_options ::= account_options DBS literal */
+   -3,  /* (9) account_options ::= account_options USERS literal */
+   -3,  /* (10) account_options ::= account_options CONNS literal */
+   -3,  /* (11) account_options ::= account_options STATE literal */
+   -1,  /* (12) alter_account_options ::= alter_account_option */
+   -2,  /* (13) alter_account_options ::= alter_account_options alter_account_option */
+   -2,  /* (14) alter_account_option ::= PASS literal */
+   -2,  /* (15) alter_account_option ::= PPS literal */
+   -2,  /* (16) alter_account_option ::= TSERIES literal */
+   -2,  /* (17) alter_account_option ::= STORAGE literal */
+   -2,  /* (18) alter_account_option ::= STREAMS literal */
+   -2,  /* (19) alter_account_option ::= QTIME literal */
+   -2,  /* (20) alter_account_option ::= DBS literal */
+   -2,  /* (21) alter_account_option ::= USERS literal */
+   -2,  /* (22) alter_account_option ::= CONNS literal */
+   -2,  /* (23) alter_account_option ::= STATE literal */
+   -5,  /* (24) cmd ::= CREATE USER user_name PASS NK_STRING */
+   -5,  /* (25) cmd ::= ALTER USER user_name PASS NK_STRING */
+   -5,  /* (26) cmd ::= ALTER USER user_name PRIVILEGE NK_STRING */
+   -3,  /* (27) cmd ::= DROP USER user_name */
+   -6,  /* (28) cmd ::= GRANT privileges ON priv_level TO user_name */
+   -6,  /* (29) cmd ::= REVOKE privileges ON priv_level FROM user_name */
+   -1,  /* (30) privileges ::= ALL */
+   -1,  /* (31) privileges ::= priv_type_list */
+   -1,  /* (32) priv_type_list ::= priv_type */
+   -3,  /* (33) priv_type_list ::= priv_type_list NK_COMMA priv_type */
+   -1,  /* (34) priv_type ::= READ */
+   -1,  /* (35) priv_type ::= WRITE */
+   -3,  /* (36) priv_level ::= NK_STAR NK_DOT NK_STAR */
+   -3,  /* (37) priv_level ::= db_name NK_DOT NK_STAR */
+   -3,  /* (38) cmd ::= CREATE DNODE dnode_endpoint */
+   -5,  /* (39) cmd ::= CREATE DNODE dnode_host_name PORT NK_INTEGER */
+   -3,  /* (40) cmd ::= DROP DNODE NK_INTEGER */
+   -3,  /* (41) cmd ::= DROP DNODE dnode_endpoint */
+   -4,  /* (42) cmd ::= ALTER DNODE NK_INTEGER NK_STRING */
+   -5,  /* (43) cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */
+   -4,  /* (44) cmd ::= ALTER ALL DNODES NK_STRING */
+   -5,  /* (45) cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */
+   -1,  /* (46) dnode_endpoint ::= NK_STRING */
+   -1,  /* (47) dnode_host_name ::= NK_ID */
+   -1,  /* (48) dnode_host_name ::= NK_IPTOKEN */
+   -3,  /* (49) cmd ::= ALTER LOCAL NK_STRING */
+   -4,  /* (50) cmd ::= ALTER LOCAL NK_STRING NK_STRING */
+   -5,  /* (51) cmd ::= CREATE QNODE ON DNODE NK_INTEGER */
+   -5,  /* (52) cmd ::= DROP QNODE ON DNODE NK_INTEGER */
+   -5,  /* (53) cmd ::= CREATE BNODE ON DNODE NK_INTEGER */
+   -5,  /* (54) cmd ::= DROP BNODE ON DNODE NK_INTEGER */
+   -5,  /* (55) cmd ::= CREATE SNODE ON DNODE NK_INTEGER */
+   -5,  /* (56) cmd ::= DROP SNODE ON DNODE NK_INTEGER */
+   -5,  /* (57) cmd ::= CREATE MNODE ON DNODE NK_INTEGER */
+   -5,  /* (58) cmd ::= DROP MNODE ON DNODE NK_INTEGER */
+   -5,  /* (59) cmd ::= CREATE DATABASE not_exists_opt db_name db_options */
+   -4,  /* (60) cmd ::= DROP DATABASE exists_opt db_name */
+   -2,  /* (61) cmd ::= USE db_name */
+   -4,  /* (62) cmd ::= ALTER DATABASE db_name alter_db_options */
+   -3,  /* (63) not_exists_opt ::= IF NOT EXISTS */
+    0,  /* (64) not_exists_opt ::= */
+   -2,  /* (65) exists_opt ::= IF EXISTS */
+    0,  /* (66) exists_opt ::= */
+    0,  /* (67) db_options ::= */
+   -3,  /* (68) db_options ::= db_options BUFFER NK_INTEGER */
+   -3,  /* (69) db_options ::= db_options CACHELAST NK_INTEGER */
+   -3,  /* (70) db_options ::= db_options COMP NK_INTEGER */
+   -3,  /* (71) db_options ::= db_options DAYS NK_INTEGER */
+   -3,  /* (72) db_options ::= db_options DAYS NK_VARIABLE */
+   -3,  /* (73) db_options ::= db_options FSYNC NK_INTEGER */
+   -3,  /* (74) db_options ::= db_options MAXROWS NK_INTEGER */
+   -3,  /* (75) db_options ::= db_options MINROWS NK_INTEGER */
+   -3,  /* (76) db_options ::= db_options KEEP integer_list */
+   -3,  /* (77) db_options ::= db_options KEEP variable_list */
+   -3,  /* (78) db_options ::= db_options PAGES NK_INTEGER */
+   -3,  /* (79) db_options ::= db_options PAGESIZE NK_INTEGER */
+   -3,  /* (80) db_options ::= db_options PRECISION NK_STRING */
+   -3,  /* (81) db_options ::= db_options REPLICA NK_INTEGER */
+   -3,  /* (82) db_options ::= db_options STRICT NK_INTEGER */
+   -3,  /* (83) db_options ::= db_options WAL NK_INTEGER */
+   -3,  /* (84) db_options ::= db_options VGROUPS NK_INTEGER */
+   -3,  /* (85) db_options ::= db_options SINGLE_STABLE NK_INTEGER */
+   -3,  /* (86) db_options ::= db_options RETENTIONS retention_list */
+   -3,  /* (87) db_options ::= db_options SCHEMALESS NK_INTEGER */
+   -1,  /* (88) alter_db_options ::= alter_db_option */
+   -2,  /* (89) alter_db_options ::= alter_db_options alter_db_option */
+   -2,  /* (90) alter_db_option ::= BUFFER NK_INTEGER */
+   -2,  /* (91) alter_db_option ::= CACHELAST NK_INTEGER */
+   -2,  /* (92) alter_db_option ::= FSYNC NK_INTEGER */
+   -2,  /* (93) alter_db_option ::= KEEP integer_list */
+   -2,  /* (94) alter_db_option ::= KEEP variable_list */
+   -2,  /* (95) alter_db_option ::= PAGES NK_INTEGER */
+   -2,  /* (96) alter_db_option ::= REPLICA NK_INTEGER */
+   -2,  /* (97) alter_db_option ::= STRICT NK_INTEGER */
+   -2,  /* (98) alter_db_option ::= WAL NK_INTEGER */
+   -1,  /* (99) integer_list ::= NK_INTEGER */
+   -3,  /* (100) integer_list ::= integer_list NK_COMMA NK_INTEGER */
+   -1,  /* (101) variable_list ::= NK_VARIABLE */
+   -3,  /* (102) variable_list ::= variable_list NK_COMMA NK_VARIABLE */
+   -1,  /* (103) retention_list ::= retention */
+   -3,  /* (104) retention_list ::= retention_list NK_COMMA retention */
+   -3,  /* (105) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */
+   -9,  /* (106) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */
+   -3,  /* (107) cmd ::= CREATE TABLE multi_create_clause */
+   -9,  /* (108) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */
+   -3,  /* (109) cmd ::= DROP TABLE multi_drop_clause */
+   -4,  /* (110) cmd ::= DROP STABLE exists_opt full_table_name */
+   -3,  /* (111) cmd ::= ALTER TABLE alter_table_clause */
+   -3,  /* (112) cmd ::= ALTER STABLE alter_table_clause */
+   -2,  /* (113) alter_table_clause ::= full_table_name alter_table_options */
+   -5,  /* (114) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */
+   -4,  /* (115) alter_table_clause ::= full_table_name DROP COLUMN column_name */
+   -5,  /* (116) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */
+   -5,  /* (117) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */
+   -5,  /* (118) alter_table_clause ::= full_table_name ADD TAG column_name type_name */
+   -4,  /* (119) alter_table_clause ::= full_table_name DROP TAG column_name */
+   -5,  /* (120) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */
+   -5,  /* (121) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */
+   -6,  /* (122) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */
+   -1,  /* (123) multi_create_clause ::= create_subtable_clause */
+   -2,  /* (124) multi_create_clause ::= multi_create_clause create_subtable_clause */
+  -10,  /* (125) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_tags_opt TAGS NK_LP literal_list NK_RP table_options */
+   -1,  /* (126) multi_drop_clause ::= drop_table_clause */
+   -2,  /* (127) multi_drop_clause ::= multi_drop_clause drop_table_clause */
+   -2,  /* (128) drop_table_clause ::= exists_opt full_table_name */
+    0,  /* (129) specific_tags_opt ::= */
+   -3,  /* (130) specific_tags_opt ::= NK_LP col_name_list NK_RP */
+   -1,  /* (131) full_table_name ::= table_name */
+   -3,  /* (132) full_table_name ::= db_name NK_DOT table_name */
+   -1,  /* (133) column_def_list ::= column_def */
+   -3,  /* (134) column_def_list ::= column_def_list NK_COMMA column_def */
+   -2,  /* (135) column_def ::= column_name type_name */
+   -4,  /* (136) column_def ::= column_name type_name COMMENT NK_STRING */
+   -1,  /* (137) type_name ::= BOOL */
+   -1,  /* (138) type_name ::= TINYINT */
+   -1,  /* (139) type_name ::= SMALLINT */
+   -1,  /* (140) type_name ::= INT */
+   -1,  /* (141) type_name ::= INTEGER */
+   -1,  /* (142) type_name ::= BIGINT */
+   -1,  /* (143) type_name ::= FLOAT */
+   -1,  /* (144) type_name ::= DOUBLE */
+   -4,  /* (145) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */
+   -1,  /* (146) type_name ::= TIMESTAMP */
+   -4,  /* (147) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */
+   -2,  /* (148) type_name ::= TINYINT UNSIGNED */
+   -2,  /* (149) type_name ::= SMALLINT UNSIGNED */
+   -2,  /* (150) type_name ::= INT UNSIGNED */
+   -2,  /* (151) type_name ::= BIGINT UNSIGNED */
+   -1,  /* (152) type_name ::= JSON */
+   -4,  /* (153) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */
+   -1,  /* (154) type_name ::= MEDIUMBLOB */
+   -1,  /* (155) type_name ::= BLOB */
+   -4,  /* (156) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */
+   -1,  /* (157) type_name ::= DECIMAL */
+   -4,  /* (158) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */
+   -6,  /* (159) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */
+    0,  /* (160) tags_def_opt ::= */
+   -1,  /* (161) tags_def_opt ::= tags_def */
+   -4,  /* (162) tags_def ::= TAGS NK_LP column_def_list NK_RP */
+    0,  /* (163) table_options ::= */
+   -3,  /* (164) table_options ::= table_options COMMENT NK_STRING */
+   -3,  /* (165) table_options ::= table_options FILE_FACTOR NK_FLOAT */
+   -5,  /* (166) table_options ::= table_options ROLLUP NK_LP func_name_list NK_RP */
+   -3,  /* (167) table_options ::= table_options TTL NK_INTEGER */
+   -5,  /* (168) table_options ::= table_options SMA NK_LP col_name_list NK_RP */
+   -1,  /* (169) alter_table_options ::= alter_table_option */
+   -2,  /* (170) alter_table_options ::= alter_table_options alter_table_option */
+   -2,  /* (171) alter_table_option ::= COMMENT NK_STRING */
+   -2,  /* (172) alter_table_option ::= TTL NK_INTEGER */
+   -1,  /* (173) col_name_list ::= col_name */
+   -3,  /* (174) col_name_list ::= col_name_list NK_COMMA col_name */
+   -1,  /* (175) col_name ::= column_name */
+   -2,  /* (176) cmd ::= SHOW DNODES */
+   -2,  /* (177) cmd ::= SHOW USERS */
+   -2,  /* (178) cmd ::= SHOW DATABASES */
+   -4,  /* (179) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */
+   -4,  /* (180) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */
+   -3,  /* (181) cmd ::= SHOW db_name_cond_opt VGROUPS */
+   -2,  /* (182) cmd ::= SHOW MNODES */
+   -2,  /* (183) cmd ::= SHOW MODULES */
+   -2,  /* (184) cmd ::= SHOW QNODES */
+   -2,  /* (185) cmd ::= SHOW FUNCTIONS */
+   -5,  /* (186) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */
+   -2,  /* (187) cmd ::= SHOW STREAMS */
+   -2,  /* (188) cmd ::= SHOW ACCOUNTS */
+   -2,  /* (189) cmd ::= SHOW APPS */
+   -2,  /* (190) cmd ::= SHOW CONNECTIONS */
+   -2,  /* (191) cmd ::= SHOW LICENCE */
+   -2,  /* (192) cmd ::= SHOW GRANTS */
+   -4,  /* (193) cmd ::= SHOW CREATE DATABASE db_name */
+   -4,  /* (194) cmd ::= SHOW CREATE TABLE full_table_name */
+   -4,  /* (195) cmd ::= SHOW CREATE STABLE full_table_name */
+   -2,  /* (196) cmd ::= SHOW QUERIES */
+   -2,  /* (197) cmd ::= SHOW SCORES */
+   -2,  /* (198) cmd ::= SHOW TOPICS */
+   -2,  /* (199) cmd ::= SHOW VARIABLES */
+   -2,  /* (200) cmd ::= SHOW BNODES */
+   -2,  /* (201) cmd ::= SHOW SNODES */
+   -2,  /* (202) cmd ::= SHOW CLUSTER */
+   -2,  /* (203) cmd ::= SHOW TRANSACTIONS */
+    0,  /* (204) db_name_cond_opt ::= */
+   -2,  /* (205) db_name_cond_opt ::= db_name NK_DOT */
+    0,  /* (206) like_pattern_opt ::= */
+   -2,  /* (207) like_pattern_opt ::= LIKE NK_STRING */
+   -1,  /* (208) table_name_cond ::= table_name */
+    0,  /* (209) from_db_opt ::= */
+   -2,  /* (210) from_db_opt ::= FROM db_name */
+   -1,  /* (211) func_name_list ::= func_name */
+   -3,  /* (212) func_name_list ::= func_name_list NK_COMMA func_name */
+   -1,  /* (213) func_name ::= function_name */
+   -8,  /* (214) cmd ::= CREATE SMA INDEX not_exists_opt index_name ON table_name index_options */
+  -10,  /* (215) cmd ::= CREATE FULLTEXT INDEX not_exists_opt index_name ON table_name NK_LP col_name_list NK_RP */
+   -6,  /* (216) cmd ::= DROP INDEX exists_opt index_name ON table_name */
+    0,  /* (217) index_options ::= */
+   -9,  /* (218) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt */
+  -11,  /* (219) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt */
+   -1,  /* (220) func_list ::= func */
+   -3,  /* (221) func_list ::= func_list NK_COMMA func */
+   -4,  /* (222) func ::= function_name NK_LP expression_list NK_RP */
+   -6,  /* (223) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_expression */
+   -7,  /* (224) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */
+   -7,  /* (225) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */
+   -4,  /* (226) cmd ::= DROP TOPIC exists_opt topic_name */
+   -7,  /* (227) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */
+   -2,  /* (228) cmd ::= DESC full_table_name */
+   -2,  /* (229) cmd ::= DESCRIBE full_table_name */
+   -3,  /* (230) cmd ::= RESET QUERY CACHE */
+   -4,  /* (231) cmd ::= EXPLAIN analyze_opt explain_options query_expression */
+    0,  /* (232) analyze_opt ::= */
+   -1,  /* (233) analyze_opt ::= ANALYZE */
+    0,  /* (234) explain_options ::= */
+   -3,  /* (235) explain_options ::= explain_options VERBOSE NK_BOOL */
+   -3,  /* (236) explain_options ::= explain_options RATIO NK_FLOAT */
+   -6,  /* (237) cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP */
+  -10,  /* (238) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */
+   -4,  /* (239) cmd ::= DROP FUNCTION exists_opt function_name */
+    0,  /* (240) agg_func_opt ::= */
+   -1,  /* (241) agg_func_opt ::= AGGREGATE */
+    0,  /* (242) bufsize_opt ::= */
+   -2,  /* (243) bufsize_opt ::= BUFSIZE NK_INTEGER */
+   -8,  /* (244) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options into_opt AS query_expression */
+   -4,  /* (245) cmd ::= DROP STREAM exists_opt stream_name */
+    0,  /* (246) into_opt ::= */
+   -2,  /* (247) into_opt ::= INTO full_table_name */
+    0,  /* (248) stream_options ::= */
+   -3,  /* (249) stream_options ::= stream_options TRIGGER AT_ONCE */
+   -3,  /* (250) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */
+   -3,  /* (251) stream_options ::= stream_options WATERMARK duration_literal */
+   -3,  /* (252) cmd ::= KILL CONNECTION NK_INTEGER */
+   -3,  /* (253) cmd ::= KILL QUERY NK_INTEGER */
+   -3,  /* (254) cmd ::= KILL TRANSACTION NK_INTEGER */
+   -4,  /* (255) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */
+   -4,  /* (256) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */
+   -3,  /* (257) cmd ::= SPLIT VGROUP NK_INTEGER */
+   -2,  /* (258) dnode_list ::= DNODE NK_INTEGER */
+   -3,  /* (259) dnode_list ::= dnode_list DNODE NK_INTEGER */
+   -3,  /* (260) cmd ::= SYNCDB db_name REPLICA */
+   -1,  /* (261) cmd ::= query_expression */
+   -1,  /* (262) literal ::= NK_INTEGER */
+   -1,  /* (263) literal ::= NK_FLOAT */
+   -1,  /* (264) literal ::= NK_STRING */
+   -1,  /* (265) literal ::= NK_BOOL */
+   -2,  /* (266) literal ::= TIMESTAMP NK_STRING */
+   -1,  /* (267) literal ::= duration_literal */
+   -1,  /* (268) literal ::= NULL */
+   -1,  /* (269) literal ::= NK_QUESTION */
+   -1,  /* (270) duration_literal ::= NK_VARIABLE */
+   -1,  /* (271) signed ::= NK_INTEGER */
+   -2,  /* (272) signed ::= NK_PLUS NK_INTEGER */
+   -2,  /* (273) signed ::= NK_MINUS NK_INTEGER */
+   -1,  /* (274) signed ::= NK_FLOAT */
+   -2,  /* (275) signed ::= NK_PLUS NK_FLOAT */
+   -2,  /* (276) signed ::= NK_MINUS NK_FLOAT */
+   -1,  /* (277) signed_literal ::= signed */
+   -1,  /* (278) signed_literal ::= NK_STRING */
+   -1,  /* (279) signed_literal ::= NK_BOOL */
+   -2,  /* (280) signed_literal ::= TIMESTAMP NK_STRING */
+   -1,  /* (281) signed_literal ::= duration_literal */
+   -1,  /* (282) signed_literal ::= NULL */
+   -1,  /* (283) signed_literal ::= literal_func */
+   -1,  /* (284) literal_list ::= signed_literal */
+   -3,  /* (285) literal_list ::= literal_list NK_COMMA signed_literal */
+   -1,  /* (286) db_name ::= NK_ID */
+   -1,  /* (287) table_name ::= NK_ID */
+   -1,  /* (288) column_name ::= NK_ID */
+   -1,  /* (289) function_name ::= NK_ID */
+   -1,  /* (290) table_alias ::= NK_ID */
+   -1,  /* (291) column_alias ::= NK_ID */
+   -1,  /* (292) user_name ::= NK_ID */
+   -1,  /* (293) index_name ::= NK_ID */
+   -1,  /* (294) topic_name ::= NK_ID */
+   -1,  /* (295) stream_name ::= NK_ID */
+   -1,  /* (296) cgroup_name ::= NK_ID */
+   -1,  /* (297) expression ::= literal */
+   -1,  /* (298) expression ::= pseudo_column */
+   -1,  /* (299) expression ::= column_reference */
+   -1,  /* (300) expression ::= function_expression */
+   -1,  /* (301) expression ::= subquery */
+   -3,  /* (302) expression ::= NK_LP expression NK_RP */
+   -2,  /* (303) expression ::= NK_PLUS expression */
+   -2,  /* (304) expression ::= NK_MINUS expression */
+   -3,  /* (305) expression ::= expression NK_PLUS expression */
+   -3,  /* (306) expression ::= expression NK_MINUS expression */
+   -3,  /* (307) expression ::= expression NK_STAR expression */
+   -3,  /* (308) expression ::= expression NK_SLASH expression */
+   -3,  /* (309) expression ::= expression NK_REM expression */
+   -3,  /* (310) expression ::= column_reference NK_ARROW NK_STRING */
+   -1,  /* (311) expression_list ::= expression */
+   -3,  /* (312) expression_list ::= expression_list NK_COMMA expression */
+   -1,  /* (313) column_reference ::= column_name */
+   -3,  /* (314) column_reference ::= table_name NK_DOT column_name */
+   -1,  /* (315) pseudo_column ::= ROWTS */
+   -1,  /* (316) pseudo_column ::= TBNAME */
+   -3,  /* (317) pseudo_column ::= table_name NK_DOT TBNAME */
+   -1,  /* (318) pseudo_column ::= QSTARTTS */
+   -1,  /* (319) pseudo_column ::= QENDTS */
+   -1,  /* (320) pseudo_column ::= WSTARTTS */
+   -1,  /* (321) pseudo_column ::= WENDTS */
+   -1,  /* (322) pseudo_column ::= WDURATION */
+   -4,  /* (323) function_expression ::= function_name NK_LP expression_list NK_RP */
+   -4,  /* (324) function_expression ::= star_func NK_LP star_func_para_list NK_RP */
+   -6,  /* (325) function_expression ::= CAST NK_LP expression AS type_name NK_RP */
+   -1,  /* (326) function_expression ::= literal_func */
+   -3,  /* (327) literal_func ::= noarg_func NK_LP NK_RP */
+   -1,  /* (328) literal_func ::= NOW */
+   -1,  /* (329) noarg_func ::= NOW */
+   -1,  /* (330) noarg_func ::= TODAY */
+   -1,  /* (331) noarg_func ::= TIMEZONE */
+   -1,  /* (332) star_func ::= COUNT */
+   -1,  /* (333) star_func ::= FIRST */
+   -1,  /* (334) star_func ::= LAST */
+   -1,  /* (335) star_func ::= LAST_ROW */
+   -1,  /* (336) star_func_para_list ::= NK_STAR */
+   -1,  /* (337) star_func_para_list ::= other_para_list */
+   -1,  /* (338) other_para_list ::= star_func_para */
+   -3,  /* (339) other_para_list ::= other_para_list NK_COMMA star_func_para */
+   -1,  /* (340) star_func_para ::= expression */
+   -3,  /* (341) star_func_para ::= table_name NK_DOT NK_STAR */
+   -3,  /* (342) predicate ::= expression compare_op expression */
+   -5,  /* (343) predicate ::= expression BETWEEN expression AND expression */
+   -6,  /* (344) predicate ::= expression NOT BETWEEN expression AND expression */
+   -3,  /* (345) predicate ::= expression IS NULL */
+   -4,  /* (346) predicate ::= expression IS NOT NULL */
+   -3,  /* (347) predicate ::= expression in_op in_predicate_value */
+   -1,  /* (348) compare_op ::= NK_LT */
+   -1,  /* (349) compare_op ::= NK_GT */
+   -1,  /* (350) compare_op ::= NK_LE */
+   -1,  /* (351) compare_op ::= NK_GE */
+   -1,  /* (352) compare_op ::= NK_NE */
+   -1,  /* (353) compare_op ::= NK_EQ */
+   -1,  /* (354) compare_op ::= LIKE */
+   -2,  /* (355) compare_op ::= NOT LIKE */
+   -1,  /* (356) compare_op ::= MATCH */
+   -1,  /* (357) compare_op ::= NMATCH */
+   -1,  /* (358) compare_op ::= CONTAINS */
+   -1,  /* (359) in_op ::= IN */
+   -2,  /* (360) in_op ::= NOT IN */
+   -3,  /* (361) in_predicate_value ::= NK_LP expression_list NK_RP */
+   -1,  /* (362) boolean_value_expression ::= boolean_primary */
+   -2,  /* (363) boolean_value_expression ::= NOT boolean_primary */
+   -3,  /* (364) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */
+   -3,  /* (365) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */
+   -1,  /* (366) boolean_primary ::= predicate */
+   -3,  /* (367) boolean_primary ::= NK_LP boolean_value_expression NK_RP */
+   -1,  /* (368) common_expression ::= expression */
+   -1,  /* (369) common_expression ::= boolean_value_expression */
+   -2,  /* (370) from_clause ::= FROM table_reference_list */
+   -1,  /* (371) table_reference_list ::= table_reference */
+   -3,  /* (372) table_reference_list ::= table_reference_list NK_COMMA table_reference */
+   -1,  /* (373) table_reference ::= table_primary */
+   -1,  /* (374) table_reference ::= joined_table */
+   -2,  /* (375) table_primary ::= table_name alias_opt */
+   -4,  /* (376) table_primary ::= db_name NK_DOT table_name alias_opt */
+   -2,  /* (377) table_primary ::= subquery alias_opt */
+   -1,  /* (378) table_primary ::= parenthesized_joined_table */
+    0,  /* (379) alias_opt ::= */
+   -1,  /* (380) alias_opt ::= table_alias */
+   -2,  /* (381) alias_opt ::= AS table_alias */
+   -3,  /* (382) parenthesized_joined_table ::= NK_LP joined_table NK_RP */
+   -3,  /* (383) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */
+   -6,  /* (384) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */
+    0,  /* (385) join_type ::= */
+   -1,  /* (386) join_type ::= INNER */
+   -9,  /* (387) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */
+    0,  /* (388) set_quantifier_opt ::= */
+   -1,  /* (389) set_quantifier_opt ::= DISTINCT */
+   -1,  /* (390) set_quantifier_opt ::= ALL */
+   -1,  /* (391) select_list ::= NK_STAR */
+   -1,  /* (392) select_list ::= select_sublist */
+   -1,  /* (393) select_sublist ::= select_item */
+   -3,  /* (394) select_sublist ::= select_sublist NK_COMMA select_item */
+   -1,  /* (395) select_item ::= common_expression */
+   -2,  /* (396) select_item ::= common_expression column_alias */
+   -3,  /* (397) select_item ::= common_expression AS column_alias */
+   -3,  /* (398) select_item ::= table_name NK_DOT NK_STAR */
+    0,  /* (399) where_clause_opt ::= */
+   -2,  /* (400) where_clause_opt ::= WHERE search_condition */
+    0,  /* (401) partition_by_clause_opt ::= */
+   -3,  /* (402) partition_by_clause_opt ::= PARTITION BY expression_list */
+    0,  /* (403) twindow_clause_opt ::= */
+   -6,  /* (404) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */
+   -4,  /* (405) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */
+   -6,  /* (406) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */
+   -8,  /* (407) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */
+    0,  /* (408) sliding_opt ::= */
+   -4,  /* (409) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */
+    0,  /* (410) fill_opt ::= */
+   -4,  /* (411) fill_opt ::= FILL NK_LP fill_mode NK_RP */
+   -6,  /* (412) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */
+   -1,  /* (413) fill_mode ::= NONE */
+   -1,  /* (414) fill_mode ::= PREV */
+   -1,  /* (415) fill_mode ::= NULL */
+   -1,  /* (416) fill_mode ::= LINEAR */
+   -1,  /* (417) fill_mode ::= NEXT */
+    0,  /* (418) group_by_clause_opt ::= */
+   -3,  /* (419) group_by_clause_opt ::= GROUP BY group_by_list */
+   -1,  /* (420) group_by_list ::= expression */
+   -3,  /* (421) group_by_list ::= group_by_list NK_COMMA expression */
+    0,  /* (422) having_clause_opt ::= */
+   -2,  /* (423) having_clause_opt ::= HAVING search_condition */
+   -4,  /* (424) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */
+   -1,  /* (425) query_expression_body ::= query_primary */
+   -4,  /* (426) query_expression_body ::= query_expression_body UNION ALL query_expression_body */
+   -3,  /* (427) query_expression_body ::= query_expression_body UNION query_expression_body */
+   -1,  /* (428) query_primary ::= query_specification */
+   -6,  /* (429) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */
+    0,  /* (430) order_by_clause_opt ::= */
+   -3,  /* (431) order_by_clause_opt ::= ORDER BY sort_specification_list */
+    0,  /* (432) slimit_clause_opt ::= */
+   -2,  /* (433) slimit_clause_opt ::= SLIMIT NK_INTEGER */
+   -4,  /* (434) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */
+   -4,  /* (435) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+    0,  /* (436) limit_clause_opt ::= */
+   -2,  /* (437) limit_clause_opt ::= LIMIT NK_INTEGER */
+   -4,  /* (438) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */
+   -4,  /* (439) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */
+   -3,  /* (440) subquery ::= NK_LP query_expression NK_RP */
+   -1,  /* (441) search_condition ::= common_expression */
+   -1,  /* (442) sort_specification_list ::= sort_specification */
+   -3,  /* (443) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */
+   -3,  /* (444) sort_specification ::= expression ordering_specification_opt null_ordering_opt */
+    0,  /* (445) ordering_specification_opt ::= */
+   -1,  /* (446) ordering_specification_opt ::= ASC */
+   -1,  /* (447) ordering_specification_opt ::= DESC */
+    0,  /* (448) null_ordering_opt ::= */
+   -2,  /* (449) null_ordering_opt ::= NULLS FIRST */
+   -2,  /* (450) null_ordering_opt ::= NULLS LAST */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -3035,14 +3512,17 @@ static YYACTIONTYPE yy_reduce(
   yymsp = yypParser->yytos;
 #ifndef NDEBUG
   if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
-    yysize = yyRuleInfo[yyruleno].nrhs;
+    yysize = yyRuleInfoNRhs[yyruleno];
     if( yysize ){
-      fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n",
+      fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
         yyTracePrompt,
-        yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno);
+        yyruleno, yyRuleName[yyruleno],
+        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
+        yymsp[yysize].stateno);
     }else{
-      fprintf(yyTraceFILE, "%sReduce %d [%s].\n",
-        yyTracePrompt, yyruleno, yyRuleName[yyruleno]);
+      fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
+        yyTracePrompt, yyruleno, yyRuleName[yyruleno],
+        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
     }
   }
 #endif /* NDEBUG */
@@ -3050,7 +3530,7 @@ static YYACTIONTYPE yy_reduce(
   /* Check that the stack is large enough to grow by a single entry
   ** if the RHS of the rule is empty.  This ensures that there is room
   ** enough on the stack to push the LHS value */
-  if( yyRuleInfo[yyruleno].nrhs==0 ){
+  if( yyRuleInfoNRhs[yyruleno]==0 ){
 #ifdef YYTRACKMAXSTACKDEPTH
     if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
       yypParser->yyhwm++;
@@ -4406,9 +4886,9 @@ static YYACTIONTYPE yy_reduce(
         break;
 /********** End reduce actions ************************************************/
   };
-  assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
-  yygoto = yyRuleInfo[yyruleno].lhs;
-  yysize = yyRuleInfo[yyruleno].nrhs;
+  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
+  yygoto = yyRuleInfoLhs[yyruleno];
+  yysize = yyRuleInfoNRhs[yyruleno];
   yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
 
   /* There are no SHIFTREDUCE actions on nonterminals because the table
@@ -4695,11 +5175,10 @@ void Parse(
 */
 int ParseFallback(int iToken){
 #ifdef YYFALLBACK
-  if( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ){
-    return yyFallback[iToken];
-  }
+  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
+  return yyFallback[iToken];
 #else
   (void)iToken;
-#endif
   return 0;
+#endif
 }

source/libs/scalar/test/scalar/CMakeLists.txt

@@ -17,9 +17,7 @@ TARGET_INCLUDE_DIRECTORIES(
         PUBLIC "${TD_SOURCE_DIR}/source/libs/parser/inc"
         PRIVATE "${TD_SOURCE_DIR}/source/libs/scalar/inc"
 )
-if(NOT TD_WINDOWS)
-        add_test(
-                NAME scalarTest
-                COMMAND scalarTest
-        )
-endif(NOT TD_WINDOWS)
+add_test(
+        NAME scalarTest
+        COMMAND scalarTest
+)

source/libs/stream/src/tstream.c

@@ -35,6 +35,16 @@ void* streamDataBlockDecode(const void* buf, SStreamDataBlock* pInput) {
   return (void*)buf;
 }
 
+SStreamDataSubmit* streamSubmitRefClone(SStreamDataSubmit* pSubmit) {
+  SStreamDataSubmit* pSubmitClone = taosAllocateQitem(sizeof(SStreamDataSubmit), DEF_QITEM);
+  if (pSubmitClone == NULL) {
+    return NULL;
+  }
+  streamDataSubmitRefInc(pSubmit);
+  memcpy(pSubmitClone, pSubmit, sizeof(SStreamDataSubmit));
+  return pSubmitClone;
+}
+
 static int32_t streamBuildDispatchMsg(SStreamTask* pTask, SArray* data, SRpcMsg* pMsg, SEpSet** ppEpSet) {
   SStreamDispatchReq req = {
       .streamId = pTask->streamId,
@@ -207,7 +217,6 @@ int32_t streamExec(SStreamTask* pTask, SMsgCb* pMsgCb) {
   if (pRes == NULL) return -1;
   while (1) {
     int8_t execStatus = atomic_val_compare_exchange_8(&pTask->status, TASK_STATUS__IDLE, TASK_STATUS__EXECUTING);
-    void*  exec = pTask->exec.executor;
     if (execStatus == TASK_STATUS__IDLE) {
       // first run, from qall, handle failure from last exec
       pRes = streamExecForQall(pTask, pRes);

tests/pytest/util/dnodes.py

@@ -397,6 +397,7 @@ class TDDnode:
     def stop(self):
         if (not self.remoteIP == ""):
             self.remoteExec(self.cfgDict, "tdDnodes.stop(%d)"%self.index)
+            tdLog.info("stop dnode%d"%self.index)
             return
         if self.valgrind == 0:
             toBeKilled = "taosd"

tests/script/tsim/db/alter_replica_13.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/deploy.sh -n dnode2 -i 2
+system sh/deploy.sh -n dnode3 -i 3
+system sh/deploy.sh -n dnode4 -i 4
+system sh/exec.sh -n dnode1 -s start
+system sh/exec.sh -n dnode2 -s start
+system sh/exec.sh -n dnode3 -s start
+system sh/exec.sh -n dnode4 -s start
+sql connect
+
+print =============== step1: create dnodes
+sql create dnode $hostname port 7200
+
+$loop_cnt = 0
+step1:
+	$loop_cnt = $loop_cnt + 1
+	sleep 1000
+	if $loop_cnt == 10 then
+	  print ====> dnode not ready!
+		return -1
+	endi
+sql show dnodes
+print ===> $data00 $data01 $data02 $data03 $data04 $data05
+print ===> $data10 $data11 $data12 $data13 $data14 $data15
+if $rows != 2 then
+  return -1
+endi
+if $data(1)[4] != ready then
+  goto step1
+endi
+if $data(2)[4] != ready then
+  goto step1
+endi
+
+print =============== step2: create database
+sql create database db vgroups 1
+sql show databases
+if $rows != 3 then 
+  return -1
+endi
+if $data(db)[4] != 1 then 
+  return -1
+endi
+
+sql show dnodes
+if $data(2)[2] != 1 then
+  return -1
+endi
+
+# vnodes
+sql show dnodes
+if $data(2)[2] != 1 then
+  return -1
+endi
+
+# v1_dnode
+sql show db.vgroups
+if $data(2)[3] != 2 then
+  return -1
+endi
+
+sql_error alter database db replica 3
+sql create table db.stb (ts timestamp, c1 int, c2 binary(4)) tags(t1 int, t2 binary(16)) comment "abd"
+sql create table db.ctb using db.stb tags(101, "102")
+sql insert into db.ctb values(now, 1, "2")
+sql select * from db.stb
+if $rows != 1 then
+  return -1
+endi
+
+print =============== step3: create dnodes
+sql create dnode $hostname port 7300
+sql create dnode $hostname port 7400
+
+$loop_cnt = 0
+step3:
+	$loop_cnt = $loop_cnt + 1
+	sleep 1000
+	if $loop_cnt == 10 then
+	  print ====> dnode not ready!
+		return -1
+	endi
+sql show dnodes
+print ===> rows: $rows 
+print ===> $data00 $data01 $data02 $data03 $data04 $data05
+print ===> $data10 $data11 $data12 $data13 $data14 $data15
+print ===> $data20 $data21 $data22 $data23 $data24 $data25
+print ===> $data30 $data31 $data32 $data33 $data24 $data35
+if $rows != 4 then
+  return -1
+endi
+if $data(1)[4] != ready then
+  goto step3
+endi
+if $data(2)[4] != ready then
+  goto step3
+endi
+if $data(3)[4] != ready then
+  goto step3
+endi
+if $data(4)[4] != ready then
+  goto step3
+endi
+
+return
+print ============= step4: alter database
+sql alter database db replica 3
+if $rows != 3 then 
+  return -1
+endi
+if $data(db)[4] != 3 then 
+  return -1
+endi
+
+sql select * from db.stb
+if $rows != 1 then
+  return -1
+endi
+
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+system sh/exec.sh -n dnode2 -s stop -x SIGINT
+system sh/exec.sh -n dnode3 -s stop -x SIGINT

tests/system-test/0-others/taosShell.py

@@ -84,6 +84,12 @@ class TDTestCase:
     #updatecfgDict = {'clientCfg': {'serverPort': 7080, 'firstEp': 'trd02:7080', 'secondEp':'trd02:7080'},\
     #                 'serverPort': 7080, 'firstEp': 'trd02:7080'}
     hostname = socket.gethostname()
+    if (platform.system().lower() == 'windows' and not tdDnodes.dnodes[0].remoteIP == ""):
+        try:
+            config = eval(tdDnodes.dnodes[0].remoteIP)
+            hostname = config["host"]
+        except Exception:
+            hostname = tdDnodes.dnodes[0].remoteIP
     serverPort = '7080'
     rpcDebugFlagVal = '143'
     clientCfgDict = {'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}

tests/system-test/0-others/taosShellError.py

@@ -86,6 +86,12 @@ class TDTestCase:
     #updatecfgDict = {'clientCfg': {'serverPort': 7080, 'firstEp': 'trd02:7080', 'secondEp':'trd02:7080'},\
     #                 'serverPort': 7080, 'firstEp': 'trd02:7080'}
     hostname = socket.gethostname()
+    if (platform.system().lower() == 'windows' and not tdDnodes.dnodes[0].remoteIP == ""):
+        try:
+            config = eval(tdDnodes.dnodes[0].remoteIP)
+            hostname = config["host"]
+        except Exception:
+            hostname = tdDnodes.dnodes[0].remoteIP
     serverPort = '7080'
     rpcDebugFlagVal = '143'
     clientCfgDict = {'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}

tests/system-test/0-others/taosShellNetChk.py

@@ -86,6 +86,12 @@ class TDTestCase:
     #updatecfgDict = {'clientCfg': {'serverPort': 7080, 'firstEp': 'trd02:7080', 'secondEp':'trd02:7080'},\
     #                 'serverPort': 7080, 'firstEp': 'trd02:7080'}
     hostname = socket.gethostname()
+    if (platform.system().lower() == 'windows' and not tdDnodes.dnodes[0].remoteIP == ""):
+        try:
+            config = eval(tdDnodes.dnodes[0].remoteIP )
+            hostname = config["host"]
+        except Exception:
+            hostname = tdDnodes.dnodes[0].remoteIP
     serverPort = '7080'
     rpcDebugFlagVal = '143'
     clientCfgDict = {'serverPort': '', 'firstEp': '', 'secondEp':'', 'rpcDebugFlag':'135', 'fqdn':''}
@@ -196,7 +202,7 @@ class TDTestCase:
         pktNum = '10'
         role   = 'client'
         if platform.system().lower() == 'windows':
-            taosCmd = buildPath + '\\build\\bin\\taos.exe -c ' + keyDict['c']
+            taosCmd = buildPath + '\\build\\bin\\taos.exe -h 127.0.0.1 -c ' + keyDict['c']
             taosCmd = taosCmd.replace('\\','\\\\')
         else:
             taosCmd = buildPath + '/build/bin/taos -c ' + keyDict['c']