Merge remote-tracking branch 'origin/3.0' into feature/qnode

.devcontainer/devcontainer.json

@@ -28,5 +28,5 @@
 	// "postCreateCommand": "gcc -v",
 
 	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-	"remoteUser": "vscode"
+	"remoteUser": "root"
 }

contrib/test/tdev/src/main.c

@@ -14,6 +14,10 @@
 
 #define tPutB(buf, val)                         \
   ({                                            \
+    ((uint8_t *)buf)[7] = ((val) >> 56) & 0xff; \
+    ((uint8_t *)buf)[6] = ((val) >> 48) & 0xff; \
+    ((uint8_t *)buf)[5] = ((val) >> 40) & 0xff; \
+    ((uint8_t *)buf)[4] = ((val) >> 32) & 0xff; \
     ((uint8_t *)buf)[3] = ((val) >> 24) & 0xff; \
     ((uint8_t *)buf)[2] = ((val) >> 16) & 0xff; \
     ((uint8_t *)buf)[1] = ((val) >> 8) & 0xff;  \
@@ -21,13 +25,33 @@
     POINTER_SHIFT(buf, sizeof(val));            \
   })
 
-#define tPutC(buf, val)              \
+#define tPutC(buf, val)                \
-  ({                                 \
+  ({                                   \
-    ((uint64_t *)buf)[0] = (val);    \
+    if (buf) {                         \
-    POINTER_SHIFT(buf, sizeof(val)); \
+      ((uint64_t *)buf)[0] = (val);    \
+      POINTER_SHIFT(buf, sizeof(val)); \
+    }                                  \
+    NULL;                                 \
   })
 
-typedef enum { A, B, C } T;
+#define tPutD(buf, val)                        \
+  ({                                           \
+    uint64_t tmp = val;                        \
+    for (size_t i = 0; i < sizeof(val); i++) { \
+      ((uint8_t *)buf)[i] = tmp & 0xff;        \
+      tmp >>= 8;                               \
+    }                                          \
+    POINTER_SHIFT(buf, sizeof(val));           \
+  })
+
+static inline void tPutE(void **buf, uint64_t val) {
+  if (buf) {
+    ((uint64_t *)(*buf))[0] = val;
+    *buf = POINTER_SHIFT(*buf, sizeof(val));
+  }
+}
+
+typedef enum { A, B, C, D, E } T;
 
 static void func(T t) {
   uint64_t val = 198;
@@ -59,6 +83,22 @@ static void func(T t) {
         }
       }
       break;
+    case D:
+      for (size_t i = 0; i < 10 * 1024l * 1024l * 1024l; i++) {
+        pBuf = tPutD(pBuf, val);
+        if (POINTER_DISTANCE(buf, pBuf) == 1024) {
+          pBuf = buf;
+        }
+      }
+      break;
+    case E:
+      for (size_t i = 0; i < 10 * 1024l * 1024l * 1024l; i++) {
+        tPutE(&pBuf, val);
+        if (POINTER_DISTANCE(buf, pBuf) == 1024) {
+          pBuf = buf;
+        }
+      }
+      break;
 
     default:
       break;
@@ -83,5 +123,11 @@ int main(int argc, char const *argv[]) {
   func(C);
   uint64_t t4 = now();
   printf("C: %ld\n", t4 - t3);
+  func(D);
+  uint64_t t5 = now();
+  printf("D: %ld\n", t5 - t4);
+  func(E);
+  uint64_t t6 = now();
+  printf("E: %ld\n", t6 - t5);
   return 0;
 }

include/common/tmsg.h

@@ -20,6 +20,7 @@
 extern "C" {
 #endif
 
+#include "encode.h"
 #include "taosdef.h"
 #include "taoserror.h"
 #include "tcoding.h"
@@ -299,12 +300,12 @@ typedef struct SEpSet {
 } SEpSet;
 
 typedef struct {
-  int32_t  acctId;
+  int32_t acctId;
-  int64_t  clusterId;
+  int64_t clusterId;
-  int32_t  connId;
+  int32_t connId;
-  int8_t   superUser;
+  int8_t  superUser;
-  int8_t   reserved[5];
+  int8_t  reserved[5];
-  SEpSet   epSet;
+  SEpSet  epSet;
 } SConnectRsp;
 
 typedef struct {
@@ -641,8 +642,6 @@ typedef struct {
 typedef struct {
   int32_t dnodeId;
   int64_t clusterId;
-  int8_t  dropped;
-  char    reserved[7];
 } SDnodeCfg;
 
 typedef struct {
@@ -1057,9 +1056,9 @@ typedef struct STaskDropRsp {
 } STaskDropRsp;
 
 typedef struct {
-  int8_t  igExists;
+  int8_t igExists;
-  char*   name;
+  char*  name;
-  char*   phyPlan;
+  char*  phyPlan;
 } SCMCreateTopicReq;
 
 static FORCE_INLINE int tSerializeSCMCreateTopicReq(void** buf, const SCMCreateTopicReq* pReq) {
@@ -1239,6 +1238,31 @@ static FORCE_INLINE void* tDeserializeSVCreateTbReq(void* buf, SVCreateTbReq* pR
 typedef struct SVCreateTbRsp {
 } SVCreateTbRsp;
 
+typedef struct SVShowTablesReq {
+  SMsgHead head;
+} SVShowTablesReq;
+
+typedef struct SVShowTablesRsp {
+  int64_t       id;
+  STableMetaMsg metaInfo;
+} SVShowTablesRsp;
+
+typedef struct SVShowTablesFetchReq {
+  SMsgHead head;
+  int64_t  id;
+} SVShowTablesFetchReq;
+
+typedef struct SVShowTablesFetchRsp {
+  int64_t useconds;
+  int8_t  completed;  // all results are returned to client
+  int8_t  precision;
+  int8_t  compressed;
+  int32_t compLen;
+
+  int32_t numOfRows;
+  char    data[];
+} SVShowTablesFetchRsp;
+
 #pragma pack(pop)
 
 #ifdef __cplusplus

include/common/tmsgdef.h

@@ -146,6 +146,8 @@ enum {
   TD_DEF_MSG_TYPE(TDMT_VND_CREATE_TOPIC, "vnode-create-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_ALTER_TOPIC, "vnode-alter-topic", NULL, NULL)
   TD_DEF_MSG_TYPE(TDMT_VND_DROP_TOPIC, "vnode-drop-topic", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_SHOW_TABLES, "vnode-show-tables", SVShowTablesReq, SVShowTablesRsp)
+  TD_DEF_MSG_TYPE(TDMT_VND_SHOW_TABLES_FETCH, "vnode-show-tables-fetch", SVShowTablesFetchReq, SVShowTablesFetchRsp)
 
   // Requests handled by QNODE
   TD_NEW_MSG_SEG(TDMT_QND_MSG)

include/dnode/mnode/sdb/sdb.h

@@ -25,7 +25,7 @@ extern "C" {
 #define SDB_GET_INT64(pData, pRow, dataPos, val)   \
   {                                                \
     if (sdbGetRawInt64(pRaw, dataPos, val) != 0) { \
-      sdbFreeRow(pRow);                            \
+      tfree(pRow);                                 \
       return NULL;                                 \
     }                                              \
     dataPos += sizeof(int64_t);                    \
@@ -34,7 +34,7 @@ extern "C" {
 #define SDB_GET_INT32(pData, pRow, dataPos, val)   \
   {                                                \
     if (sdbGetRawInt32(pRaw, dataPos, val) != 0) { \
-      sdbFreeRow(pRow);                            \
+      tfree(pRow);                                 \
       return NULL;                                 \
     }                                              \
     dataPos += sizeof(int32_t);                    \
@@ -43,7 +43,7 @@ extern "C" {
 #define SDB_GET_INT16(pData, pRow, dataPos, val)   \
   {                                                \
     if (sdbGetRawInt16(pRaw, dataPos, val) != 0) { \
-      sdbFreeRow(pRow);                            \
+      tfree(pRow);                                 \
       return NULL;                                 \
     }                                              \
     dataPos += sizeof(int16_t);                    \
@@ -52,7 +52,7 @@ extern "C" {
 #define SDB_GET_INT8(pData, pRow, dataPos, val)   \
   {                                               \
     if (sdbGetRawInt8(pRaw, dataPos, val) != 0) { \
-      sdbFreeRow(pRow);                           \
+      tfree(pRow);                                \
       return NULL;                                \
     }                                             \
     dataPos += sizeof(int8_t);                    \
@@ -61,7 +61,7 @@ extern "C" {
 #define SDB_GET_BINARY(pRaw, pRow, dataPos, val, valLen)    \
   {                                                         \
     if (sdbGetRawBinary(pRaw, dataPos, val, valLen) != 0) { \
-      sdbFreeRow(pRow);                                     \
+      tfree(pRow);                                          \
       return NULL;                                          \
     }                                                       \
     dataPos += valLen;                                      \
@@ -71,7 +71,7 @@ extern "C" {
   {                                                         \
     char val[valLen] = {0};                                 \
     if (sdbGetRawBinary(pRaw, dataPos, val, valLen) != 0) { \
-      sdbFreeRow(pRow);                                     \
+      tfree(pRow);                                          \
       return NULL;                                          \
     }                                                       \
     dataPos += valLen;                                      \
@@ -325,7 +325,7 @@ int32_t  sdbGetRawSoftVer(SSdbRaw *pRaw, int8_t *sver);
 int32_t  sdbGetRawTotalSize(SSdbRaw *pRaw);
 
 SSdbRow *sdbAllocRow(int32_t objSize);
-void     sdbFreeRow(SSdbRow *pRow);
+void     sdbFreeRow(SSdb *pSdb, SSdbRow *pRow);
 void    *sdbGetRowObj(SSdbRow *pRow);
 
 #ifdef __cplusplus

include/dnode/vnode/meta/meta.h

@@ -18,8 +18,8 @@
 
 #include "mallocator.h"
 #include "os.h"
-#include "trow.h"
 #include "tmsg.h"
+#include "trow.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -47,35 +47,13 @@ int    metaCreateTable(SMeta *pMeta, STbCfg *pTbCfg);
 int    metaDropTable(SMeta *pMeta, tb_uid_t uid);
 int    metaCommit(SMeta *pMeta);
 
+// For Query
+int metaGetTableInfo(SMeta *pMeta, char *tbname, STableMetaMsg **ppMsg);
+
 // Options
 void metaOptionsInit(SMetaCfg *pMetaCfg);
 void metaOptionsClear(SMetaCfg *pMetaCfg);
 
-// STbCfg
-#define META_INIT_STB_CFG(NAME, TTL, KEEP, SUID, PSCHEMA, PTAGSCHEMA)                   \
-  {                                                                                     \
-    .name = (NAME), .ttl = (TTL), .keep = (KEEP), .type = META_SUPER_TABLE, .stbCfg = { \
-      .suid = (SUID),                                                                   \
-      .pSchema = (PSCHEMA),                                                             \
-      .pTagSchema = (PTAGSCHEMA)                                                        \
-    }                                                                                   \
-  }
-
-#define META_INIT_CTB_CFG(NAME, TTL, KEEP, SUID, PTAG)                                                                \
-  {                                                                                                                   \
-    .name = (NAME), .ttl = (TTL), .keep = (KEEP), .type = META_CHILD_TABLE, .ctbCfg = {.suid = (SUID), .pTag = PTAG } \
-  }
-
-#define META_INIT_NTB_CFG(NAME, TTL, KEEP, SUID, PSCHEMA)                                                      \
-  {                                                                                                            \
-    .name = (NAME), .ttl = (TTL), .keep = (KEEP), .type = META_NORMAL_TABLE, .ntbCfg = {.pSchema = (PSCHEMA) } \
-  }
-
-#define META_CLEAR_TB_CFG(pTbCfg)
-
-int   metaEncodeTbCfg(void **pBuf, STbCfg *pTbCfg);
-void *metaDecodeTbCfg(void *pBuf, STbCfg *pTbCfg);
-
 #ifdef __cplusplus
 }
 #endif

include/dnode/vnode/vnode.h

@@ -162,16 +162,6 @@ int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
  */
 int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
 
-/**
- * @brief Process a consume message.
- *
- * @param pVnode The vnode object.
- * @param pMsg The request message
- * @param pRsp The response message
- * @return int 0 for success, -1 for failure
- */
-int vnodeProcessConsumeReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp);
-
 /* ------------------------ SVnodeCfg ------------------------ */
 /**
  * @brief Initialize VNODE options.
@@ -187,68 +177,6 @@ void vnodeOptionsInit(SVnodeCfg *pOptions);
  */
 void vnodeOptionsClear(SVnodeCfg *pOptions);
 
-/* ------------------------ REQUESTS ------------------------ */
-typedef STbCfg SVCreateTableReq;
-typedef struct {
-  tb_uid_t uid;
-} SVDropTableReq;
-
-typedef struct {
-  // TODO
-} SVSubmitReq;
-
-typedef struct {
-  uint64_t ver;
-  union {
-    SVCreateTableReq ctReq;
-    SVDropTableReq   dtReq;
-  };
-} SVnodeReq;
-
-typedef struct {
-  int  err;
-  char info[];
-} SVnodeRsp;
-
-static FORCE_INLINE void vnodeSetCreateStbReq(SVnodeReq *pReq, char *name, uint32_t ttl, uint32_t keep, tb_uid_t suid,
-                                              STSchema *pSchema, STSchema *pTagSchema) {
-  pReq->ver = 0;
-
-  pReq->ctReq.name = name;
-  pReq->ctReq.ttl = ttl;
-  pReq->ctReq.keep = keep;
-  pReq->ctReq.type = META_SUPER_TABLE;
-  pReq->ctReq.stbCfg.suid = suid;
-  pReq->ctReq.stbCfg.pSchema = pSchema;
-  pReq->ctReq.stbCfg.pTagSchema = pTagSchema;
-}
-
-static FORCE_INLINE void vnodeSetCreateCtbReq(SVnodeReq *pReq, char *name, uint32_t ttl, uint32_t keep, tb_uid_t suid,
-                                              SKVRow pTag) {
-  pReq->ver = 0;
-
-  pReq->ctReq.name = name;
-  pReq->ctReq.ttl = ttl;
-  pReq->ctReq.keep = keep;
-  pReq->ctReq.type = META_CHILD_TABLE;
-  pReq->ctReq.ctbCfg.suid = suid;
-  pReq->ctReq.ctbCfg.pTag = pTag;
-}
-
-static FORCE_INLINE void vnodeSetCreateNtbReq(SVnodeReq *pReq, char *name, uint32_t ttl, uint32_t keep,
-                                              STSchema *pSchema) {
-  pReq->ver = 0;
-
-  pReq->ctReq.name = name;
-  pReq->ctReq.ttl = ttl;
-  pReq->ctReq.keep = keep;
-  pReq->ctReq.type = META_NORMAL_TABLE;
-  pReq->ctReq.ntbCfg.pSchema = pSchema;
-}
-
-int   vnodeBuildReq(void **buf, const SVnodeReq *pReq, tmsg_t type);
-void *vnodeParseReq(void *buf, SVnodeReq *pReq, tmsg_t type);
-
 /* ------------------------ FOR COMPILE ------------------------ */
 
 int32_t vnodeAlter(SVnode *pVnode, const SVnodeCfg *pCfg);

include/libs/catalog/catalog.h

@@ -21,13 +21,14 @@ extern "C" {
 #endif
 
 #include "os.h"
-#include "thash.h"
-#include "tarray.h"
 #include "taosdef.h"
-#include "transport.h"
-#include "common.h"
-#include "tmsg.h"
 #include "query.h"
+#include "tname.h"
+#include "common.h"
+#include "tarray.h"
+#include "thash.h"
+#include "tmsg.h"
+#include "transport.h"
 
 struct SCatalog;
 
@@ -80,35 +81,32 @@ int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDB
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pDBName (input, full db name)
  * @param pTableName (input, table name, NOT including db name)
  * @param pTableMeta(output, table meta data, NEED to free it by calller)
  * @return error code
  */
-int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void * pTransporter, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta);
+int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void * pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta);
 
 /**
  * Force renew a table's local cached meta data. 
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pRpc (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pDBName (input, full db name)
  * @param pTableName (input, table name, NOT including db name)
  * @return error code
  */
-int32_t catalogRenewTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName);
+int32_t catalogRenewTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName);
 
 /**
  * Force renew a table's local cached meta data and get the new one. 
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pRpc (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pDBName (input, full db name)
  * @param pTableName (input, table name, NOT including db name)
  * @param pTableMeta(output, table meta data, NEED to free it by calller) 
  * @return error code
  */
-int32_t catalogRenewAndGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta);
+int32_t catalogRenewAndGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta);
 
 
 /**
@@ -116,24 +114,22 @@ int32_t catalogRenewAndGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pRpc (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pDBName (input, full db name)
  * @param pTableName (input, table name, NOT including db name)
  * @param pVgroupList (output, vgroup info list, element is SVgroupInfo, NEED to simply free the array by caller)
  * @return error code
  */
-int32_t catalogGetTableDistVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SArray** pVgroupList);
+int32_t catalogGetTableDistVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, SArray** pVgroupList);
 
 /**
  * Get a table's vgroup from its name's hash value.
  * @param pCatalog (input, got with catalogGetHandle)
  * @param pTransporter (input, rpc object)
  * @param pMgmtEps (input, mnode EPs)
- * @param pDBName (input, full db name)
  * @param pTableName (input, table name, NOT including db name)
  * @param vgInfo (output, vgroup info)
  * @return error code
  */
-int32_t catalogGetTableHashVgroup(struct SCatalog* pCatalog, void * pTransporter, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo);
+int32_t catalogGetTableHashVgroup(struct SCatalog* pCatalog, void * pTransporter, const SEpSet* pMgmtEps, const SName* pName, SVgroupInfo* vgInfo);
 
 
 /**

include/libs/parser/parser.h

@@ -27,7 +27,7 @@ typedef struct SParseContext {
   int8_t           schemaAttached; // denote if submit block is built with table schema or not
   const char      *pSql;           // sql string
   size_t           sqlLen;         // length of the sql string
-  char            *pMsg;           // extended error message if exists to help avoid the problem in sql statement.
+  char            *pMsg;           // extended error message if exists to help identifying the problem in sql statement.
   int32_t          msgLen;         // max length of the msg
 } SParseContext;
 

include/libs/qcom/query.h

@@ -23,6 +23,7 @@ extern "C" {
 #include "tarray.h"
 #include "thash.h"
 #include "tlog.h"
+#include "tmsg.h"
 
 enum {
   JOB_TASK_STATUS_NULL = 0,
@@ -73,7 +74,6 @@ typedef struct STableMeta {
   SSchema        schema[];
 } STableMeta;
 
-
 typedef struct SDBVgroupInfo {
   int32_t   lock;
   int32_t   vgVersion;  

include/os/osEndian.h

@@ -20,8 +20,11 @@
 extern "C" {
 #endif
 
+typedef enum { TD_LITTLE_ENDIAN = 0, TD_BIG_ENDIAN } td_endian_t;
+
 static const int32_t endian_test_var = 1;
 #define IS_LITTLE_ENDIAN() (*(uint8_t *)(&endian_test_var) != 0)
+#define TD_RT_ENDIAN() (IS_LITTLE_ENDIAN() ? TD_LITTLE_ENDIAN : TD_BIG_ENDIAN)
 
 #ifdef __cplusplus
 }

include/util/encode.h

@@ -0,0 +1,476 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _TD_UTIL_ENCODE_H_
+#define _TD_UTIL_ENCODE_H_
+
+#include "tcoding.h"
+#include "tmacro.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  td_endian_t endian;
+  uint8_t*    data;
+  int64_t     size;
+  int64_t     pos;
+} SEncoder, SDecoder;
+
+#define tPut(TYPE, BUF, VAL) ((TYPE*)(BUF))[0] = (VAL)
+#define tGet(TYPE, BUF, VAL) (VAL) = ((TYPE*)(BUF))[0]
+
+#define tRPut16(PDEST, PSRC)                      \
+  ((uint8_t*)(PDEST))[0] = ((uint8_t*)(PSRC))[1]; \
+  ((uint8_t*)(PDEST))[1] = ((uint8_t*)(PSRC))[0];
+
+#define tRPut32(PDEST, PSRC)                      \
+  ((uint8_t*)(PDEST))[0] = ((uint8_t*)(PSRC))[3]; \
+  ((uint8_t*)(PDEST))[1] = ((uint8_t*)(PSRC))[2]; \
+  ((uint8_t*)(PDEST))[2] = ((uint8_t*)(PSRC))[1]; \
+  ((uint8_t*)(PDEST))[3] = ((uint8_t*)(PSRC))[0];
+
+#define tRPut64(PDEST, PSRC)                      \
+  ((uint8_t*)(PDEST))[0] = ((uint8_t*)(PSRC))[7]; \
+  ((uint8_t*)(PDEST))[1] = ((uint8_t*)(PSRC))[6]; \
+  ((uint8_t*)(PDEST))[2] = ((uint8_t*)(PSRC))[5]; \
+  ((uint8_t*)(PDEST))[3] = ((uint8_t*)(PSRC))[4]; \
+  ((uint8_t*)(PDEST))[4] = ((uint8_t*)(PSRC))[3]; \
+  ((uint8_t*)(PDEST))[5] = ((uint8_t*)(PSRC))[2]; \
+  ((uint8_t*)(PDEST))[6] = ((uint8_t*)(PSRC))[1]; \
+  ((uint8_t*)(PDEST))[7] = ((uint8_t*)(PSRC))[0];
+
+#define tRGet16 tRPut16
+#define tRGet32 tRPut32
+#define tRGet64 tRPut64
+
+#define TD_CODER_CURRENT(CODER) ((CODER)->data + (CODER)->pos)
+#define TD_CODER_MOVE_POS(CODER, MOVE) ((CODER)->pos += (MOVE))
+#define TD_CHECK_CODER_CAPACITY_FAILED(CODER, EXPSIZE) (((CODER)->size - (CODER)->pos) < (EXPSIZE))
+
+/* ------------------------ FOR ENCODER ------------------------ */
+static FORCE_INLINE void tInitEncoder(SEncoder* pEncoder, td_endian_t endian, uint8_t* data, int64_t size) {
+  pEncoder->endian = endian;
+  pEncoder->data = data;
+  pEncoder->size = (data) ? size : 0;
+  pEncoder->pos = 0;
+}
+
+// 8
+static FORCE_INLINE int tEncodeU8(SEncoder* pEncoder, uint8_t val) {
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    tPut(uint8_t, TD_CODER_CURRENT(pEncoder), val);
+  }
+  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeI8(SEncoder* pEncoder, int8_t val) {
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    tPut(int8_t, TD_CODER_CURRENT(pEncoder), val);
+  }
+  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
+  return 0;
+}
+
+// 16
+static FORCE_INLINE int tEncodeU16(SEncoder* pEncoder, uint16_t val) {
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    if (TD_RT_ENDIAN() == pEncoder->endian) {
+      tPut(uint16_t, TD_CODER_CURRENT(pEncoder), val);
+    } else {
+      tRPut16(TD_CODER_CURRENT(pEncoder), &val);
+    }
+  }
+  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeI16(SEncoder* pEncoder, int16_t val) {
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    if (TD_RT_ENDIAN() == pEncoder->endian) {
+      tPut(int16_t, TD_CODER_CURRENT(pEncoder), val);
+    } else {
+      tRPut16(TD_CODER_CURRENT(pEncoder), &val);
+    }
+  }
+  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
+  return 0;
+}
+
+// 32
+static FORCE_INLINE int tEncodeU32(SEncoder* pEncoder, uint32_t val) {
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    if (TD_RT_ENDIAN() == pEncoder->endian) {
+      tPut(uint32_t, TD_CODER_CURRENT(pEncoder), val);
+    } else {
+      tRPut32(TD_CODER_CURRENT(pEncoder), &val);
+    }
+  }
+  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeI32(SEncoder* pEncoder, int32_t val) {
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    if (TD_RT_ENDIAN() == pEncoder->endian) {
+      tPut(int32_t, TD_CODER_CURRENT(pEncoder), val);
+    } else {
+      tRPut32(TD_CODER_CURRENT(pEncoder), &val);
+    }
+  }
+  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
+  return 0;
+}
+
+// 64
+static FORCE_INLINE int tEncodeU64(SEncoder* pEncoder, uint64_t val) {
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    if (TD_RT_ENDIAN() == pEncoder->endian) {
+      tPut(uint64_t, TD_CODER_CURRENT(pEncoder), val);
+    } else {
+      tRPut64(TD_CODER_CURRENT(pEncoder), &val);
+    }
+  }
+  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeI64(SEncoder* pEncoder, int64_t val) {
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, sizeof(val))) return -1;
+    if (TD_RT_ENDIAN() == pEncoder->endian) {
+      tPut(int64_t, TD_CODER_CURRENT(pEncoder), val);
+    } else {
+      tRPut64(TD_CODER_CURRENT(pEncoder), &val);
+    }
+  }
+  TD_CODER_MOVE_POS(pEncoder, sizeof(val));
+  return 0;
+}
+
+// 16v
+static FORCE_INLINE int tEncodeU16v(SEncoder* pEncoder, uint16_t val) {
+  int64_t i = 0;
+  while (val >= ENCODE_LIMIT) {
+    if (pEncoder->data) {
+      if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
+      TD_CODER_CURRENT(pEncoder)[i] = (val | ENCODE_LIMIT) & 0xff;
+    }
+
+    val >>= 7;
+    i++;
+  }
+
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
+    TD_CODER_CURRENT(pEncoder)[i] = (uint8_t)val;
+  }
+
+  TD_CODER_MOVE_POS(pEncoder, i + 1);
+
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeI16v(SEncoder* pEncoder, int16_t val) {
+  return tEncodeU16v(pEncoder, ZIGZAGE(int16_t, val));
+}
+
+// 32v
+static FORCE_INLINE int tEncodeU32v(SEncoder* pEncoder, uint32_t val) {
+  int64_t i = 0;
+  while (val >= ENCODE_LIMIT) {
+    if (pEncoder->data) {
+      if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
+      TD_CODER_CURRENT(pEncoder)[i] = (val | ENCODE_LIMIT) & 0xff;
+    }
+
+    val >>= 7;
+    i++;
+  }
+
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
+    TD_CODER_CURRENT(pEncoder)[i] = (uint8_t)val;
+  }
+
+  TD_CODER_MOVE_POS(pEncoder, i + 1);
+
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeI32v(SEncoder* pEncoder, int32_t val) {
+  return tEncodeU32v(pEncoder, ZIGZAGE(int32_t, val));
+}
+
+// 64v
+static FORCE_INLINE int tEncodeU64v(SEncoder* pEncoder, uint64_t val) {
+  int64_t i = 0;
+  while (val >= ENCODE_LIMIT) {
+    if (pEncoder->data) {
+      if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
+      TD_CODER_CURRENT(pEncoder)[i] = (val | ENCODE_LIMIT) & 0xff;
+    }
+
+    val >>= 7;
+    i++;
+  }
+
+  if (pEncoder->data) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pEncoder, 1)) return -1;
+    TD_CODER_CURRENT(pEncoder)[i] = (uint8_t)val;
+  }
+
+  TD_CODER_MOVE_POS(pEncoder, i + 1);
+
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeI64v(SEncoder* pEncoder, int64_t val) {
+  return tEncodeU64v(pEncoder, ZIGZAGE(int64_t, val));
+}
+
+static FORCE_INLINE int tEncodeFloat(SEncoder* pEncoder, float val) {
+  // TODO
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeDouble(SEncoder* pEncoder, double val) {
+  // TODO
+  return 0;
+}
+
+static FORCE_INLINE int tEncodeCStr(SEncoder* pEncoder, const char* val) {
+  // TODO
+  return 0;
+}
+
+/* ------------------------ FOR DECODER ------------------------ */
+static FORCE_INLINE void tInitDecoder(SDecoder* pDecoder, td_endian_t endian, uint8_t* data, int64_t size) {
+  ASSERT(!TD_IS_NULL(data));
+  pDecoder->endian = endian;
+  pDecoder->data = data;
+  pDecoder->size = size;
+  pDecoder->pos = 0;
+}
+
+// 8
+static FORCE_INLINE int tDecodeU8(SDecoder* pDecoder, uint8_t* val) {
+  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+  tGet(uint8_t, TD_CODER_CURRENT(pDecoder), *val);
+  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeI8(SDecoder* pDecoder, int8_t* val) {
+  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+  tGet(int8_t, TD_CODER_CURRENT(pDecoder), *val);
+  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
+  return 0;
+}
+
+// 16
+static FORCE_INLINE int tDecodeU16(SDecoder* pDecoder, uint16_t* val) {
+  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+  if (TD_RT_ENDIAN() == pDecoder->endian) {
+    tGet(uint16_t, TD_CODER_CURRENT(pDecoder), *val);
+  } else {
+    tRGet16(val, TD_CODER_CURRENT(pDecoder));
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeI16(SDecoder* pDecoder, int16_t* val) {
+  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+  if (TD_RT_ENDIAN() == pDecoder->endian) {
+    tGet(int16_t, TD_CODER_CURRENT(pDecoder), *val);
+  } else {
+    tRGet16(val, TD_CODER_CURRENT(pDecoder));
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
+  return 0;
+}
+
+// 32
+static FORCE_INLINE int tDecodeU32(SDecoder* pDecoder, uint32_t* val) {
+  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+  if (TD_RT_ENDIAN() == pDecoder->endian) {
+    tGet(uint32_t, TD_CODER_CURRENT(pDecoder), *val);
+  } else {
+    tRGet32(val, TD_CODER_CURRENT(pDecoder));
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeI32(SDecoder* pDecoder, int32_t* val) {
+  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+  if (TD_RT_ENDIAN() == pDecoder->endian) {
+    tGet(int32_t, TD_CODER_CURRENT(pDecoder), *val);
+  } else {
+    tRGet32(val, TD_CODER_CURRENT(pDecoder));
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
+  return 0;
+}
+
+// 64
+static FORCE_INLINE int tDecodeU64(SDecoder* pDecoder, uint64_t* val) {
+  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+  if (TD_RT_ENDIAN() == pDecoder->endian) {
+    tGet(uint64_t, TD_CODER_CURRENT(pDecoder), *val);
+  } else {
+    tRGet64(val, TD_CODER_CURRENT(pDecoder));
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeI64(SDecoder* pDecoder, int64_t* val) {
+  if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, sizeof(*val))) return -1;
+  if (TD_RT_ENDIAN() == pDecoder->endian) {
+    tGet(int64_t, TD_CODER_CURRENT(pDecoder), *val);
+  } else {
+    tRGet64(val, TD_CODER_CURRENT(pDecoder));
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, sizeof(*val));
+  return 0;
+}
+
+// 16v
+static FORCE_INLINE int tDecodeU16v(SDecoder* pDecoder, uint16_t* val) {
+  int64_t i = 0;
+  *val = 0;
+  for (;;) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, 1)) return -1;
+    uint16_t tval = TD_CODER_CURRENT(pDecoder)[i];
+    if (tval < ENCODE_LIMIT) {
+      (*val) |= (tval << (7 * i));
+      break;
+    } else {
+      (*val) |= (((tval) & (ENCODE_LIMIT - 1)) << (7 * i));
+      i++;
+    }
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, i);
+
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeI16v(SDecoder* pDecoder, int16_t* val) {
+  uint16_t tval;
+  if (tDecodeU16v(pDecoder, &tval) < 0) {
+    return -1;
+  }
+  *val = ZIGZAGD(int16_t, tval);
+  return 0;
+}
+
+// 32v
+static FORCE_INLINE int tDecodeU32v(SDecoder* pDecoder, uint32_t* val) {
+  int64_t i = 0;
+  *val = 0;
+  for (;;) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, 1)) return -1;
+    uint32_t tval = TD_CODER_CURRENT(pDecoder)[i];
+    if (tval < ENCODE_LIMIT) {
+      (*val) |= (tval << (7 * i));
+      break;
+    } else {
+      (*val) |= (((tval) & (ENCODE_LIMIT - 1)) << (7 * i));
+      i++;
+    }
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, i);
+
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeI32v(SDecoder* pDecoder, int32_t* val) {
+  uint32_t tval;
+  if (tDecodeU32v(pDecoder, &tval) < 0) {
+    return -1;
+  }
+  *val = ZIGZAGD(int32_t, tval);
+  return 0;
+}
+
+// 64v
+static FORCE_INLINE int tDecodeU64v(SDecoder* pDecoder, uint64_t* val) {
+  int64_t i = 0;
+  *val = 0;
+  for (;;) {
+    if (TD_CHECK_CODER_CAPACITY_FAILED(pDecoder, 1)) return -1;
+    uint64_t tval = TD_CODER_CURRENT(pDecoder)[i];
+    if (tval < ENCODE_LIMIT) {
+      (*val) |= (tval << (7 * i));
+      break;
+    } else {
+      (*val) |= (((tval) & (ENCODE_LIMIT - 1)) << (7 * i));
+      i++;
+    }
+  }
+
+  TD_CODER_MOVE_POS(pDecoder, i);
+
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeI64v(SDecoder* pDecoder, int64_t* val) {
+  uint64_t tval;
+  if (tDecodeU64v(pDecoder, &tval) < 0) {
+    return -1;
+  }
+  *val = ZIGZAGD(int64_t, tval);
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeFloat(SDecoder* pDecoder, float* val) {
+  // TODO
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeDouble(SDecoder* pDecoder, double* val) {
+  // TODO
+  return 0;
+}
+
+static FORCE_INLINE int tDecodeCStr(SDecoder* pEncoder, const char** val) {
+  // TODO
+  return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*_TD_UTIL_ENCODE_H_*/

include/util/tbuffer.h

@@ -16,6 +16,8 @@
 #ifndef _TD_UTIL_BUFFER_H
 #define _TD_UTIL_BUFFER_H
 
+#include "os.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -71,102 +73,95 @@ int main( int argc, char** argv ) {
 */
 
 typedef struct SBufferReader {
-  bool endian;
+  bool        endian;
   const char* data;
-  size_t pos;
+  size_t      pos;
-  size_t size;
+  size_t      size;
 } SBufferReader;
 
 typedef struct SBufferWriter {
-  bool endian;
+  bool   endian;
-  char* data;
+  char*  data;
   size_t pos;
   size_t size;
-  void* (*allocator)( void*, size_t );
+  void* (*allocator)(void*, size_t);
 } SBufferWriter;
 
 ////////////////////////////////////////////////////////////////////////////////
 // common functions & macros for both reader & writer
 
-#define tbufTell( buf ) ((buf)->pos)
+#define tbufTell(buf) ((buf)->pos)
-
 
 ////////////////////////////////////////////////////////////////////////////////
-// reader functions & macros
+/* ------------------------ BUFFER WRITER FUNCTIONS AND MACROS ------------------------ */
-
-// *Endian*, if true, reader functions of primitive types will do 'ntoh' automatically
-#define tbufInitReader( Data, Size, Endian ) {.endian = (Endian), .data = (Data), .pos = 0, .size = ((Data) == NULL ? 0 :(Size))}
-
-size_t      tbufSkip( SBufferReader* buf, size_t size );
-
-const char* tbufRead( SBufferReader* buf, size_t size );
-void        tbufReadToBuffer( SBufferReader* buf, void* dst, size_t size );
-const char* tbufReadString( SBufferReader* buf, size_t* len );
-size_t      tbufReadToString( SBufferReader* buf, char* dst, size_t size );
-const char* tbufReadBinary( SBufferReader* buf, size_t *len );
-size_t      tbufReadToBinary( SBufferReader* buf, void* dst, size_t size );
-
-bool     tbufReadBool( SBufferReader* buf );
-char     tbufReadChar( SBufferReader* buf );
-int8_t   tbufReadInt8( SBufferReader* buf );
-uint8_t  tbufReadUint8( SBufferReader* buf );
-int16_t  tbufReadInt16( SBufferReader* buf );
-uint16_t tbufReadUint16( SBufferReader* buf );
-int32_t  tbufReadInt32( SBufferReader* buf );
-uint32_t tbufReadUint32( SBufferReader* buf );
-int64_t  tbufReadInt64( SBufferReader* buf );
-uint64_t tbufReadUint64( SBufferReader* buf );
-float    tbufReadFloat( SBufferReader* buf );
-double   tbufReadDouble( SBufferReader* buf );
-
-
-////////////////////////////////////////////////////////////////////////////////
-// writer functions & macros
-
 // *Allocator*, function to allocate memory, will use 'realloc' if NULL
 // *Endian*, if true, writer functions of primitive types will do 'hton' automatically
-#define tbufInitWriter( Allocator, Endian ) {.endian = (Endian), .data = NULL, .pos = 0, .size = 0, .allocator = ((Allocator) == NULL ? realloc : (Allocator))}
+#define tbufInitWriter(Allocator, Endian) \
-void   tbufCloseWriter( SBufferWriter* buf );
+  { .endian = (Endian), .data = NULL, .pos = 0, .size = 0, .allocator = ((Allocator) == NULL ? realloc : (Allocator)) }
 
-void   tbufEnsureCapacity( SBufferWriter* buf, size_t size );
+void   tbufCloseWriter(SBufferWriter* buf);
-size_t tbufReserve( SBufferWriter* buf, size_t size );
+void   tbufEnsureCapacity(SBufferWriter* buf, size_t size);
-char*  tbufGetData( SBufferWriter* buf, bool takeOver );
+size_t tbufReserve(SBufferWriter* buf, size_t size);
-
+char*  tbufGetData(SBufferWriter* buf, bool takeOver);
-void   tbufWrite( SBufferWriter* buf, const void* data, size_t size );
+void   tbufWrite(SBufferWriter* buf, const void* data, size_t size);
-void   tbufWriteAt( SBufferWriter* buf, size_t pos, const void* data, size_t size );
+void   tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size);
-void   tbufWriteStringLen( SBufferWriter* buf, const char* str, size_t len );
+void   tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len);
-void   tbufWriteString( SBufferWriter* buf, const char* str );
+void   tbufWriteString(SBufferWriter* buf, const char* str);
 // the prototype of tbufWriteBinary and tbufWrite are identical
 // the difference is: tbufWriteBinary writes the length of the data to the buffer
 // first, then the actual data, which means the reader don't need to know data
 // size before read. Write only write the data itself, which means the reader
 // need to know data size before read.
-void   tbufWriteBinary( SBufferWriter* buf, const void* data, size_t len );
+void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len);
+void tbufWriteBool(SBufferWriter* buf, bool data);
+void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data);
+void tbufWriteChar(SBufferWriter* buf, char data);
+void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data);
+void tbufWriteInt8(SBufferWriter* buf, int8_t data);
+void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data);
+void tbufWriteUint8(SBufferWriter* buf, uint8_t data);
+void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data);
+void tbufWriteInt16(SBufferWriter* buf, int16_t data);
+void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data);
+void tbufWriteUint16(SBufferWriter* buf, uint16_t data);
+void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data);
+void tbufWriteInt32(SBufferWriter* buf, int32_t data);
+void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data);
+void tbufWriteUint32(SBufferWriter* buf, uint32_t data);
+void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data);
+void tbufWriteInt64(SBufferWriter* buf, int64_t data);
+void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data);
+void tbufWriteUint64(SBufferWriter* buf, uint64_t data);
+void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data);
+void tbufWriteFloat(SBufferWriter* buf, float data);
+void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data);
+void tbufWriteDouble(SBufferWriter* buf, double data);
+void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data);
 
-void tbufWriteBool( SBufferWriter* buf, bool data );
+/* ------------------------ BUFFER READER FUNCTIONS AND MACROS ------------------------ */
-void tbufWriteBoolAt( SBufferWriter* buf, size_t pos, bool data );
+// *Endian*, if true, reader functions of primitive types will do 'ntoh' automatically
-void tbufWriteChar( SBufferWriter* buf, char data );
+#define tbufInitReader(Data, Size, Endian) \
-void tbufWriteCharAt( SBufferWriter* buf, size_t pos, char data );
+  { .endian = (Endian), .data = (Data), .pos = 0, .size = ((Data) == NULL ? 0 : (Size)) }
-void tbufWriteInt8( SBufferWriter* buf, int8_t data );
+
-void tbufWriteInt8At( SBufferWriter* buf, size_t pos, int8_t data );
+size_t      tbufSkip(SBufferReader* buf, size_t size);
-void tbufWriteUint8( SBufferWriter* buf, uint8_t data );
+const char* tbufRead(SBufferReader* buf, size_t size);
-void tbufWriteUint8At( SBufferWriter* buf, size_t pos, uint8_t data );
+void        tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size);
-void tbufWriteInt16( SBufferWriter* buf, int16_t data );
+const char* tbufReadString(SBufferReader* buf, size_t* len);
-void tbufWriteInt16At( SBufferWriter* buf, size_t pos, int16_t data );
+size_t      tbufReadToString(SBufferReader* buf, char* dst, size_t size);
-void tbufWriteUint16( SBufferWriter* buf, uint16_t data );
+const char* tbufReadBinary(SBufferReader* buf, size_t* len);
-void tbufWriteUint16At( SBufferWriter* buf, size_t pos, uint16_t data );
+size_t      tbufReadToBinary(SBufferReader* buf, void* dst, size_t size);
-void tbufWriteInt32( SBufferWriter* buf, int32_t data );
+bool        tbufReadBool(SBufferReader* buf);
-void tbufWriteInt32At( SBufferWriter* buf, size_t pos, int32_t data );
+char        tbufReadChar(SBufferReader* buf);
-void tbufWriteUint32( SBufferWriter* buf, uint32_t data );
+int8_t      tbufReadInt8(SBufferReader* buf);
-void tbufWriteUint32At( SBufferWriter* buf, size_t pos, uint32_t data );
+uint8_t     tbufReadUint8(SBufferReader* buf);
-void tbufWriteInt64( SBufferWriter* buf, int64_t data );
+int16_t     tbufReadInt16(SBufferReader* buf);
-void tbufWriteInt64At( SBufferWriter* buf, size_t pos, int64_t data );
+uint16_t    tbufReadUint16(SBufferReader* buf);
-void tbufWriteUint64( SBufferWriter* buf, uint64_t data );
+int32_t     tbufReadInt32(SBufferReader* buf);
-void tbufWriteUint64At( SBufferWriter* buf, size_t pos, uint64_t data );
+uint32_t    tbufReadUint32(SBufferReader* buf);
-void tbufWriteFloat( SBufferWriter* buf, float data );
+int64_t     tbufReadInt64(SBufferReader* buf);
-void tbufWriteFloatAt( SBufferWriter* buf, size_t pos, float data );
+uint64_t    tbufReadUint64(SBufferReader* buf);
-void tbufWriteDouble( SBufferWriter* buf, double data );
+float       tbufReadFloat(SBufferReader* buf);
-void tbufWriteDoubleAt( SBufferWriter* buf, size_t pos, double data );
+double      tbufReadDouble(SBufferReader* buf);
 
 #ifdef __cplusplus
 }

include/util/tcoding.h

@@ -25,6 +25,8 @@ extern "C" {
 #define ZIGZAGE(T, v) ((u##T)((v) >> (sizeof(T) * 8 - 1))) ^ (((u##T)(v)) << 1)  // zigzag encode
 #define ZIGZAGD(T, v) ((v) >> 1) ^ -((T)((v)&1))                                 // zigzag decode
 
+/* ------------------------ LEGACY CODES ------------------------ */
+#if 1
 // ---- Fixed U8
 static FORCE_INLINE int taosEncodeFixedU8(void **buf, uint8_t value) {
   if (buf != NULL) {
@@ -368,6 +370,8 @@ static FORCE_INLINE void *taosDecodeStringTo(void *buf, char *value) {
   return POINTER_SHIFT(buf, size);
 }
 
+#endif
+
 #ifdef __cplusplus
 }
 #endif

include/util/tmacro.h

@@ -35,6 +35,8 @@ typedef int8_t td_mode_flag_t;
 
 #define TD_CHECK_AND_SET_MOD_CLEAR(FLAG) atomic_val_compare_exchange_8((FLAG), TD_MOD_UNCLEARD, TD_MOD_CLEARD)
 
+#define TD_IS_NULL(PTR) ((PTR) == NULL)
+
 #ifdef __cplusplus
 }
 #endif

source/client/src/clientImpl.c

@@ -181,43 +181,13 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQueryNode* pQuery) {
   pRequest->body.requestMsg = (SDataBuf){.pData = pDcl->pMsg, .len = pDcl->msgLen};
 
   STscObj* pTscObj = pRequest->pTscObj;
-
-
   SMsgSendInfo* pSendMsg = buildSendMsgInfoImpl(pRequest);
-  SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet;
 
+  int64_t transporterId = 0;
   if (pDcl->msgType == TDMT_VND_CREATE_TABLE) {
-//    struct SCatalog* pCatalog = NULL;
-//
-//    char buf[18] = {0};
-//    sprintf(buf, "%" PRId64, pRequest->pTscObj->pAppInfo->clusterId);
-//    int32_t code = catalogGetHandle(buf, &pCatalog);
-//    if (code != TSDB_CODE_SUCCESS) {
-//      return code;
-//    }
-//
-//    SCreateTableMsg* pMsg = pSendMsg->msgInfo.pData;
-//
-//    SName t = {0};
-//    tNameFromString(&t, pMsg->name, T_NAME_ACCT|T_NAME_DB|T_NAME_TABLE);
-//
-//    char db[TSDB_DB_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_ACCT_ID_LEN] = {0};
-//    tNameGetFullDbName(&t, db);
-//
-//    SVgroupInfo info = {0};
-//    catalogGetTableHashVgroup(pCatalog, pRequest->pTscObj->pTransporter, pEpSet, db, tNameGetTableName(&t), &info);
-//
-    int64_t transporterId = 0;
-//    SEpSet ep   = {0};
-//    ep.inUse    = info.inUse;
-//    ep.numOfEps = info.numOfEps;
-//    for(int32_t i = 0; i < ep.numOfEps; ++i) {
-//      ep.port[i] = info.epAddr[i].port;
-//      tstrncpy(ep.fqdn[i], info.epAddr[i].fqdn, tListLen(ep.fqdn[i]));
-//    }
     asyncSendMsgToServer(pTscObj->pTransporter, &pDcl->epSet, &transporterId, pSendMsg);
   } else {
-    int64_t transporterId = 0;
+    SEpSet* pEpSet = &pTscObj->pAppInfo->mgmtEp.epSet;
     asyncSendMsgToServer(pTscObj->pTransporter, pEpSet, &transporterId, pSendMsg);
   }
 

source/client/src/clientMsgHandler.c

@@ -188,14 +188,21 @@ int32_t processCreateDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
 }
 
 int32_t processUseDbRsp(void* param, const SDataBuf* pMsg, int32_t code) {
-  SUseDbRsp* pUseDbRsp = (SUseDbRsp*) pMsg->pData;
+  SRequestObj* pRequest = param;
-  SName name = {0};
+
-  tNameFromString(&name, pUseDbRsp->db, T_NAME_ACCT|T_NAME_DB);
+  if (code != TSDB_CODE_SUCCESS) {
+    pRequest->code = code;
+    tsem_post(&pRequest->body.rspSem);
+    return code;
+  }
+
+  SUseDbRsp* pUseDbRsp = (SUseDbRsp*)pMsg->pData;
+  SName      name = {0};
+  tNameFromString(&name, pUseDbRsp->db, T_NAME_ACCT | T_NAME_DB);
 
   char db[TSDB_DB_NAME_LEN] = {0};
   tNameGetDbName(&name, db);
 
-  SRequestObj* pRequest = param;
   setConnectionDB(pRequest->pTscObj, db);
 
   tsem_post(&pRequest->body.rspSem);

source/client/test/clientTests.cpp

@@ -162,7 +162,7 @@ TEST(testCase, create_db_Test) {
 
   taos_free_result(pRes);
 
-  pRes = taos_query(pConn, "create database abc1");
+  pRes = taos_query(pConn, "create database abc1 vgroups 4");
   if (taos_errno(pRes) != 0) {
     printf("error in create db, reason:%s\n", taos_errstr(pRes));
   }
@@ -399,50 +399,49 @@ TEST(testCase, drop_stable_Test) {
   taos_close(pConn);
 }
 
-TEST(testCase, create_topic_Test) {
+//TEST(testCase, create_topic_Test) {
-  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
-  assert(pConn != NULL);
-
-  TAOS_RES* pRes = taos_query(pConn, "create database abc1");
-  if (taos_errno(pRes) != 0) {
-    printf("error in create db, reason:%s\n", taos_errstr(pRes));
-  }
-  taos_free_result(pRes);
-
-  pRes = taos_query(pConn, "use abc1");
-  if (taos_errno(pRes) != 0) {
-    printf("error in use db, reason:%s\n", taos_errstr(pRes));
-  }
-  taos_free_result(pRes);
-
-  pRes = taos_query(pConn, "create stable st1(ts timestamp, k int) tags(a int)");
-  if (taos_errno(pRes) != 0) {
-    printf("error in create stable, reason:%s\n", taos_errstr(pRes));
-  }
-
-  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
-  ASSERT_TRUE(pFields == NULL);
-
-  int32_t numOfFields = taos_num_fields(pRes);
-  ASSERT_EQ(numOfFields, 0);
-
-  taos_free_result(pRes);
-  
-  char* sql = "select * from st1";
-  tmq_create_topic(pConn, "test_topic_1", sql, strlen(sql));
-  taos_close(pConn); 
-}
-
-
-//TEST(testCase, show_table_Test) {
 //  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
 //  assert(pConn != NULL);
 //
-//  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+//  TAOS_RES* pRes = taos_query(pConn, "create database abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+//  }
 //  taos_free_result(pRes);
 //
-//  pRes = taos_query(pConn, "show tables");
+//  pRes = taos_query(pConn, "use abc1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+//  }
 //  taos_free_result(pRes);
 //
+//  pRes = taos_query(pConn, "create stable st1(ts timestamp, k int) tags(a int)");
+//  if (taos_errno(pRes) != 0) {
+//    printf("error in create stable, reason:%s\n", taos_errstr(pRes));
+//  }
+//
+//  TAOS_FIELD* pFields = taos_fetch_fields(pRes);
+//  ASSERT_TRUE(pFields == NULL);
+//
+//  int32_t numOfFields = taos_num_fields(pRes);
+//  ASSERT_EQ(numOfFields, 0);
+//
+//  taos_free_result(pRes);
+//
+//  char* sql = "select * from st1";
+//  tmq_create_topic(pConn, "test_topic_1", sql, strlen(sql));
 //  taos_close(pConn);
 //}
+
+TEST(testCase, show_table_Test) {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "show tables");
+  taos_free_result(pRes);
+
+  taos_close(pConn);
+}

source/dnode/mgmt/daemon/src/daemon.c

@@ -139,7 +139,7 @@ void dmnWaitSignal() {
 void dmnInitOption(SDnodeOpt *pOption) {
   pOption->sver = 30000000; //3.0.0.0
   pOption->numOfCores = tsNumOfCores;
-  pOption->numOfSupportVnodes = 1;
+  pOption->numOfSupportVnodes = 16;
   pOption->numOfCommitThreads = 1;
   pOption->statusInterval = tsStatusInterval;
   pOption->numOfThreadsPerCore = tsNumOfThreadsPerCore;

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

@@ -393,13 +393,11 @@ void dndSendStatusMsg(SDnode *pDnode) {
 
 static void dndUpdateDnodeCfg(SDnode *pDnode, SDnodeCfg *pCfg) {
   SDnodeMgmt *pMgmt = &pDnode->dmgmt;
-  if (pMgmt->dnodeId == 0 || pMgmt->dropped != pCfg->dropped) {
+  if (pMgmt->dnodeId == 0) {
-    dInfo("set dnodeId:%d clusterId:% " PRId64 " dropped:%d", pCfg->dnodeId, pCfg->clusterId, pCfg->dropped);
+    dInfo("set dnodeId:%d clusterId:% " PRId64, pCfg->dnodeId, pCfg->clusterId);
-
     taosWLockLatch(&pMgmt->latch);
     pMgmt->dnodeId = pCfg->dnodeId;
     pMgmt->clusterId = pCfg->clusterId;
-    pMgmt->dropped = pCfg->dropped;
     dndWriteDnodes(pDnode);
     taosWUnLockLatch(&pMgmt->latch);
   }
@@ -430,6 +428,11 @@ static void dndProcessStatusRsp(SDnode *pDnode, SRpcMsg *pMsg) {
 
   if (pMsg->code != TSDB_CODE_SUCCESS) {
     pMgmt->statusSent = 0;
+    if (pMsg->code == TSDB_CODE_MND_DNODE_NOT_EXIST && !pMgmt->dropped && pMgmt->dnodeId > 0) {
+      dInfo("dnode:%d, set to dropped since not exist in mnode", pMgmt->dnodeId);
+      pMgmt->dropped = 1;
+      dndWriteDnodes(pDnode);
+    }
     return;
   }
 
@@ -439,11 +442,6 @@ static void dndProcessStatusRsp(SDnode *pDnode, SRpcMsg *pMsg) {
   pCfg->clusterId = htobe64(pCfg->clusterId);
   dndUpdateDnodeCfg(pDnode, pCfg);
 
-  if (pCfg->dropped) {
-    pMgmt->statusSent = 0;
-    return;
-  }
-
   SDnodeEps *pDnodeEps = &pRsp->dnodeEps;
   pDnodeEps->num = htonl(pDnodeEps->num);
   for (int32_t i = 0; i < pDnodeEps->num; ++i) {
@@ -487,7 +485,7 @@ static void *dnodeThreadRoutine(void *param) {
     pthread_testcancel();
     taosMsleep(ms);
 
-    if (dndGetStat(pDnode) == DND_STAT_RUNNING && !pMgmt->statusSent) {
+    if (dndGetStat(pDnode) == DND_STAT_RUNNING && !pMgmt->statusSent && !pMgmt->dropped) {
       dndSendStatusMsg(pDnode);
     }
   }
@@ -522,6 +520,11 @@ int32_t dndInitDnode(SDnode *pDnode) {
     return -1;
   }
 
+  if (pMgmt->dropped) {
+    dError("dnode will not start for its already dropped");
+    return -1;
+  }
+
   if (dndInitMgmtWorker(pDnode) != 0) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;

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

@@ -124,12 +124,8 @@ typedef struct {
   int64_t    rebootTime;
   int64_t    lastAccessTime;
   int32_t    accessTimes;
-  int16_t    numOfMnodes;
   int16_t    numOfVnodes;
-  int16_t    numOfQnodes;
-  int16_t    numOfSupportMnodes;
   int16_t    numOfSupportVnodes;
-  int16_t    numOfSupportQnodes;
   int16_t    numOfCores;
   EDndStatus status;
   EDndReason offlineReason;

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

@@ -19,6 +19,7 @@
 #include "mndDef.h"
 #include "sdb.h"
 #include "tcache.h"
+#include "tep.h"
 #include "tqueue.h"
 #include "ttime.h"
 

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

@@ -29,6 +29,7 @@ void     mndReleaseVgroup(SMnode *pMnode, SVgObj *pVgroup);
 SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup);
 int32_t  mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups);
 SEpSet   mndGetVgroupEpset(SMnode *pMnode, SVgObj *pVgroup);
+int32_t  mndGetVnodesNum(SMnode *pMnode, int32_t dnodeId);
 
 SCreateVnodeMsg *mndBuildCreateVnodeMsg(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup);
 SDropVnodeMsg   *mndBuildDropVnodeMsg(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup);

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

@@ -18,8 +18,7 @@
 #include "mndMnode.h"
 #include "mndShow.h"
 #include "mndTrans.h"
-#include "tep.h"
+#include "mndVgroup.h"
-#include "ttime.h"
 
 #define TSDB_DNODE_VER_NUMBER 1
 #define TSDB_DNODE_RESERVE_SIZE 64
@@ -370,7 +369,6 @@ static int32_t mndProcessStatusMsg(SMnodeMsg *pMsg) {
   }
 
   pRsp->dnodeCfg.dnodeId = htonl(pDnode->id);
-  pRsp->dnodeCfg.dropped = 0;
   pRsp->dnodeCfg.clusterId = htobe64(pMnode->clusterId);
   mndGetDnodeData(pMnode, &pRsp->dnodeEps, numOfEps);
 
@@ -700,7 +698,7 @@ static int32_t mndRetrieveDnodes(SMnodeMsg *pMsg, SShowObj *pShow, char *data, i
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
-    *(int16_t *)pWrite = pDnode->numOfVnodes;
+    *(int16_t *)pWrite = mndGetVnodesNum(pMnode, pDnode->id);
     cols++;
 
     pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;

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

@@ -118,17 +118,17 @@ static SConnObj *mndCreateConn(SMnode *pMnode, SRpcConnInfo *pInfo, int32_t pid,
   SConnObj *pConn = taosCachePut(pMgmt->cache, &connId, sizeof(int32_t), &connObj, sizeof(connObj), keepTime * 1000);
   if (pConn == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    mError("conn:%d, data:%p failed to put into cache since %s, user:%s", connId, pConn, pInfo->user, terrstr());
+    mError("conn:%d, failed to put into cache since %s, user:%s", connId, pInfo->user, terrstr());
     return NULL;
   } else {
-    mTrace("conn:%d, data:%p created, user:%s", pConn->id, pConn, pInfo->user);
+    mTrace("conn:%d, is created, data:%p user:%s", pConn->id, pConn, pInfo->user);
     return pConn;
   }
 }
 
 static void mndFreeConn(SConnObj *pConn) {
   tfree(pConn->pQueries);
-  mTrace("conn:%d, data:%p destroyed", pConn->id, pConn);
+  mTrace("conn:%d, is destroyed, data:%p", pConn->id, pConn);
 }
 
 static SConnObj *mndAcquireConn(SMnode *pMnode, int32_t connId) {
@@ -143,13 +143,13 @@ static SConnObj *mndAcquireConn(SMnode *pMnode, int32_t connId) {
   int32_t keepTime = pMnode->cfg.shellActivityTimer * 3;
   pConn->lastAccessTimeMs = keepTime * 1000 + (uint64_t)taosGetTimestampMs();
 
-  mTrace("conn:%d, data:%p acquired from cache", pConn->id, pConn);
+  mTrace("conn:%d, acquired from cache, data:%p", pConn->id, pConn);
   return pConn;
 }
 
 static void mndReleaseConn(SMnode *pMnode, SConnObj *pConn) {
   if (pConn == NULL) return;
-  mTrace("conn:%d, data:%p released from cache", pConn->id, pConn);
+  mTrace("conn:%d, released from cache, data:%p", pConn->id, pConn);
 
   SProfileMgmt *pMgmt = &pMnode->profileMgmt;
   taosCacheRelease(pMgmt->cache, (void **)&pConn, false);

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

@@ -55,32 +55,25 @@ static SShowObj *mndCreateShowObj(SMnode *pMnode, SShowMsg *pMsg) {
   int32_t showId = atomic_add_fetch_32(&pMgmt->showId, 1);
   if (showId == 0) atomic_add_fetch_32(&pMgmt->showId, 1);
 
-  int32_t   size = sizeof(SShowObj) + pMsg->payloadLen;
+  int32_t  size = sizeof(SShowObj) + pMsg->payloadLen;
-  SShowObj *pShow = calloc(1, size);
+  SShowObj showObj = {0};
-  if (pShow != NULL) {
+  showObj.id = showId;
-    pShow->id = showId;
+  showObj.pMnode = pMnode;
-    pShow->pMnode = pMnode;
+  showObj.type = pMsg->type;
-    pShow->type = pMsg->type;
+  showObj.payloadLen = pMsg->payloadLen;
-    pShow->payloadLen = pMsg->payloadLen;
+  memcpy(showObj.db, pMsg->db, TSDB_DB_FNAME_LEN);
-    memcpy(pShow->db, pMsg->db, TSDB_DB_FNAME_LEN);
+  memcpy(showObj.payload, pMsg->payload, pMsg->payloadLen);
-    memcpy(pShow->payload, pMsg->payload, pMsg->payloadLen);
-  } else {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    mError("failed to process show-meta msg:%s since %s", mndShowStr(pMsg->type), terrstr());
-    return NULL;
-  }
 
   int32_t   keepTime = pMnode->cfg.shellActivityTimer * 6 * 1000;
-  SShowObj *pShowRet = taosCachePut(pMgmt->cache, &showId, sizeof(int32_t), pShow, size, keepTime);
+  SShowObj *pShow = taosCachePut(pMgmt->cache, &showId, sizeof(int32_t), &showObj, size, keepTime);
-  free(pShow);
+  if (pShow == NULL) {
-  if (pShowRet == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     mError("show:%d, failed to put into cache since %s", showId, terrstr());
     return NULL;
-  } else {
-    mTrace("show:%d, data:%p created", showId, pShowRet);
-    return pShowRet;
   }
+
+  mTrace("show:%d, is created, data:%p", showId, pShow);
+  return pShow;
 }
 
 static void mndFreeShowObj(SShowObj *pShow) {
@@ -94,7 +87,7 @@ static void mndFreeShowObj(SShowObj *pShow) {
     }
   }
 
-  mTrace("show:%d, data:%p destroyed", pShow->id, pShow);
+  mTrace("show:%d, is destroyed, data:%p", pShow->id, pShow);
 }
 
 static SShowObj *mndAcquireShowObj(SMnode *pMnode, int32_t showId) {
@@ -106,14 +99,14 @@ static SShowObj *mndAcquireShowObj(SMnode *pMnode, int32_t showId) {
     return NULL;
   }
 
-  mTrace("show:%d, data:%p acquired from cache", pShow->id, pShow);
+  mTrace("show:%d, acquired from cache, data:%p", pShow->id, pShow);
   return pShow;
 }
 
 static void mndReleaseShowObj(SShowObj *pShow, bool forceRemove) {
   if (pShow == NULL) return;
-  mTrace("show:%d, data:%p released from cache, force:%d", pShow->id, pShow, forceRemove);
+  mTrace("show:%d, released from cache, data:%p force:%d", pShow->id, pShow, forceRemove);
-  
+
   // A bug in tcache.c
   forceRemove = 0;
 
@@ -158,8 +151,8 @@ static int32_t mndProcessShowMsg(SMnodeMsg *pMnodeMsg) {
   }
 
   int32_t code = (*metaFp)(pMnodeMsg, pShow, &pRsp->tableMeta);
-  mDebug("show:%d, data:%p get meta finished, numOfRows:%d cols:%d type:%s result:%s", pShow->id, pShow,
+  mDebug("show:%d, get meta finished, numOfRows:%d cols:%d type:%s result:%s", pShow->id, pShow->numOfRows,
-         pShow->numOfRows, pShow->numOfColumns, mndShowStr(type), tstrerror(code));
+         pShow->numOfColumns, mndShowStr(type), tstrerror(code));
 
   if (code == TSDB_CODE_SUCCESS) {
     pMnodeMsg->contLen = sizeof(SShowRsp) + sizeof(SSchema) * pShow->numOfColumns;
@@ -195,16 +188,15 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) {
   if (retrieveFp == NULL) {
     mndReleaseShowObj(pShow, false);
     terrno = TSDB_CODE_MSG_NOT_PROCESSED;
-    mError("show:%d, data:%p failed to retrieve data since %s", pShow->id, pShow, terrstr());
+    mError("show:%d, failed to retrieve data since %s", pShow->id, terrstr());
     return -1;
   }
 
-  mDebug("show:%d, data:%p start retrieve data, numOfReads:%d numOfRows:%d type:%s", pShow->id, pShow,
+  mDebug("show:%d, start retrieve data, numOfReads:%d numOfRows:%d type:%s", pShow->id, pShow->numOfReads,
-         pShow->numOfReads, pShow->numOfRows, mndShowStr(pShow->type));
+         pShow->numOfRows, mndShowStr(pShow->type));
 
   if (mndCheckRetrieveFinished(pShow)) {
-    mDebug("show:%d, data:%p read finished, numOfReads:%d numOfRows:%d", pShow->id, pShow, pShow->numOfReads,
+    mDebug("show:%d, read finished, numOfReads:%d numOfRows:%d", pShow->id, pShow->numOfReads, pShow->numOfRows);
-           pShow->numOfRows);
     pShow->numOfReads = pShow->numOfRows;
   }
 
@@ -227,7 +219,7 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) {
   if (pRsp == NULL) {
     mndReleaseShowObj(pShow, false);
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    mError("show:%d, data:%p failed to retrieve data since %s", pShow->id, pShow, terrstr());
+    mError("show:%d, failed to retrieve data since %s", pShow->id, terrstr());
     return -1;
   }
 
@@ -236,7 +228,7 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) {
     rowsRead = (*retrieveFp)(pMnodeMsg, pShow, pRsp->data, rowsToRead);
   }
 
-  mDebug("show:%d, data:%p stop retrieve data, rowsRead:%d rowsToRead:%d", pShow->id, pShow, rowsRead, rowsToRead);
+  mDebug("show:%d, stop retrieve data, rowsRead:%d rowsToRead:%d", pShow->id, rowsRead, rowsToRead);
 
   pRsp->numOfRows = htonl(rowsRead);
   pRsp->precision = TSDB_TIME_PRECISION_MILLI;  // millisecond time precision
@@ -246,10 +238,10 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) {
 
   if (rowsRead == 0 || rowsToRead == 0 || (rowsRead == rowsToRead && pShow->numOfRows == pShow->numOfReads)) {
     pRsp->completed = 1;
-    mDebug("show:%d, data:%p retrieve completed", pShow->id, pShow);
+    mDebug("show:%d, retrieve completed", pShow->id);
     mndReleaseShowObj(pShow, true);
   } else {
-    mDebug("show:%d, data:%p retrieve not completed yet", pShow->id, pShow);
+    mDebug("show:%d, retrieve not completed yet", pShow->id);
     mndReleaseShowObj(pShow, false);
   }
 

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

@@ -294,18 +294,18 @@ TRANS_DECODE_OVER:
     return NULL;
   }
 
-  mTrace("trans:%d, decode from raw:%p", pTrans->id, pRaw);
+  mTrace("trans:%d, decode from raw:%p, data:%p", pTrans->id, pRaw, pTrans);
   return pRow;
 }
 
 static int32_t mndTransActionInsert(SSdb *pSdb, STrans *pTrans) {
   pTrans->stage = TRN_STAGE_PREPARE;
-  mTrace("trans:%d, perform insert action", pTrans->id);
+  mTrace("trans:%d, perform insert action, data:%p", pTrans->id, pTrans);
   return 0;
 }
 
 static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans) {
-  mTrace("trans:%d, perform delete action", pTrans->id);
+  mTrace("trans:%d, perform delete action, data:%p", pTrans->id, pTrans);
 
   mndTransDropLogs(pTrans->redoLogs);
   mndTransDropLogs(pTrans->undoLogs);
@@ -317,7 +317,7 @@ static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans) {
 }
 
 static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOldTrans, STrans *pNewTrans) {
-  mTrace("trans:%d, perform update action", pOldTrans->id);
+  mTrace("trans:%d, perform update action, data:%p", pOldTrans->id, pOldTrans);
   pOldTrans->stage = pNewTrans->stage;
   return 0;
 }
@@ -362,14 +362,14 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, SRpcMsg *pMsg) {
     return NULL;
   }
 
-  mDebug("trans:%d, is created", pTrans->id);
+  mDebug("trans:%d, is created, data:%p", pTrans->id, pTrans);
   return pTrans;
 }
 
 static void mndTransDropLogs(SArray *pArray) {
   for (int32_t i = 0; i < pArray->size; ++i) {
     SSdbRaw *pRaw = taosArrayGetP(pArray, i);
-    tfree(pRaw);
+    sdbFreeRaw(pRaw);
   }
 
   taosArrayDestroy(pArray);
@@ -391,7 +391,7 @@ void mndTransDrop(STrans *pTrans) {
   mndTransDropActions(pTrans->redoActions);
   mndTransDropActions(pTrans->undoActions);
 
-  // mDebug("trans:%d, is dropped, data:%p", pTrans->id, pTrans);
+  mDebug("trans:%d, is dropped, data:%p", pTrans->id, pTrans);
   tfree(pTrans);
 }
 
@@ -442,7 +442,7 @@ static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) {
   }
   sdbSetRawStatus(pRaw, SDB_STATUS_READY);
 
-  mTrace("trans:%d, sync to other nodes", pTrans->id);
+  mDebug("trans:%d, sync to other nodes", pTrans->id);
   int32_t code = mndSyncPropose(pMnode, pRaw);
   if (code != 0) {
     mError("trans:%d, failed to sync since %s", pTrans->id, terrstr());
@@ -450,7 +450,7 @@ static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) {
     return -1;
   }
 
-  mTrace("trans:%d, sync finished", pTrans->id);
+  mDebug("trans:%d, sync finished", pTrans->id);
 
   code = sdbWrite(pMnode->pSdb, pRaw);
   if (code != 0) {

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

@@ -86,7 +86,6 @@ SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup) {
   for (int8_t i = 0; i < pVgroup->replica; ++i) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
     SDB_SET_INT32(pRaw, dataPos, pVgid->dnodeId)
-    SDB_SET_INT8(pRaw, dataPos, pVgid->role)
   }
   SDB_SET_RESERVE(pRaw, dataPos, TSDB_VGROUP_RESERVE_SIZE)
   SDB_SET_DATALEN(pRaw, dataPos);
@@ -121,7 +120,6 @@ SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw) {
   for (int8_t i = 0; i < pVgroup->replica; ++i) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[i];
     SDB_GET_INT32(pRaw, pRow, dataPos, &pVgid->dnodeId)
-    SDB_GET_INT8(pRaw, pRow, dataPos, (int8_t *)&pVgid->role)
   }
   SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_VGROUP_RESERVE_SIZE)
 
@@ -237,44 +235,95 @@ SDropVnodeMsg *mndBuildDropVnodeMsg(SMnode *pMnode, SDnodeObj *pDnode, SDbObj *p
   return pDrop;
 }
 
-static int32_t mndGetAvailableDnode(SMnode *pMnode, SVgObj *pVgroup) {
+static SArray *mndBuildDnodesArray(SMnode *pMnode) {
   SSdb   *pSdb = pMnode->pSdb;
-  int32_t allocedVnodes = 0;
+  int32_t numOfDnodes = mndGetDnodeSize(pMnode);
-  void   *pIter = NULL;
+  SArray *pArray = taosArrayInit(numOfDnodes, sizeof(SDnodeObj));
+  if (pArray == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
 
-  while (allocedVnodes < pVgroup->replica) {
+  void *pIter = NULL;
+  while (1) {
     SDnodeObj *pDnode = NULL;
     pIter = sdbFetch(pSdb, SDB_DNODE, pIter, (void **)&pDnode);
     if (pIter == NULL) break;
 
-    // todo
+    int32_t numOfVnodes = mndGetVnodesNum(pMnode, pDnode->id);
-    if (mndIsDnodeInReadyStatus(pMnode, pDnode)) {
+
-      SVnodeGid *pVgid = &pVgroup->vnodeGid[allocedVnodes];
+    bool isMnode = mndIsMnode(pMnode, pDnode->id);
-      pVgid->dnodeId = pDnode->id;
+    if (isMnode) {
-      if (pVgroup->replica == 1) {
+      pDnode->numOfVnodes++;
-        pVgid->role = TAOS_SYNC_STATE_LEADER;
-      } else {
-        pVgid->role = TAOS_SYNC_STATE_FOLLOWER;
-      }
-      allocedVnodes++;
     }
+
+    bool isReady = mndIsDnodeInReadyStatus(pMnode, pDnode);
+    if (isReady) {
+      taosArrayPush(pArray, pDnode);
+    }
+
+    mDebug("dnode:%d, numOfVnodes:%d numOfSupportVnodes:%d isMnode:%d ready:%d", pDnode->id, numOfVnodes,
+           pDnode->numOfSupportVnodes, isMnode, isReady);
     sdbRelease(pSdb, pDnode);
   }
 
-  if (allocedVnodes != pVgroup->replica) {
+  return pArray;
-    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
+}
-    return -1;
+
+static int32_t mndCompareDnodeVnodes(SDnodeObj *pDnode1, SDnodeObj *pDnode2) {
+  float d1Score = (float)pDnode1->numOfVnodes / pDnode1->numOfSupportVnodes;
+  float d2Score = (float)pDnode2->numOfVnodes / pDnode2->numOfSupportVnodes;
+  return d1Score > d2Score ? 0 : 1;
+}
+
+static int32_t mndGetAvailableDnode(SMnode *pMnode, SVgObj *pVgroup, SArray *pArray) {
+  SSdb   *pSdb = pMnode->pSdb;
+  int32_t allocedVnodes = 0;
+  void   *pIter = NULL;
+
+  taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
+
+  for (int32_t v = 0; v < pVgroup->replica; ++v) {
+    SVnodeGid *pVgid = &pVgroup->vnodeGid[v];
+    SDnodeObj *pDnode = taosArrayGet(pArray, v);
+    if (pDnode == NULL || pDnode->numOfVnodes > pDnode->numOfSupportVnodes) {
+      terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
+      return -1;
+    }
+
+    pVgid->dnodeId = pDnode->id;
+    if (pVgroup->replica == 1) {
+      pVgid->role = TAOS_SYNC_STATE_LEADER;
+    } else {
+      pVgid->role = TAOS_SYNC_STATE_FOLLOWER;
+    }
+
+    mDebug("db:%s, vgId:%d, vindex:%d dnodeId:%d is alloced", pVgroup->dbName, pVgroup->vgId, v, pVgid->dnodeId);
+    pDnode->numOfVnodes++;
   }
+
   return 0;
 }
 
 int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) {
-  SVgObj *pVgroups = calloc(pDb->cfg.numOfVgroups, sizeof(SVgObj));
+  int32_t code = -1;
+  SArray *pArray = NULL;
+  SVgObj *pVgroups = NULL;
+
+  pVgroups = calloc(pDb->cfg.numOfVgroups, sizeof(SVgObj));
   if (pVgroups == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    goto ALLOC_VGROUP_OVER;
   }
 
+  pArray = mndBuildDnodesArray(pMnode);
+  if (pArray == NULL) {
+    goto ALLOC_VGROUP_OVER;
+  }
+
+  mDebug("db:%s, total %d dnodes used to create %d vgroups (%d vnodes)", pDb->name, (int32_t)taosArrayGetSize(pArray),
+         pDb->cfg.numOfVgroups, pDb->cfg.numOfVgroups * pDb->cfg.replications);
+
   int32_t  allocedVgroups = 0;
   int32_t  maxVgId = sdbGetMaxId(pMnode->pSdb, SDB_VGROUP);
   uint32_t hashMin = 0;
@@ -298,17 +347,23 @@ int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) {
     pVgroup->dbUid = pDb->uid;
     pVgroup->replica = pDb->cfg.replications;
 
-    if (mndGetAvailableDnode(pMnode, pVgroup) != 0) {
+    if (mndGetAvailableDnode(pMnode, pVgroup, pArray) != 0) {
       terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-      free(pVgroups);
+      goto ALLOC_VGROUP_OVER;
-      return -1;
     }
 
     allocedVgroups++;
   }
 
   *ppVgroups = pVgroups;
-  return 0;
+  code = 0;
+
+  mDebug("db:%s, %d vgroups is alloced, replica:%d", pDb->name, pDb->cfg.numOfVgroups, pDb->cfg.replications);
+
+ALLOC_VGROUP_OVER:
+  if (code != 0) free(pVgroups);
+  taosArrayDestroy(pArray);
+  return code;
 }
 
 SEpSet mndGetVgroupEpset(SMnode *pMnode, SVgObj *pVgroup) {
@@ -348,6 +403,7 @@ static int32_t mndProcessDropVnodeRsp(SMnodeMsg *pMsg) {
 }
 
 static int32_t mndProcessSyncVnodeRsp(SMnodeMsg *pMsg) { return 0; }
+
 static int32_t mndProcessCompactVnodeRsp(SMnodeMsg *pMsg) { return 0; }
 
 static int32_t mndGetVgroupMaxReplica(SMnode *pMnode, char *dbName, int8_t *pReplica, int32_t *pNumOfVgroups) {
@@ -478,7 +534,7 @@ static void mndCancelGetNextVgroup(SMnode *pMnode, void *pIter) {
   sdbCancelFetch(pSdb, pIter);
 }
 
-static int32_t mndGetVnodesNum(SMnode *pMnode, int32_t dnodeId) {
+int32_t mndGetVnodesNum(SMnode *pMnode, int32_t dnodeId) {
   SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfVnodes = 0;
   void   *pIter = NULL;

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

@@ -146,15 +146,15 @@ static int32_t mndInitSteps(SMnode *pMnode) {
   if (mndAllocStep(pMnode, "mnode-sdb", mndInitSdb, mndCleanupSdb) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-trans", mndInitTrans, mndCleanupTrans) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-cluster", mndInitCluster, mndCleanupCluster) != 0) return -1;
-  if (mndAllocStep(pMnode, "mnode-dnode", mndInitDnode, mndCleanupDnode) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-mnode", mndInitMnode, mndCleanupMnode) != 0) return -1;
-  if (mndAllocStep(pMnode, "mnode-acct", mndInitAcct, mndCleanupAcct) != 0) return -1;
+  if (mndAllocStep(pMnode, "mnode-dnode", mndInitDnode, mndCleanupDnode) != 0) return -1;
-  if (mndAllocStep(pMnode, "mnode-auth", mndInitAuth, mndCleanupAuth) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-user", mndInitUser, mndCleanupUser) != 0) return -1;
-  if (mndAllocStep(pMnode, "mnode-db", mndInitDb, mndCleanupDb) != 0) return -1;
+  if (mndAllocStep(pMnode, "mnode-auth", mndInitAuth, mndCleanupAuth) != 0) return -1;
+  if (mndAllocStep(pMnode, "mnode-acct", mndInitAcct, mndCleanupAcct) != 0) return -1;
+  if (mndAllocStep(pMnode, "mnode-topic", mndInitTopic, mndCleanupTopic) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-vgroup", mndInitVgroup, mndCleanupVgroup) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-stb", mndInitStb, mndCleanupStb) != 0) return -1;
-  if (mndAllocStep(pMnode, "mnode-topic", mndInitTopic, mndCleanupTopic) != 0) return -1;
+  if (mndAllocStep(pMnode, "mnode-db", mndInitDb, mndCleanupDb) != 0) return -1;
   if (mndAllocStep(pMnode, "mnode-func", mndInitFunc, mndCleanupFunc) != 0) return -1;
   if (pMnode->clusterId <= 0) {
     if (mndAllocStep(pMnode, "mnode-sdb-deploy", mndDeploySdb, NULL) != 0) return -1;

source/dnode/mnode/sdb/inc/sdbInt.h

@@ -72,6 +72,7 @@ typedef struct SSdb {
 } SSdb;
 
 int32_t sdbWriteFile(SSdb *pSdb);
+void    sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper);
 
 #ifdef __cplusplus
 }

source/dnode/mnode/sdb/src/sdb.c

@@ -80,16 +80,12 @@ void sdbCleanup(SSdb *pSdb) {
     SHashObj *hash = pSdb->hashObjs[i];
     if (hash == NULL) continue;
 
-    SdbDeleteFp deleteFp = pSdb->deleteFps[i];
+    SSdbRow **ppRow = taosHashIterate(hash, NULL);
-    SSdbRow   **ppRow = taosHashIterate(hash, NULL);
     while (ppRow != NULL) {
       SSdbRow *pRow = *ppRow;
       if (pRow == NULL) continue;
 
-      if (deleteFp != NULL) {
+      sdbFreeRow(pSdb, pRow);
-        (*deleteFp)(pSdb, pRow->pObj);
-      }
-      sdbFreeRow(pRow);
       ppRow = taosHashIterate(hash, ppRow);
     }
   }

source/dnode/mnode/sdb/src/sdbFile.c

@@ -151,7 +151,7 @@ int32_t sdbWriteFile(SSdb *pSdb) {
         if (taosWriteFile(fd, pRaw, writeLen) != writeLen) {
           code = TAOS_SYSTEM_ERROR(terrno);
           taosHashCancelIterate(hash, ppRow);
-          free(pRaw);
+          sdbFreeRaw(pRaw);
           break;
         }
 
@@ -159,7 +159,7 @@ int32_t sdbWriteFile(SSdb *pSdb) {
         if (taosWriteFile(fd, &cksum, sizeof(int32_t)) != sizeof(int32_t)) {
           code = TAOS_SYSTEM_ERROR(terrno);
           taosHashCancelIterate(hash, ppRow);
-          free(pRaw);
+          sdbFreeRaw(pRaw);
           break;
         }
       } else {
@@ -168,7 +168,7 @@ int32_t sdbWriteFile(SSdb *pSdb) {
         break;
       }
 
-      free(pRaw);
+      sdbFreeRaw(pRaw);
       ppRow = taosHashIterate(hash, ppRow);
     }
     taosWUnLockLatch(pLock);

source/dnode/mnode/sdb/src/sdbHash.c

@@ -16,6 +16,50 @@
 #define _DEFAULT_SOURCE
 #include "sdbInt.h"
 
+static const char *sdbTableName(ESdbType type) {
+  switch (type) {
+    case SDB_TRANS:
+      return "trans";
+    case SDB_CLUSTER:
+      return "cluster";
+    case SDB_MNODE:
+      return "mnode";
+    case SDB_DNODE:
+      return "dnode";
+    case SDB_USER:
+      return "user";
+    case SDB_AUTH:
+      return "auth";
+    case SDB_ACCT:
+      return "acct";
+    case SDB_TOPIC:
+      return "topic";
+    case SDB_VGROUP:
+      return "vgId";
+    case SDB_STB:
+      return "stb";
+    case SDB_DB:
+      return "db";
+    case SDB_FUNC:
+      return "func";
+    default:
+      return "undefine";
+  }
+}
+
+void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper) {
+  EKeyType keyType = pSdb->keyTypes[pRow->type];
+
+  if (keyType == SDB_KEY_BINARY) {
+    mTrace("%s:%s, refCount:%d oper:%s", sdbTableName(pRow->type), (char *)pRow->pObj, pRow->refCount, oper);
+  } else if (keyType == SDB_KEY_INT32) {
+    mTrace("%s:%d, refCount:%d oper:%s", sdbTableName(pRow->type), *(int32_t *)pRow->pObj, pRow->refCount, oper);
+  } else if (keyType == SDB_KEY_INT64) {
+    mTrace("%s:%" PRId64 ", refCount:%d oper:%s", sdbTableName(pRow->type), *(int64_t *)pRow->pObj, pRow->refCount, oper);
+  } else {
+  }
+}
+
 static SHashObj *sdbGetHash(SSdb *pSdb, int32_t type) {
   if (type >= SDB_MAX || type <= SDB_START) {
     terrno = TSDB_CODE_SDB_INVALID_TABLE_TYPE;
@@ -55,17 +99,18 @@ static int32_t sdbInsertRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
   SSdbRow *pOldRow = taosHashGet(hash, pRow->pObj, keySize);
   if (pOldRow != NULL) {
     taosWUnLockLatch(pLock);
-    sdbFreeRow(pRow);
+    sdbFreeRow(pSdb, pRow);
     terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;
     return terrno;
   }
 
-  pRow->refCount = 1;
+  pRow->refCount = 0;
   pRow->status = pRaw->status;
+  sdbPrintOper(pSdb, pRow, "insertRow");
 
   if (taosHashPut(hash, pRow->pObj, keySize, &pRow, sizeof(void *)) != 0) {
     taosWUnLockLatch(pLock);
-    sdbFreeRow(pRow);
+    sdbFreeRow(pSdb, pRow);
     terrno = TSDB_CODE_SDB_OBJ_ALREADY_THERE;
     return terrno;
   }
@@ -83,7 +128,7 @@ static int32_t sdbInsertRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
       taosWLockLatch(pLock);
       taosHashRemove(hash, pRow->pObj, keySize);
       taosWUnLockLatch(pLock);
-      sdbFreeRow(pRow);
+      sdbFreeRow(pSdb, pRow);
       terrno = code;
       return terrno;
     }
@@ -113,7 +158,7 @@ static int32_t sdbUpdateRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
     code = (*updateFp)(pSdb, pOldRow->pObj, pNewRow->pObj);
   }
 
-  sdbFreeRow(pNewRow);
+  sdbFreeRow(pSdb, pNewRow);
   return code;
 }
 
@@ -123,14 +168,10 @@ static int32_t sdbDeleteRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
   SRWLatch *pLock = &pSdb->locks[pRow->type];
   taosWLockLatch(pLock);
 
-  // remove attached object such as trans
-  SdbDeleteFp deleteFp = pSdb->deleteFps[pRow->type];
-  if (deleteFp != NULL) (*deleteFp)(pSdb, pRow->pObj);
-
   SSdbRow **ppOldRow = taosHashGet(hash, pRow->pObj, keySize);
   if (ppOldRow == NULL || *ppOldRow == NULL) {
     taosWUnLockLatch(pLock);
-    sdbFreeRow(pRow);
+    sdbFreeRow(pSdb, pRow);
     terrno = TSDB_CODE_SDB_OBJ_NOT_THERE;
     return terrno;
   }
@@ -140,8 +181,8 @@ static int32_t sdbDeleteRow(SSdb *pSdb, SHashObj *hash, SSdbRaw *pRaw, SSdbRow *
   taosHashRemove(hash, pOldRow->pObj, keySize);
   taosWUnLockLatch(pLock);
 
-  sdbRelease(pSdb, pOldRow->pObj);
+  // sdbRelease(pSdb, pOldRow->pObj);
-  sdbFreeRow(pRow);
+  sdbFreeRow(pSdb, pRow);
   return code;
 }
 
@@ -206,6 +247,7 @@ void *sdbAcquire(SSdb *pSdb, ESdbType type, void *pKey) {
     case SDB_STATUS_UPDATING:
       atomic_add_fetch_32(&pRow->refCount, 1);
       pRet = pRow->pObj;
+      sdbPrintOper(pSdb, pRow, "acquireRow");
       break;
     case SDB_STATUS_CREATING:
       terrno = TSDB_CODE_SDB_OBJ_CREATING;
@@ -232,13 +274,9 @@ void sdbRelease(SSdb *pSdb, void *pObj) {
   taosRLockLatch(pLock);
 
   int32_t ref = atomic_sub_fetch_32(&pRow->refCount, 1);
+  sdbPrintOper(pSdb, pRow, "releaseRow");
   if (ref <= 0 && pRow->status == SDB_STATUS_DROPPED) {
-    SdbDeleteFp deleteFp = pSdb->deleteFps[pRow->type];
+    sdbFreeRow(pSdb, pRow);
-    if (deleteFp != NULL) {
-      (*deleteFp)(pSdb, pRow->pObj);
-    }
-
-    sdbFreeRow(pRow);
   }
 
   taosRUnLockLatch(pLock);
@@ -255,9 +293,9 @@ void *sdbFetch(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj) {
 
   if (pIter != NULL) {
     SSdbRow *pLastRow = *(SSdbRow **)pIter;
-    int32_t  ref = atomic_sub_fetch_32(&pLastRow->refCount, 1);
+    int32_t  ref = atomic_load_32(&pLastRow->refCount);
     if (ref <= 0 && pLastRow->status == SDB_STATUS_DROPPED) {
-      sdbFreeRow(pLastRow);
+      sdbFreeRow(pSdb, pLastRow);
     }
   }
 
@@ -270,6 +308,7 @@ void *sdbFetch(SSdb *pSdb, ESdbType type, void *pIter, void **ppObj) {
     }
 
     atomic_add_fetch_32(&pRow->refCount, 1);
+    sdbPrintOper(pSdb, pRow, "fetchRow");
     *ppObj = pRow->pObj;
     break;
   }

source/dnode/mnode/sdb/src/sdbRaw.c

@@ -27,12 +27,12 @@ SSdbRaw *sdbAllocRaw(ESdbType type, int8_t sver, int32_t dataLen) {
   pRaw->sver = sver;
   pRaw->dataLen = dataLen;
 
-  // mTrace("raw:%p, is created, len:%d", pRaw, dataLen);
+  mTrace("raw:%p, is created, len:%d", pRaw, dataLen);
   return pRaw;
 }
 
 void sdbFreeRaw(SSdbRaw *pRaw) {
-  // mTrace("raw:%p, is freed", pRaw);
+  mTrace("raw:%p, is freed", pRaw);
   free(pRaw);
 }
 

source/dnode/mnode/sdb/src/sdbRow.c

@@ -35,4 +35,13 @@ void *sdbGetRowObj(SSdbRow *pRow) {
   return pRow->pObj;
 }
 
-void sdbFreeRow(SSdbRow *pRow) { tfree(pRow); }
+void sdbFreeRow(SSdb *pSdb, SSdbRow *pRow) {
+  // remove attached object such as trans
+  SdbDeleteFp deleteFp = pSdb->deleteFps[pRow->type];
+  if (deleteFp != NULL) {
+    (*deleteFp)(pSdb, pRow->pObj);
+  }
+
+  sdbPrintOper(pSdb, pRow, "freeRow");
+  tfree(pRow);
+}

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

@@ -23,8 +23,8 @@ extern "C" {
 #endif
 
 // SVDropTableReq
-int   vnodeBuildDropTableReq(void **buf, const SVDropTableReq *pReq);
+// int   vnodeBuildDropTableReq(void **buf, const SVDropTableReq *pReq);
-void *vnodeParseDropTableReq(void *buf, SVDropTableReq *pReq);
+// void *vnodeParseDropTableReq(void *buf, SVDropTableReq *pReq);
 
 #ifdef __cplusplus
 }

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

@@ -28,8 +28,3 @@ int vnodeProcessSyncReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   vInfo("sync message is processed");
   return 0;
 }
-
-int vnodeProcessConsumeReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
-  vInfo("consume message is processed");
-  return 0;
-}

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

@@ -13,12 +13,10 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "vnodeDef.h"
 #include "vnodeQuery.h"
+#include "vnodeDef.h"
 
-int vnodeQueryOpen(SVnode *pVnode) {
+int vnodeQueryOpen(SVnode *pVnode) { return qWorkerInit(NULL, &pVnode->pQuery); }
-  return qWorkerInit(NULL, &pVnode->pQuery);
-}
 
 int vnodeProcessQueryReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   vInfo("query message is processed");
@@ -46,4 +44,24 @@ int vnodeProcessFetchReq(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
   return 0;
 }
 
+static int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
+  STableInfoMsg *pReq = (STableInfoMsg *)(pMsg->pCont);
+  STableMetaMsg *pRspMsg;
+  int            ret;
 
+  if (metaGetTableInfo(pVnode->pMeta, pReq->tableFname, &pRspMsg) < 0) {
+    return -1;
+  }
+
+  *pRsp = malloc(sizeof(SRpcMsg));
+  if (TD_IS_NULL(*pRsp)) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    free(pMsg);
+    return -1;
+  }
+
+  // TODO
+  (*pRsp)->pCont = pRspMsg;
+
+  return 0;
+}

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

@@ -15,6 +15,8 @@
 
 #include "vnodeDef.h"
 
+#if 0
+
 static int   vnodeBuildCreateTableReq(void **buf, const SVCreateTableReq *pReq);
 static void *vnodeParseCreateTableReq(void *buf, SVCreateTableReq *pReq);
 
@@ -113,4 +115,5 @@ int vnodeBuildDropTableReq(void **buf, const SVDropTableReq *pReq) {
 
 void *vnodeParseDropTableReq(void *buf, SVDropTableReq *pReq) {
   // TODO
-}
+}
+#endif

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

@@ -28,7 +28,6 @@ int vnodeProcessNoWalWMsgs(SVnode *pVnode, SRpcMsg *pMsg) {
 
 int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
   SRpcMsg *  pMsg;
-  SVnodeReq *pVnodeReq;
 
   for (int i = 0; i < taosArrayGetSize(pMsgs); i++) {
     pMsg = *(SRpcMsg **)taosArrayGet(pMsgs, i);
@@ -51,7 +50,6 @@ int vnodeProcessWMsgs(SVnode *pVnode, SArray *pMsgs) {
 }
 
 int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
-  SVnodeReq     vReq;
   SVCreateTbReq vCreateTbReq;
   void *        ptr = vnodeMalloc(pVnode, pMsg->contLen);
   if (ptr == NULL) {
@@ -70,6 +68,7 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
 
   switch (pMsg->msgType) {
     case TDMT_VND_CREATE_STB:
+    case TDMT_VND_CREATE_TABLE:
       tDeserializeSVCreateTbReq(POINTER_SHIFT(pMsg->pCont, sizeof(SMsgHead)), &vCreateTbReq);
       if (metaCreateTable(pVnode->pMeta, &(vCreateTbReq)) < 0) {
         // TODO: handle error
@@ -79,9 +78,9 @@ int vnodeApplyWMsg(SVnode *pVnode, SRpcMsg *pMsg, SRpcMsg **pRsp) {
       break;
     case TDMT_VND_DROP_STB:
     case TDMT_VND_DROP_TABLE:
-      if (metaDropTable(pVnode->pMeta, vReq.dtReq.uid) < 0) {
+      // if (metaDropTable(pVnode->pMeta, vReq.dtReq.uid) < 0) {
-        // TODO: handle error
+      //   // TODO: handle error
-      }
+      // }
       break;
     case TDMT_VND_SUBMIT:
       if (tsdbInsertData(pVnode->pTsdb, (SSubmitMsg *)ptr) < 0) {

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

@@ -351,7 +351,7 @@ static int metaCtbIdxCb(DB *pIdx, const DBT *pKey, const DBT *pValue, DBT *pSKey
     pDbt[0].size = sizeof(pTbCfg->ctbCfg.suid);
 
     // Second key is the first tag
-    void *pTagVal = tdGetKVRowValOfCol(pTbCfg->ctbCfg.pTag, 0);
+    void *pTagVal = tdGetKVRowValOfCol(pTbCfg->ctbCfg.pTag, (kvRowColIdx(pTbCfg->ctbCfg.pTag))[0].colId);
     pDbt[1].data = varDataVal(pTagVal);
     pDbt[1].size = varDataLen(pTagVal);
 
@@ -403,10 +403,10 @@ static void *metaDecodeTbInfo(void *buf, STbCfg *pTbCfg) {
   buf = taosDecodeFixedU8(buf, &(pTbCfg->type));
 
   if (pTbCfg->type == META_SUPER_TABLE) {
-    buf = taosDecodeVariantU32(buf, pTbCfg->stbCfg.nTagCols);
+    buf = taosDecodeVariantU32(buf, &(pTbCfg->stbCfg.nTagCols));
     pTbCfg->stbCfg.pTagSchema = (SSchema *)malloc(sizeof(SSchema) * pTbCfg->stbCfg.nTagCols);
     for (uint32_t i = 0; i < pTbCfg->stbCfg.nTagCols; i++) {
-      buf = taosDecodeFixedI8(buf, &pTbCfg->stbCfg.pSchema[i].type);
+      buf = taosDecodeFixedI8(buf, &(pTbCfg->stbCfg.pSchema[i].type));
       buf = taosDecodeFixedI32(buf, &pTbCfg->stbCfg.pSchema[i].colId);
       buf = taosDecodeFixedI32(buf, &pTbCfg->stbCfg.pSchema[i].bytes);
       buf = taosDecodeStringTo(buf, pTbCfg->stbCfg.pSchema[i].name);
@@ -428,4 +428,82 @@ static void metaClearTbCfg(STbCfg *pTbCfg) {
   } else if (pTbCfg->type == META_CHILD_TABLE) {
     tfree(pTbCfg->ctbCfg.pTag);
   }
+}
+
+/* ------------------------ FOR QUERY ------------------------ */
+int metaGetTableInfo(SMeta *pMeta, char *tbname, STableMetaMsg **ppMsg) {
+  DBT            key = {0};
+  DBT            value = {0};
+  SMetaDB *      pMetaDB = pMeta->pDB;
+  int            ret;
+  STbCfg         tbCfg;
+  SSchemaKey     schemaKey;
+  DBT            key1 = {0};
+  DBT            value1 = {0};
+  uint32_t       ncols;
+  void *         pBuf;
+  int            tlen;
+  STableMetaMsg *pMsg;
+
+  key.data = tbname;
+  key.size = strlen(tbname) + 1;
+
+  ret = pMetaDB->pNameIdx->get(pMetaDB->pNameIdx, NULL, &key, &value, 0);
+  if (ret != 0) {
+    // TODO
+    return -1;
+  }
+
+  metaDecodeTbInfo(value.data, &tbCfg);
+
+  switch (tbCfg.type) {
+    case META_SUPER_TABLE:
+      schemaKey.uid = tbCfg.stbCfg.suid;
+      schemaKey.sver = 0;
+
+      key1.data = &schemaKey;
+      key1.size = sizeof(schemaKey);
+
+      ret = pMetaDB->pSchemaDB->get(pMetaDB->pSchemaDB, &key1, &value1, NULL, 0);
+      if (ret != 0) {
+        // TODO
+        return -1;
+      }
+      pBuf = value1.data;
+      pBuf = taosDecodeFixedU32(pBuf, &ncols);
+
+      tlen = sizeof(STableMetaMsg) + (tbCfg.stbCfg.nTagCols + ncols) * sizeof(SSchema);
+      pMsg = calloc(1, tlen);
+      if (pMsg == NULL) {
+        terrno = TSDB_CODE_OUT_OF_MEMORY;
+        return -1;
+      }
+
+      strcpy(pMsg->tbFname, tbCfg.name);
+      pMsg->numOfTags = tbCfg.stbCfg.nTagCols;
+      pMsg->numOfColumns = ncols;
+      pMsg->tableType = tbCfg.type;
+      pMsg->sversion = 0;
+      pMsg->tversion = 0;
+      pMsg->suid = tbCfg.stbCfg.suid;
+      pMsg->tuid = tbCfg.stbCfg.suid;
+      for (size_t i = 0; i < tbCfg.stbCfg.nTagCols; i++) {
+
+      }
+
+      break;
+    case META_CHILD_TABLE:
+      ASSERT(0);
+      break;
+    case META_NORMAL_TABLE:
+      ASSERT(0);
+      break;
+    default:
+      ASSERT(0);
+      break;
+  }
+
+  *ppMsg = pMsg;
+
+  return 0;
 }

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

@@ -46,58 +46,4 @@ size_t metaEncodeTbObjFromTbOptions(const STbCfg *pTbOptions, void *pBuf, size_t
   }
 
   return tlen;
-}
-
-int metaEncodeTbCfg(void **pBuf, STbCfg *pTbCfg) {
-  int tsize = 0;
-
-  tsize += taosEncodeString(pBuf, pTbCfg->name);
-  tsize += taosEncodeFixedU32(pBuf, pTbCfg->ttl);
-  tsize += taosEncodeFixedU32(pBuf, pTbCfg->keep);
-  tsize += taosEncodeFixedU8(pBuf, pTbCfg->type);
-
-  switch (pTbCfg->type) {
-    case META_SUPER_TABLE:
-      tsize += taosEncodeFixedU64(pBuf, pTbCfg->stbCfg.suid);
-      tsize += tdEncodeSchema(pBuf, pTbCfg->stbCfg.pSchema);
-      tsize += tdEncodeSchema(pBuf, pTbCfg->stbCfg.pTagSchema);
-      break;
-    case META_CHILD_TABLE:
-      tsize += taosEncodeFixedU64(pBuf, pTbCfg->ctbCfg.suid);
-      tsize += tdEncodeKVRow(pBuf, pTbCfg->ctbCfg.pTag);
-      break;
-    case META_NORMAL_TABLE:
-      tsize += tdEncodeSchema(pBuf, pTbCfg->ntbCfg.pSchema);
-      break;
-    default:
-      break;
-  }
-
-  return tsize;
-}
-
-void *metaDecodeTbCfg(void *pBuf, STbCfg *pTbCfg) {
-  pBuf = taosDecodeString(pBuf, &(pTbCfg->name));
-  pBuf = taosDecodeFixedU32(pBuf, &(pTbCfg->ttl));
-  pBuf = taosDecodeFixedU32(pBuf, &(pTbCfg->keep));
-  pBuf = taosDecodeFixedU8(pBuf, &(pTbCfg->type));
-
-  switch (pTbCfg->type) {
-    case META_SUPER_TABLE:
-      pBuf = taosDecodeFixedU64(pBuf, &(pTbCfg->stbCfg.suid));
-      pBuf = tdDecodeSchema(pBuf, &(pTbCfg->stbCfg.pSchema));
-      pBuf = tdDecodeSchema(pBuf, &(pTbCfg->stbCfg.pTagSchema));
-      break;
-    case META_CHILD_TABLE:
-      pBuf = taosDecodeFixedU64(pBuf, &(pTbCfg->ctbCfg.suid));
-      pBuf = tdDecodeKVRow(pBuf, &(pTbCfg->ctbCfg.pTag));
-      break;
-    case META_NORMAL_TABLE:
-      pBuf = tdDecodeSchema(pBuf, &(pTbCfg->ntbCfg.pSchema));
-      break;
-    default:
-      break;
-  }
-
-  return pBuf;
 }

source/libs/catalog/src/catalog.c

@@ -13,10 +13,10 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "catalogInt.h"
 #include "trpc.h"
 #include "query.h"
 #include "tname.h"
+#include "catalogInt.h"
 
 SCatalogMgmt ctgMgmt = {0};
 
@@ -75,15 +75,14 @@ int32_t ctgGetDBVgroupFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEp
 }
 
 
-int32_t ctgGetTableMetaFromCache(struct SCatalog* pCatalog, const char *dbName, const char* pTableName, STableMeta** pTableMeta, int32_t *exist) {
+int32_t ctgGetTableMetaFromCache(struct SCatalog* pCatalog, const SName* pTableName, STableMeta** pTableMeta, int32_t *exist) {
   if (NULL == pCatalog->tableCache.cache) {
     *exist = 0;
     return TSDB_CODE_SUCCESS;
   }
 
   char tbFullName[TSDB_TABLE_FNAME_LEN];
-
+  tNameExtractFullName(pTableName, tbFullName);
-  snprintf(tbFullName, sizeof(tbFullName), "%s.%s", dbName, pTableName);
 
   *pTableMeta = NULL;
 
@@ -144,14 +143,13 @@ void ctgGenEpSet(SEpSet *epSet, SVgroupInfo *vgroupInfo) {
   }
 }
 
-int32_t ctgGetTableMetaFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char *pDBName, const char* pTableName, STableMetaOutput* output) {
+int32_t ctgGetTableMetaFromMnode(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, STableMetaOutput* output) {
-  if (NULL == pCatalog || NULL == pRpc || NULL == pMgmtEps || NULL == pDBName || NULL == pTableName || NULL == output) {
+  if (NULL == pCatalog || NULL == pRpc || NULL == pMgmtEps || NULL == pTableName || NULL == output) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
   char tbFullName[TSDB_TABLE_FNAME_LEN];
-
+  tNameExtractFullName(pTableName, tbFullName);
-  snprintf(tbFullName, sizeof(tbFullName), "%s.%s", pDBName, pTableName);
 
   SBuildTableMetaInput bInput = {.vgId = 0, .tableFullName = tbFullName};
   char *msg = NULL;
@@ -270,15 +268,18 @@ _return:
   CTG_RET(code);
 }
 
-int32_t ctgGetVgInfoFromHashValue(SDBVgroupInfo *dbInfo, const char *pDBName, const char *pTableName, SVgroupInfo *pVgroup) {
+int32_t ctgGetVgInfoFromHashValue(SDBVgroupInfo *dbInfo, const SName *pTableName, SVgroupInfo *pVgroup) {
   int32_t code = 0;
   
   CTG_LOCK(CTG_READ, &dbInfo->lock);
   
   int32_t vgNum = taosHashGetSize(dbInfo->vgInfo);
+  char db[TSDB_DB_FNAME_LEN] = {0};
+  tNameGetFullDbName(pTableName, db);
+
   if (vgNum <= 0) {
-    ctgError("db[%s] vgroup cache invalid, vgroup number:%d", pDBName, vgNum);
+    ctgError("db[%s] vgroup cache invalid, vgroup number:%d", db, vgNum);
-    CTG_ERR_JRET(TSDB_CODE_TSC_DB_NOT_SELECTED);
+    CTG_ERR_RET(TSDB_CODE_TSC_DB_NOT_SELECTED);
   }
 
   tableNameHashFp fp = NULL;
@@ -287,8 +288,7 @@ int32_t ctgGetVgInfoFromHashValue(SDBVgroupInfo *dbInfo, const char *pDBName, co
   CTG_ERR_JRET(ctgGetHashFunction(dbInfo->hashMethod, &fp));
 
   char tbFullName[TSDB_TABLE_FNAME_LEN];
-
+  tNameExtractFullName(pTableName, tbFullName);
-  snprintf(tbFullName, sizeof(tbFullName), "%s.%s", pDBName, pTableName);
 
   uint32_t hashValue = (*fp)(tbFullName, (uint32_t)strlen(tbFullName));
 
@@ -317,24 +317,24 @@ _return:
   CTG_RET(TSDB_CODE_SUCCESS);
 }
 
-int32_t ctgGetTableMetaImpl(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, bool forceUpdate, STableMeta** pTableMeta) {
+int32_t ctgGetTableMetaImpl(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, bool forceUpdate, STableMeta** pTableMeta) {
-  if (NULL == pCatalog || NULL == pDBName || NULL == pRpc || NULL == pMgmtEps || NULL == pTableName || NULL == pTableMeta) {
+  if (NULL == pCatalog || NULL == pRpc || NULL == pMgmtEps || NULL == pTableName || NULL == pTableMeta) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
   
   int32_t exist = 0;
 
   if (!forceUpdate) {  
-    CTG_ERR_RET(ctgGetTableMetaFromCache(pCatalog, pDBName, pTableName, pTableMeta, &exist));
+    CTG_ERR_RET(ctgGetTableMetaFromCache(pCatalog, pTableName, pTableMeta, &exist));
 
     if (exist) {
       return TSDB_CODE_SUCCESS;
     }
   }
 
-  CTG_ERR_RET(catalogRenewTableMeta(pCatalog, pRpc, pMgmtEps, pDBName, pTableName));
+  CTG_ERR_RET(catalogRenewTableMeta(pCatalog, pRpc, pMgmtEps, pTableName));
 
-  CTG_ERR_RET(ctgGetTableMetaFromCache(pCatalog, pDBName, pTableName, pTableMeta, &exist));
+  CTG_ERR_RET(ctgGetTableMetaFromCache(pCatalog, pTableName, pTableMeta, &exist));
 
   if (0 == exist) {
     ctgError("get table meta from cache failed, but fetch succeed");
@@ -433,7 +433,7 @@ int32_t ctgGetDBVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgm
   strncpy(input.db, dbName, sizeof(input.db));
   input.db[sizeof(input.db) - 1] = 0;
   input.vgVersion = CTG_DEFAULT_INVALID_VERSION;
-  
+
   CTG_ERR_RET(ctgGetDBVgroupFromMnode(pCatalog, pRpc, pMgmtEps, &input, &DbOut));
 
   CTG_ERR_RET(catalogUpdateDBVgroup(pCatalog, dbName, &DbOut.dbVgroup));
@@ -452,7 +452,7 @@ int32_t catalogInit(SCatalogCfg *cfg) {
 
   if (cfg) {
     memcpy(&ctgMgmt.cfg, cfg, sizeof(*cfg));
-    
+
     if (ctgMgmt.cfg.maxDBCacheNum == 0) {
       ctgMgmt.cfg.maxDBCacheNum = CTG_DEFAULT_CACHE_DB_NUMBER;
     }
@@ -632,25 +632,25 @@ int32_t catalogUpdateDBVgroup(struct SCatalog* pCatalog, const char* dbName, SDB
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta) {
+int32_t catalogGetTableMeta(struct SCatalog* pCatalog, void *pTransporter, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta) {
-  return ctgGetTableMetaImpl(pCatalog, pTransporter, pMgmtEps, pDBName, pTableName, false, pTableMeta);
+  return ctgGetTableMetaImpl(pCatalog, pTransporter, pMgmtEps, pTableName, false, pTableMeta);
 }
 
-int32_t catalogRenewTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName) {
+int32_t catalogRenewTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName) {
-  if (NULL == pCatalog || NULL == pDBName || NULL == pRpc || NULL == pMgmtEps || NULL == pTableName) {
+  if (NULL == pCatalog || NULL == pRpc || NULL == pMgmtEps || NULL == pTableName) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
   SVgroupInfo vgroupInfo = {0};
   int32_t code = 0;
-  
+
-  CTG_ERR_RET(catalogGetTableHashVgroup(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, &vgroupInfo));
+  CTG_ERR_RET(catalogGetTableHashVgroup(pCatalog, pRpc, pMgmtEps, pTableName, &vgroupInfo));
 
   STableMetaOutput output = {0};
   
   //CTG_ERR_RET(ctgGetTableMetaFromVnode(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, &vgroupInfo, &output));
 
-  CTG_ERR_RET(ctgGetTableMetaFromMnode(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, &output));
+  CTG_ERR_RET(ctgGetTableMetaFromMnode(pCatalog, pRpc, pMgmtEps, pTableName, &output));
 
   CTG_ERR_JRET(ctgUpdateTableMetaCache(pCatalog, &output));
 
@@ -661,12 +661,12 @@ _return:
   CTG_RET(code);
 }
 
-int32_t catalogRenewAndGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta) {
+int32_t catalogRenewAndGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta) {
-  return ctgGetTableMetaImpl(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, true, pTableMeta);
+  return ctgGetTableMetaImpl(pCatalog, pRpc, pMgmtEps, pTableName, true, pTableMeta);
 }
 
-int32_t catalogGetTableDistVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SArray** pVgroupList) {
+int32_t catalogGetTableDistVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, SArray** pVgroupList) {
-  if (NULL == pCatalog || NULL == pRpc || NULL == pMgmtEps || NULL == pDBName || NULL == pTableName || NULL == pVgroupList) {
+  if (NULL == pCatalog || NULL == pRpc || NULL == pMgmtEps || NULL == pTableName || NULL == pVgroupList) {
     CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
   }
   
@@ -678,9 +678,11 @@ int32_t catalogGetTableDistVgroup(struct SCatalog* pCatalog, void *pRpc, const S
 
   *pVgroupList = NULL;
   
-  CTG_ERR_JRET(catalogGetTableMeta(pCatalog, pRpc, pMgmtEps, pDBName, pTableName, &tbMeta));
+  CTG_ERR_JRET(catalogGetTableMeta(pCatalog, pRpc, pMgmtEps, pTableName, &tbMeta));
 
-  CTG_ERR_JRET(ctgGetDBVgroup(pCatalog, pRpc, pMgmtEps, pDBName, false, &dbVgroup));
+  char db[TSDB_DB_FNAME_LEN] = {0};
+  tNameGetFullDbName(pTableName, db);
+  CTG_ERR_JRET(ctgGetDBVgroup(pCatalog, pRpc, pMgmtEps, db, false, &dbVgroup));
 
   if (tbMeta->tableType == TSDB_SUPER_TABLE) {
     CTG_ERR_JRET(ctgGetVgInfoFromDB(pCatalog, pRpc, pMgmtEps, dbVgroup, pVgroupList));
@@ -723,14 +725,16 @@ _return:
 }
 
 
-int32_t catalogGetTableHashVgroup(struct SCatalog *pCatalog, void *pTransporter, const SEpSet *pMgmtEps, const char *pDBName, const char *pTableName, SVgroupInfo *pVgroup) {
+int32_t catalogGetTableHashVgroup(struct SCatalog *pCatalog, void *pTransporter, const SEpSet *pMgmtEps, const SName *pTableName, SVgroupInfo *pVgroup) {
   SDBVgroupInfo* dbInfo = NULL;
   int32_t code = 0;
-  int32_t vgId = 0;
 
-  CTG_ERR_RET(ctgGetDBVgroup(pCatalog, pTransporter, pMgmtEps, pDBName, false, &dbInfo));
+  char db[TSDB_DB_FNAME_LEN] = {0};
+  tNameGetFullDbName(pTableName, db);
 
-  CTG_ERR_JRET(ctgGetVgInfoFromHashValue(dbInfo, pDBName, pTableName, pVgroup));
+  CTG_ERR_RET(ctgGetDBVgroup(pCatalog, pTransporter, pMgmtEps, db, false, &dbInfo));
+
+  CTG_ERR_JRET(ctgGetVgInfoFromHashValue(dbInfo, pTableName, pVgroup));
 
 _return:
 
@@ -751,13 +755,12 @@ int32_t catalogGetAllMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* p
   int32_t code = 0;
 
   if (pReq->pTableName) {
-    char dbName[TSDB_DB_FNAME_LEN];
     int32_t tbNum = (int32_t)taosArrayGetSize(pReq->pTableName);
     if (tbNum <= 0) {
       ctgError("empty table name list");
       CTG_ERR_RET(TSDB_CODE_CTG_INVALID_INPUT);
     }
-    
+
     pRsp->pTableMeta = taosArrayInit(tbNum, POINTER_BYTES);
     if (NULL == pRsp->pTableMeta) {
       ctgError("taosArrayInit num[%d] failed", tbNum);
@@ -768,9 +771,7 @@ int32_t catalogGetAllMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* p
       SName *name = taosArrayGet(pReq->pTableName, i);
       STableMeta *pTableMeta = NULL;
       
-      snprintf(dbName, sizeof(dbName), "%d.%s", name->acctId, name->dbname);
+      CTG_ERR_JRET(catalogGetTableMeta(pCatalog, pRpc, pMgmtEps, name, &pTableMeta));
-
-      CTG_ERR_JRET(catalogGetTableMeta(pCatalog, pRpc, pMgmtEps, dbName, name->tname, &pTableMeta));
 
       if (NULL == taosArrayPush(pRsp->pTableMeta, &pTableMeta)) {
         ctgError("taosArrayPush failed, idx:%d", i);

source/libs/catalog/test/catalogTests.cpp

@@ -388,7 +388,11 @@ TEST(tableMeta, normalTable) {
   code = catalogGetHandle(ctgTestClusterId, &pCtg);
   ASSERT_EQ(code, 0);
 
-  code = catalogGetTableHashVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestTablename, &vgInfo);
+  SName n = {.type = T_NAME_TABLE, .acctId = 1};
+  strcpy(n.dbname, "db1");
+  strcpy(n.tname, ctgTestTablename);
+
+  code = catalogGetTableHashVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgInfo);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(vgInfo.vgId, 8);
   ASSERT_EQ(vgInfo.numOfEps, 3);
@@ -396,7 +400,7 @@ TEST(tableMeta, normalTable) {
   ctgTestSetPrepareTableMeta();
 
   STableMeta *tableMeta = NULL;
-  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestTablename, &tableMeta);
+  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &tableMeta);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(tableMeta->vgId, 8);
   ASSERT_EQ(tableMeta->tableType, TSDB_NORMAL_TABLE);
@@ -408,7 +412,7 @@ TEST(tableMeta, normalTable) {
   ASSERT_EQ(tableMeta->tableInfo.rowSize, 12);
 
   tableMeta = NULL;
-  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestTablename, &tableMeta);
+  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &tableMeta);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(tableMeta->vgId, 8);
   ASSERT_EQ(tableMeta->tableType, TSDB_NORMAL_TABLE);
@@ -433,14 +437,15 @@ TEST(tableMeta, childTableCase) {
 
   //sendCreateDbMsg(pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet);
   
-  int32_t code = catalogInit(NULL);
+  int32_t code = catalogGetHandle(ctgTestClusterId, &pCtg);
   ASSERT_EQ(code, 0);
 
-  code = catalogGetHandle(ctgTestClusterId, &pCtg);
+  SName n = {.type = T_NAME_TABLE, .acctId = 1};
-  ASSERT_EQ(code, 0);
+  strcpy(n.dbname, "db1");
+  strcpy(n.tname, ctgTestCTablename);
 
   STableMeta *tableMeta = NULL;
-  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestCTablename, &tableMeta);
+  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &tableMeta);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(tableMeta->vgId, 9);
   ASSERT_EQ(tableMeta->tableType, TSDB_CHILD_TABLE);
@@ -452,7 +457,7 @@ TEST(tableMeta, childTableCase) {
   ASSERT_EQ(tableMeta->tableInfo.rowSize, 12);
 
   tableMeta = NULL;
-  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestCTablename, &tableMeta);
+  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &tableMeta);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(tableMeta->vgId, 9);
   ASSERT_EQ(tableMeta->tableType, TSDB_CHILD_TABLE);
@@ -464,7 +469,9 @@ TEST(tableMeta, childTableCase) {
   ASSERT_EQ(tableMeta->tableInfo.rowSize, 12);
 
   tableMeta = NULL;
-  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestSTablename, &tableMeta);
+
+  strcpy(n.tname, ctgTestSTablename);
+  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &tableMeta);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(tableMeta->vgId, 0);
   ASSERT_EQ(tableMeta->tableType, TSDB_SUPER_TABLE);
@@ -488,15 +495,15 @@ TEST(tableMeta, superTableCase) {
   initQueryModuleMsgHandle();
 
   //sendCreateDbMsg(pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet);
-  
+  int32_t code = catalogGetHandle(ctgTestClusterId, &pCtg);
-  int32_t code = catalogInit(NULL);
   ASSERT_EQ(code, 0);
 
-  code = catalogGetHandle(ctgTestClusterId, &pCtg);
+  SName n = {.type = T_NAME_TABLE, .acctId = 1};
-  ASSERT_EQ(code, 0);
+  strcpy(n.dbname, "db1");
+  strcpy(n.tname, ctgTestSTablename);
 
   STableMeta *tableMeta = NULL;
-  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestSTablename, &tableMeta);
+  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &tableMeta);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(tableMeta->vgId, 0);
   ASSERT_EQ(tableMeta->tableType, TSDB_SUPER_TABLE);
@@ -510,7 +517,10 @@ TEST(tableMeta, superTableCase) {
   ctgTestSetPrepareCTableMeta();
 
   tableMeta = NULL;
-  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestCTablename, &tableMeta);
+
+  strcpy(n.dbname, "db1");
+  strcpy(n.tname, ctgTestCTablename);
+  code = catalogGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &tableMeta);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(tableMeta->vgId, 9);
   ASSERT_EQ(tableMeta->tableType, TSDB_CHILD_TABLE);
@@ -522,7 +532,7 @@ TEST(tableMeta, superTableCase) {
   ASSERT_EQ(tableMeta->tableInfo.rowSize, 12);
 
   tableMeta = NULL;
-  code = catalogRenewAndGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestCTablename, &tableMeta);
+  code = catalogRenewAndGetTableMeta(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &tableMeta);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(tableMeta->vgId, 9);
   ASSERT_EQ(tableMeta->tableType, TSDB_CHILD_TABLE);
@@ -550,14 +560,14 @@ TEST(tableDistVgroup, normalTable) {
 
   //sendCreateDbMsg(pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet);
   
-  int32_t code = catalogInit(NULL);
+  int32_t code = catalogGetHandle(ctgTestClusterId, &pCtg);
   ASSERT_EQ(code, 0);
 
-  code = catalogGetHandle(ctgTestClusterId, &pCtg);
+  SName n = {.type = T_NAME_TABLE, .acctId = 1};
-  ASSERT_EQ(code, 0);
+  strcpy(n.dbname, "db1");
+  strcpy(n.tname, ctgTestTablename);
 
-
+  code = catalogGetTableDistVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgList);
-  code = catalogGetTableDistVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestTablename, &vgList);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(taosArrayGetSize((const SArray *)vgList), 1);
   vgInfo = (SVgroupInfo *)taosArrayGet(vgList, 0);
@@ -585,7 +595,11 @@ TEST(tableDistVgroup, childTableCase) {
   code = catalogGetHandle(ctgTestClusterId, &pCtg);
   ASSERT_EQ(code, 0);
 
-  code = catalogGetTableDistVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestCTablename, &vgList);
+  SName n = {.type = T_NAME_TABLE, .acctId = 1};
+  strcpy(n.dbname, "db1");
+  strcpy(n.tname, ctgTestCTablename);
+
+  code = catalogGetTableDistVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgList);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(taosArrayGetSize((const SArray *)vgList), 1);
   vgInfo = (SVgroupInfo *)taosArrayGet(vgList, 0);
@@ -607,14 +621,14 @@ TEST(tableDistVgroup, superTableCase) {
   initQueryModuleMsgHandle();
 
   //sendCreateDbMsg(pConn->pTransporter, &pConn->pAppInfo->mgmtEp.epSet);
-  
+  int32_t code = catalogGetHandle(ctgTestClusterId, &pCtg);
-  int32_t code = catalogInit(NULL);
   ASSERT_EQ(code, 0);
 
-  code = catalogGetHandle(ctgTestClusterId, &pCtg);
+  SName n = {.type = T_NAME_TABLE, .acctId = 1};
-  ASSERT_EQ(code, 0);
+  strcpy(n.dbname, "db1");
+  strcpy(n.tname, ctgTestSTablename);
 
-  code = catalogGetTableDistVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, ctgTestDbname, ctgTestSTablename, &vgList);
+  code = catalogGetTableDistVgroup(pCtg, mockPointer, (const SEpSet *)mockPointer, &n, &vgList);
   ASSERT_EQ(code, 0);
   ASSERT_EQ(taosArrayGetSize((const SArray *)vgList), 10);
   vgInfo = (SVgroupInfo *)taosArrayGet(vgList, 0);

source/libs/index/inc/index_cache.h

@@ -30,14 +30,18 @@
 extern "C" {
 #endif
 
+typedef struct MemTable {
+  T_REF_DECLARE()
+  SSkipList* mem;
+} MemTable;
 typedef struct IndexCache {
   T_REF_DECLARE()
-  SSkipList *mem, *imm;
+  MemTable *mem, *imm;
-  SIndex*    index;
+  SIndex*   index;
-  char*      colName;
+  char*     colName;
-  int32_t    version;
+  int32_t   version;
-  int32_t    nTerm;
+  int32_t   nTerm;
-  int8_t     type;
+  int8_t    type;
 
   pthread_mutex_t mtx;
 } IndexCache;
@@ -45,7 +49,6 @@ typedef struct IndexCache {
 #define CACHE_VERSION(cache) atomic_load_32(&cache->version)
 typedef struct CacheTerm {
   // key
-  int32_t nColVal;
   char*   colVal;
   int32_t version;
   // value

source/libs/index/src/index.c

@@ -34,9 +34,7 @@ int32_t indexInit() {
   return indexQhandle == NULL ? -1 : 0;
   // do nothing
 }
-void indexCleanUp() {
+void indexCleanUp() { taosCleanUpScheduler(indexQhandle); }
-  taosCleanUpScheduler(indexQhandle);
-}
 
 static int uidCompare(const void* a, const void* b) {
   uint64_t u1 = *(uint64_t*)a;
@@ -63,7 +61,9 @@ static int  indexMergeFinalResults(SArray* interResults, EIndexOperatorType oTyp
 int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
   // pthread_once(&isInit, indexInit);
   SIndex* sIdx = calloc(1, sizeof(SIndex));
-  if (sIdx == NULL) { return -1; }
+  if (sIdx == NULL) {
+    return -1;
+  }
 
 #ifdef USE_LUCENE
   index_t* index = index_open(path);
@@ -99,7 +99,9 @@ void indexClose(SIndex* sIdx) {
   void* iter = taosHashIterate(sIdx->colObj, NULL);
   while (iter) {
     IndexCache** pCache = iter;
-    if (*pCache) { indexCacheUnRef(*pCache); }
+    if (*pCache) {
+      indexCacheUnRef(*pCache);
+    }
     iter = taosHashIterate(sIdx->colObj, iter);
   }
   taosHashCleanup(sIdx->colObj);
@@ -133,7 +135,7 @@ int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
     SIndexTerm*  p = taosArrayGetP(fVals, i);
     IndexCache** cache = taosHashGet(index->colObj, p->colName, p->nColName);
-    if (*cache == NULL) {
+    if (cache == NULL) {
       IndexCache* pCache = indexCacheCreate(index, p->colName, p->colType);
       taosHashPut(index->colObj, p->colName, p->nColName, &pCache, sizeof(void*));
     }
@@ -143,10 +145,11 @@ int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
     SIndexTerm*  p = taosArrayGetP(fVals, i);
     IndexCache** cache = taosHashGet(index->colObj, p->colName, p->nColName);
-
     assert(*cache != NULL);
     int ret = indexCachePut(*cache, p, uid);
-    if (ret != 0) { return ret; }
+    if (ret != 0) {
+      return ret;
+    }
   }
 
 #endif
@@ -224,17 +227,20 @@ SIndexOpts* indexOptsCreate() {
 #endif
   return NULL;
 }
-void indexOptsDestroy(SIndexOpts* opts){
+void indexOptsDestroy(SIndexOpts* opts) {
 #ifdef USE_LUCENE
 #endif
-} /*
+  return;
-   * @param: oper
+}
-   *
+/*
-   */
+ * @param: oper
-
+ *
+ */
 SIndexMultiTermQuery* indexMultiTermQueryCreate(EIndexOperatorType opera) {
   SIndexMultiTermQuery* p = (SIndexMultiTermQuery*)malloc(sizeof(SIndexMultiTermQuery));
-  if (p == NULL) { return NULL; }
+  if (p == NULL) {
+    return NULL;
+  }
   p->opera = opera;
   p->query = taosArrayInit(4, sizeof(SIndexTermQuery));
   return p;
@@ -253,15 +259,12 @@ int indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EInde
   return 0;
 }
 
-SIndexTerm* indexTermCreate(int64_t            suid,
+SIndexTerm* indexTermCreate(int64_t suid, SIndexOperOnColumn oper, uint8_t colType, const char* colName,
-                            SIndexOperOnColumn oper,
+                            int32_t nColName, const char* colVal, int32_t nColVal) {
-                            uint8_t            colType,
-                            const char*        colName,
-                            int32_t            nColName,
-                            const char*        colVal,
-                            int32_t            nColVal) {
   SIndexTerm* t = (SIndexTerm*)calloc(1, (sizeof(SIndexTerm)));
-  if (t == NULL) { return NULL; }
+  if (t == NULL) {
+    return NULL;
+  }
 
   t->suid = suid;
   t->operType = oper;
@@ -282,9 +285,7 @@ void indexTermDestroy(SIndexTerm* p) {
   free(p);
 }
 
-SIndexMultiTerm* indexMultiTermCreate() {
+SIndexMultiTerm* indexMultiTermCreate() { return taosArrayInit(4, sizeof(SIndexTerm*)); }
-  return taosArrayInit(4, sizeof(SIndexTerm*));
-}
 
 int indexMultiTermAdd(SIndexMultiTerm* terms, SIndexTerm* term) {
   taosArrayPush(terms, &term);
@@ -307,7 +308,7 @@ static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result
   IndexCache* cache = NULL;
   pthread_mutex_lock(&sIdx->mtx);
   IndexCache** pCache = taosHashGet(sIdx->colObj, colName, nColName);
-  if (*pCache == NULL) {
+  if (pCache == NULL) {
     pthread_mutex_unlock(&sIdx->mtx);
     return -1;
   }
@@ -335,7 +336,9 @@ static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result
   return 0;
 }
 static void indexInterResultsDestroy(SArray* results) {
-  if (results == NULL) { return; }
+  if (results == NULL) {
+    return;
+  }
 
   size_t sz = taosArrayGetSize(results);
   for (size_t i = 0; i < sz; i++) {
@@ -366,7 +369,9 @@ static int indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType
 }
 
 int indexFlushCacheTFile(SIndex* sIdx, void* cache) {
-  if (sIdx == NULL) { return -1; }
+  if (sIdx == NULL) {
+    return -1;
+  }
   indexWarn("suid %" PRIu64 " merge cache into tindex", sIdx->suid);
 
   IndexCache*  pCache = (IndexCache*)cache;
@@ -399,7 +404,6 @@ int indexFlushCacheTFile(SIndex* sIdx, void* cache) {
       TFileValue* tfv = tfileValueCreate(cv->colVal);
       taosArrayAddAll(tfv->tableId, cv->val);
       taosArrayPush(result, &tfv);
-
       // copy to final Result;
       cn = cacheIter->next(cacheIter);
     } else {
@@ -433,7 +437,9 @@ int indexFlushCacheTFile(SIndex* sIdx, void* cache) {
     indexError("faile to open file to write");
   } else {
     int ret = tfileWriterPut(tw, result);
-    if (ret != 0) { indexError("faile to write into tindex "); }
+    if (ret != 0) {
+      indexError("faile to write into tindex ");
+    }
   }
   // not free later, just put int table cache
   indexCacheDestroyImm(pCache);

source/libs/index/src/index_cache.c

@@ -23,46 +23,22 @@
 #define MEM_TERM_LIMIT 1000000
 // ref index_cache.h:22
 //#define CACHE_KEY_LEN(p) \
-//  (sizeof(int32_t) + sizeof(uint16_t) + sizeof(p->colType) + sizeof(p->nColVal) + p->nColVal + sizeof(uint64_t) + sizeof(p->operType))
+//  (sizeof(int32_t) + sizeof(uint16_t) + sizeof(p->colType) + sizeof(p->nColVal) + p->nColVal + sizeof(uint64_t) +
+//  sizeof(p->operType))
 
-static void cacheTermDestroy(CacheTerm* ct) {
+static void indexMemRef(MemTable* tbl);
-  if (ct == NULL) { return; }
+static void indexMemUnRef(MemTable* tbl);
 
-  free(ct->colVal);
+static void    cacheTermDestroy(CacheTerm* ct);
-  free(ct);
+static char*   getIndexKey(const void* pData);
-}
+static int32_t compareKey(const void* l, const void* r);
-static char* getIndexKey(const void* pData) {
-  CacheTerm* p = (CacheTerm*)pData;
-  return (char*)p;
-}
 
-static int32_t compareKey(const void* l, const void* r) {
+static MemTable* indexInternalCacheCreate(int8_t type);
-  CacheTerm* lt = (CacheTerm*)l;
-  CacheTerm* rt = (CacheTerm*)r;
 
-  // compare colVal
+static void doMergeWork(SSchedMsg* msg);
-  int i, j;
+static bool indexCacheIteratorNext(Iterate* itera);
-  for (i = 0, j = 0; i < lt->nColVal && j < rt->nColVal; i++, j++) {
-    if (lt->colVal[i] == rt->colVal[j]) {
-      continue;
-    } else {
-      return lt->colVal[i] < rt->colVal[j] ? -1 : 1;
-    }
-  }
-  if (i < lt->nColVal) {
-    return 1;
-  } else if (j < rt->nColVal) {
-    return -1;
-  }
-  // compare version
-  return rt->version - lt->version;
-}
 
-static SSkipList* indexInternalCacheCreate(int8_t type) {
+static IterateValue* indexCacheIteratorGetValue(Iterate* iter);
-  if (type == TSDB_DATA_TYPE_BINARY) {
-    return tSkipListCreate(MAX_SKIP_LIST_LEVEL, type, MAX_INDEX_KEY_LEN, compareKey, SL_ALLOW_DUP_KEY, getIndexKey);
-  }
-}
 
 IndexCache* indexCacheCreate(SIndex* idx, const char* colName, int8_t type) {
   IndexCache* cache = calloc(1, sizeof(IndexCache));
@@ -83,7 +59,15 @@ IndexCache* indexCacheCreate(SIndex* idx, const char* colName, int8_t type) {
   return cache;
 }
 void indexCacheDebug(IndexCache* cache) {
-  SSkipListIterator* iter = tSkipListCreateIter(cache->mem);
+  MemTable* tbl = NULL;
+
+  pthread_mutex_lock(&cache->mtx);
+  tbl = cache->mem;
+  indexMemRef(tbl);
+  pthread_mutex_unlock(&cache->mtx);
+
+  SSkipList*         slt = tbl->mem;
+  SSkipListIterator* iter = tSkipListCreateIter(slt);
   while (tSkipListIterNext(iter)) {
     SSkipListNode* node = tSkipListIterGet(iter);
     CacheTerm*     ct = (CacheTerm*)SL_GET_NODE_DATA(node);
@@ -93,6 +77,8 @@ void indexCacheDebug(IndexCache* cache) {
     }
   }
   tSkipListDestroyIter(iter);
+
+  indexMemUnRef(tbl);
 }
 
 void indexCacheDestroySkiplist(SSkipList* slt) {
@@ -100,71 +86,50 @@ void indexCacheDestroySkiplist(SSkipList* slt) {
   while (tSkipListIterNext(iter)) {
     SSkipListNode* node = tSkipListIterGet(iter);
     CacheTerm*     ct = (CacheTerm*)SL_GET_NODE_DATA(node);
-    if (ct != NULL) {}
+    if (ct != NULL) {
+    }
   }
   tSkipListDestroyIter(iter);
+  tSkipListDestroy(slt);
 }
 void indexCacheDestroyImm(IndexCache* cache) {
+  MemTable* tbl = NULL;
   pthread_mutex_lock(&cache->mtx);
-  SSkipList* timm = (SSkipList*)cache->imm;
+  tbl = cache->imm;
   cache->imm = NULL;  // or throw int bg thread
   pthread_mutex_unlock(&cache->mtx);
-
+  indexMemUnRef(tbl);
-  indexCacheDestroySkiplist(timm);
 }
 void indexCacheDestroy(void* cache) {
   IndexCache* pCache = cache;
-  if (pCache == NULL) { return; }
+  if (pCache == NULL) {
-  tSkipListDestroy(pCache->mem);
+    return;
-  tSkipListDestroy(pCache->imm);
+  }
+  indexMemUnRef(pCache->mem);
+  indexMemUnRef(pCache->imm);
   free(pCache->colName);
 
   free(pCache);
 }
 
-static void doMergeWork(SSchedMsg* msg) {
-  IndexCache* pCache = msg->ahandle;
-  SIndex*     sidx = (SIndex*)pCache->index;
-  indexFlushCacheTFile(sidx, pCache);
-}
-static bool indexCacheIteratorNext(Iterate* itera) {
-  SSkipListIterator* iter = itera->iter;
-  if (iter == NULL) { return false; }
-
-  IterateValue* iv = &itera->val;
-  iterateValueDestroy(iv, false);
-
-  bool next = tSkipListIterNext(iter);
-  if (next) {
-    SSkipListNode* node = tSkipListIterGet(iter);
-    CacheTerm*     ct = (CacheTerm*)SL_GET_NODE_DATA(node);
-
-    iv->type = ct->operaType;
-    iv->colVal = ct->colVal;
-
-    taosArrayPush(iv->val, &ct->uid);
-  }
-
-  return next;
-}
-
-static IterateValue* indexCacheIteratorGetValue(Iterate* iter) {
-  return &iter->val;
-}
 Iterate* indexCacheIteratorCreate(IndexCache* cache) {
   Iterate* iiter = calloc(1, sizeof(Iterate));
-  if (iiter == NULL) { return NULL; }
+  if (iiter == NULL) {
+    return NULL;
+  }
 
+  MemTable* tbl = cache->imm;
   iiter->val.val = taosArrayInit(1, sizeof(uint64_t));
-  iiter->iter = cache->imm != NULL ? tSkipListCreateIter(cache->imm) : NULL;
+  iiter->iter = tbl != NULL ? tSkipListCreateIter(tbl->mem) : NULL;
   iiter->next = indexCacheIteratorNext;
   iiter->getValue = indexCacheIteratorGetValue;
 
   return iiter;
 }
 void indexCacheIteratorDestroy(Iterate* iter) {
-  if (iter == NULL) { return; }
+  if (iter == NULL) {
-
+    return;
+  }
   tSkipListDestroyIter(iter->iter);
   iterateValueDestroy(&iter->val, true);
   free(iter);
@@ -201,18 +166,21 @@ static void indexCacheMakeRoomForWrite(IndexCache* cache) {
 }
 
 int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
-  if (cache == NULL) { return -1; }
+  if (cache == NULL) {
+    return -1;
+  }
 
   IndexCache* pCache = cache;
   indexCacheRef(pCache);
   // encode data
   CacheTerm* ct = calloc(1, sizeof(CacheTerm));
-  if (cache == NULL) { return -1; }
+  if (cache == NULL) {
+    return -1;
+  }
   // set up key
   ct->colType = term->colType;
-  ct->nColVal = term->nColVal;
+  ct->colVal = (char*)calloc(1, sizeof(char) * (term->nColVal + 1));
-  ct->colVal = (char*)calloc(1, sizeof(char) * (ct->nColVal + 1));
+  memcpy(ct->colVal, term->colVal, term->nColVal);
-  memcpy(ct->colVal, term->colVal, ct->nColVal);
   ct->version = atomic_add_fetch_32(&pCache->version, 1);
   // set value
   ct->uid = uid;
@@ -220,8 +188,13 @@ int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
 
   // ugly code, refactor later
   pthread_mutex_lock(&pCache->mtx);
+
   indexCacheMakeRoomForWrite(pCache);
-  tSkipListPut(pCache->mem, (char*)ct);
+  MemTable* tbl = pCache->mem;
+  indexMemRef(tbl);
+  tSkipListPut(tbl->mem, (char*)ct);
+  indexMemUnRef(tbl);
+
   pthread_mutex_unlock(&pCache->mtx);
 
   indexCacheUnRef(pCache);
@@ -233,27 +206,38 @@ int indexCacheDel(void* cache, const char* fieldValue, int32_t fvlen, uint64_t u
   return 0;
 }
 int indexCacheSearch(void* cache, SIndexTermQuery* query, SArray* result, STermValueType* s) {
-  if (cache == NULL) { return -1; }
+  if (cache == NULL) {
+    return -1;
+  }
   IndexCache*     pCache = cache;
   SIndexTerm*     term = query->term;
   EIndexQueryType qtype = query->qType;
 
+  MemTable *mem = NULL, *imm = NULL;
+  pthread_mutex_lock(&pCache->mtx);
+  mem = pCache->mem;
+  imm = pCache->imm;
+  indexMemRef(mem);
+  indexMemRef(imm);
+  pthread_mutex_unlock(&pCache->mtx);
+
   CacheTerm* ct = calloc(1, sizeof(CacheTerm));
-  if (ct == NULL) { return -1; }
+  if (ct == NULL) {
-  ct->nColVal = term->nColVal;
+    return -1;
-  ct->colVal = calloc(1, sizeof(char) * (ct->nColVal + 1));
+  }
-  memcpy(ct->colVal, term->colVal, ct->nColVal);
+  ct->colVal = calloc(1, sizeof(char) * (term->nColVal + 1));
+  memcpy(ct->colVal, term->colVal, term->nColVal);
   ct->version = atomic_load_32(&pCache->version);
 
   char* key = getIndexKey(ct);
   // TODO handle multi situation later, and refactor
-  SSkipListIterator* iter = tSkipListCreateIterFromVal(pCache->mem, key, TSDB_DATA_TYPE_BINARY, TSDB_ORDER_ASC);
+  SSkipListIterator* iter = tSkipListCreateIterFromVal(mem->mem, key, TSDB_DATA_TYPE_BINARY, TSDB_ORDER_ASC);
   while (tSkipListIterNext(iter)) {
     SSkipListNode* node = tSkipListIterGet(iter);
     if (node != NULL) {
       CacheTerm* c = (CacheTerm*)SL_GET_NODE_DATA(node);
       if (c->operaType == ADD_VALUE || qtype == QUERY_TERM) {
-        if (c->nColVal == ct->nColVal && strncmp(c->colVal, ct->colVal, c->nColVal) == 0) {
+        if (strcmp(c->colVal, ct->colVal) == 0) {
           taosArrayPush(result, &c->uid);
           *s = kTypeValue;
         } else {
@@ -279,14 +263,104 @@ int indexCacheSearch(void* cache, SIndexTermQuery* query, SArray* result, STermV
   } else if (qtype == QUERY_REGEX) {
     //
   }
+  indexMemUnRef(mem);
+  indexMemUnRef(imm);
   return 0;
 }
 
 void indexCacheRef(IndexCache* cache) {
+  if (cache == NULL) {
+    return;
+  }
   int ref = T_REF_INC(cache);
   UNUSED(ref);
 }
 void indexCacheUnRef(IndexCache* cache) {
+  if (cache == NULL) {
+    return;
+  }
   int ref = T_REF_DEC(cache);
-  if (ref == 0) { indexCacheDestroy(cache); }
+  if (ref == 0) {
+    indexCacheDestroy(cache);
+  }
 }
+
+void indexMemRef(MemTable* tbl) {
+  if (tbl == NULL) {
+    return;
+  }
+  int ref = T_REF_INC(tbl);
+  UNUSED(ref);
+}
+void indexMemUnRef(MemTable* tbl) {
+  if (tbl == NULL) {
+    return;
+  }
+  int ref = T_REF_DEC(tbl);
+  if (ref == 0) {
+    SSkipList* slt = tbl->mem;
+    indexCacheDestroySkiplist(slt);
+    free(tbl);
+  }
+}
+
+static void cacheTermDestroy(CacheTerm* ct) {
+  if (ct == NULL) {
+    return;
+  }
+  free(ct->colVal);
+  free(ct);
+}
+static char* getIndexKey(const void* pData) {
+  CacheTerm* p = (CacheTerm*)pData;
+  return (char*)p;
+}
+
+static int32_t compareKey(const void* l, const void* r) {
+  CacheTerm* lt = (CacheTerm*)l;
+  CacheTerm* rt = (CacheTerm*)r;
+
+  // compare colVal
+  int32_t cmp = strcmp(lt->colVal, rt->colVal);
+  if (cmp == 0) {
+    return rt->version - lt->version;
+  }
+  return cmp;
+}
+
+static MemTable* indexInternalCacheCreate(int8_t type) {
+  MemTable* tbl = calloc(1, sizeof(MemTable));
+  indexMemRef(tbl);
+  if (type == TSDB_DATA_TYPE_BINARY) {
+    tbl->mem = tSkipListCreate(MAX_SKIP_LIST_LEVEL, type, MAX_INDEX_KEY_LEN, compareKey, SL_ALLOW_DUP_KEY, getIndexKey);
+  }
+  return tbl;
+}
+
+static void doMergeWork(SSchedMsg* msg) {
+  IndexCache* pCache = msg->ahandle;
+  SIndex*     sidx = (SIndex*)pCache->index;
+  indexFlushCacheTFile(sidx, pCache);
+}
+static bool indexCacheIteratorNext(Iterate* itera) {
+  SSkipListIterator* iter = itera->iter;
+  if (iter == NULL) {
+    return false;
+  }
+  IterateValue* iv = &itera->val;
+  iterateValueDestroy(iv, false);
+
+  bool next = tSkipListIterNext(iter);
+  if (next) {
+    SSkipListNode* node = tSkipListIterGet(iter);
+    CacheTerm*     ct = (CacheTerm*)SL_GET_NODE_DATA(node);
+
+    iv->type = ct->operaType;
+    iv->colVal = ct->colVal;
+
+    taosArrayPush(iv->val, &ct->uid);
+  }
+  return next;
+}
+
+static IterateValue* indexCacheIteratorGetValue(Iterate* iter) { return &iter->val; }

source/libs/index/src/index_tfile.c

@@ -54,7 +54,9 @@ static void tfileSerialCacheKey(TFileCacheKey* key, char* buf);
 
 TFileCache* tfileCacheCreate(const char* path) {
   TFileCache* tcache = calloc(1, sizeof(TFileCache));
-  if (tcache == NULL) { return NULL; }
+  if (tcache == NULL) {
+    return NULL;
+  }
 
   tcache->tableCache = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   tcache->capacity = 64;
@@ -83,7 +85,10 @@ TFileCache* tfileCacheCreate(const char* path) {
     tfileReaderRef(reader);
     // loader fst and validate it
     TFileHeader*  header = &reader->header;
-    TFileCacheKey key = {.suid = header->suid, .colName = header->colName, .nColName = strlen(header->colName), .colType = header->colType};
+    TFileCacheKey key = {.suid = header->suid,
+                         .colName = header->colName,
+                         .nColName = strlen(header->colName),
+                         .colType = header->colType};
 
     char buf[128] = {0};
     tfileSerialCacheKey(&key, buf);
@@ -97,13 +102,16 @@ End:
   return NULL;
 }
 void tfileCacheDestroy(TFileCache* tcache) {
-  if (tcache == NULL) { return; }
+  if (tcache == NULL) {
+    return;
+  }
 
   // free table cache
   TFileReader** reader = taosHashIterate(tcache->tableCache, NULL);
   while (reader) {
     TFileReader* p = *reader;
-    indexInfo("drop table cache suid: %" PRIu64 ", colName: %s, colType: %d", p->header.suid, p->header.colName, p->header.colType);
+    indexInfo("drop table cache suid: %" PRIu64 ", colName: %s, colType: %d", p->header.suid, p->header.colName,
+              p->header.colType);
 
     tfileReaderUnRef(p);
     reader = taosHashIterate(tcache->tableCache, reader);
@@ -116,10 +124,13 @@ TFileReader* tfileCacheGet(TFileCache* tcache, TFileCacheKey* key) {
   char buf[128] = {0};
   tfileSerialCacheKey(key, buf);
 
-  TFileReader* reader = taosHashGet(tcache->tableCache, buf, strlen(buf));
+  TFileReader** reader = taosHashGet(tcache->tableCache, buf, strlen(buf));
-  tfileReaderRef(reader);
+  if (reader == NULL) {
+    return NULL;
+  }
+  tfileReaderRef(*reader);
 
-  return reader;
+  return *reader;
 }
 void tfileCachePut(TFileCache* tcache, TFileCacheKey* key, TFileReader* reader) {
   char buf[128] = {0};
@@ -138,14 +149,17 @@ void tfileCachePut(TFileCache* tcache, TFileCacheKey* key, TFileReader* reader)
 }
 TFileReader* tfileReaderCreate(WriterCtx* ctx) {
   TFileReader* reader = calloc(1, sizeof(TFileReader));
-  if (reader == NULL) { return NULL; }
+  if (reader == NULL) {
+    return NULL;
+  }
 
   // T_REF_INC(reader);
   reader->ctx = ctx;
 
   if (0 != tfileReaderLoadHeader(reader)) {
     tfileReaderDestroy(reader);
-    indexError("failed to load index header, suid: %" PRIu64 ", colName: %s", reader->header.suid, reader->header.colName);
+    indexError("failed to load index header, suid: %" PRIu64 ", colName: %s", reader->header.suid,
+               reader->header.colName);
     return NULL;
   }
 
@@ -158,7 +172,9 @@ TFileReader* tfileReaderCreate(WriterCtx* ctx) {
   return reader;
 }
 void tfileReaderDestroy(TFileReader* reader) {
-  if (reader == NULL) { return; }
+  if (reader == NULL) {
+    return;
+  }
   // T_REF_INC(reader);
   fstDestroy(reader->fst);
   writerCtxDestroy(reader->ctx);
@@ -175,10 +191,12 @@ int tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArray* resul
     uint64_t offset;
     FstSlice key = fstSliceCreate(term->colVal, term->nColVal);
     if (fstGet(reader->fst, &key, &offset)) {
-      indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, found table info in tindex", term->suid, term->colName, term->colVal);
+      indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, found table info in tindex", term->suid, term->colName,
+                term->colVal);
       ret = tfileReaderLoadTableIds(reader, offset, result);
     } else {
-      indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, not found table info in tindex", term->suid, term->colName, term->colVal);
+      indexInfo("index: %" PRIu64 ", col: %s, colVal: %s, not found table info in tindex", term->suid, term->colName,
+                term->colVal);
     }
     fstSliceDestroy(&key);
   } else if (qtype == QUERY_PREFIX) {
@@ -304,12 +322,16 @@ int tfileWriterPut(TFileWriter* tw, void* data) {
   return 0;
 }
 void tfileWriteClose(TFileWriter* tw) {
-  if (tw == NULL) { return; }
+  if (tw == NULL) {
+    return;
+  }
   writerCtxDestroy(tw->ctx);
   free(tw);
 }
 void tfileWriterDestroy(TFileWriter* tw) {
-  if (tw == NULL) { return; }
+  if (tw == NULL) {
+    return;
+  }
 
   writerCtxDestroy(tw->ctx);
   free(tw);
@@ -317,29 +339,35 @@ void tfileWriterDestroy(TFileWriter* tw) {
 
 IndexTFile* indexTFileCreate(const char* path) {
   IndexTFile* tfile = calloc(1, sizeof(IndexTFile));
-  if (tfile == NULL) { return NULL; }
+  if (tfile == NULL) {
+    return NULL;
+  }
 
   tfile->cache = tfileCacheCreate(path);
   return tfile;
 }
-void IndexTFileDestroy(IndexTFile* tfile) {
+void IndexTFileDestroy(IndexTFile* tfile) { free(tfile); }
-  free(tfile);
-}
 
 int indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result) {
   int ret = -1;
-  if (tfile == NULL) { return ret; }
+  if (tfile == NULL) {
+    return ret;
+  }
   IndexTFile* pTfile = (IndexTFile*)tfile;
 
   SIndexTerm*   term = query->term;
-  TFileCacheKey key = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName};
+  TFileCacheKey key = {
-  TFileReader*  reader = tfileCacheGet(pTfile->cache, &key);
+      .suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName};
+  TFileReader* reader = tfileCacheGet(pTfile->cache, &key);
+  if (reader == NULL) {
+    return 0;
+  }
 
   return tfileReaderSearch(reader, query, result);
 }
 int indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) {
-  // TFileWriterOpt wOpt = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName, .version =
+  // TFileWriterOpt wOpt = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName =
-  // 1};
+  // term->nColName, .version = 1};
 
   return 0;
 }
@@ -353,7 +381,9 @@ static bool tfileIteratorNext(Iterate* iiter) {
 
   TFileFstIter*          tIter = iiter->iter;
   StreamWithStateResult* rt = streamWithStateNextWith(tIter->st, NULL);
-  if (rt == NULL) { return false; }
+  if (rt == NULL) {
+    return false;
+  }
 
   int32_t sz = 0;
   char*   ch = (char*)fstSliceData(&rt->data, &sz);
@@ -364,20 +394,22 @@ static bool tfileIteratorNext(Iterate* iiter) {
 
   swsResultDestroy(rt);
   // set up iterate value
-  if (tfileReaderLoadTableIds(tIter->rdr, offset, iv->val) != 0) { return false; }
+  if (tfileReaderLoadTableIds(tIter->rdr, offset, iv->val) != 0) {
+    return false;
+  }
 
   iv->colVal = colVal;
 
   // std::string key(ch, sz);
 }
 
-static IterateValue* tifileIterateGetValue(Iterate* iter) {
+static IterateValue* tifileIterateGetValue(Iterate* iter) { return &iter->val; }
-  return &iter->val;
-}
 
 static TFileFstIter* tfileFstIteratorCreate(TFileReader* reader) {
   TFileFstIter* tIter = calloc(1, sizeof(Iterate));
-  if (tIter == NULL) { return NULL; }
+  if (tIter == NULL) {
+    return NULL;
+  }
   tIter->ctx = automCtxCreate(NULL, AUTOMATION_ALWAYS);
   tIter->fb = fstSearch(reader->fst, tIter->ctx);
   tIter->st = streamBuilderIntoStream(tIter->fb);
@@ -389,14 +421,18 @@ Iterate* tfileIteratorCreate(TFileReader* reader) {
   Iterate* iter = calloc(1, sizeof(Iterate));
 
   iter->iter = tfileFstIteratorCreate(reader);
-  if (iter->iter == NULL) { return NULL; }
+  if (iter->iter == NULL) {
+    return NULL;
+  }
 
   iter->next = tfileIteratorNext;
   iter->getValue = tifileIterateGetValue;
   return iter;
 }
 void tfileIteratorDestroy(Iterate* iter) {
-  if (iter == NULL) { return; }
+  if (iter == NULL) {
+    return;
+  }
   IterateValue* iv = &iter->val;
   iterateValueDestroy(iv, true);
 
@@ -409,14 +445,18 @@ void tfileIteratorDestroy(Iterate* iter) {
 }
 
 TFileReader* tfileGetReaderByCol(IndexTFile* tf, char* colName) {
-  if (tf == NULL) { return NULL; }
+  if (tf == NULL) {
+    return NULL;
+  }
   TFileCacheKey key = {.suid = 0, .colType = TSDB_DATA_TYPE_BINARY, .colName = colName, .nColName = strlen(colName)};
   return tfileCacheGet(tf->cache, &key);
 }
 
 static int tfileStrCompare(const void* a, const void* b) {
   int ret = strcmp((char*)a, (char*)b);
-  if (ret == 0) { return ret; }
+  if (ret == 0) {
+    return ret;
+  }
   return ret < 0 ? -1 : 1;
 }
 
@@ -431,13 +471,17 @@ static int tfileValueCompare(const void* a, const void* b, const void* param) {
 
 TFileValue* tfileValueCreate(char* val) {
   TFileValue* tf = calloc(1, sizeof(TFileValue));
-  if (tf == NULL) { return NULL; }
+  if (tf == NULL) {
+    return NULL;
+  }
 
   tf->tableId = taosArrayInit(32, sizeof(uint64_t));
   return tf;
 }
 int tfileValuePush(TFileValue* tf, uint64_t val) {
-  if (tf == NULL) { return -1; }
+  if (tf == NULL) {
+    return -1;
+  }
   taosArrayPush(tf->tableId, &val);
   return 0;
 }
@@ -457,7 +501,9 @@ static void tfileSerialTableIdsToBuf(char* buf, SArray* ids) {
 static int tfileWriteFstOffset(TFileWriter* tw, int32_t offset) {
   int32_t fstOffset = offset + sizeof(tw->header.fstOffset);
   tw->header.fstOffset = fstOffset;
-  if (sizeof(fstOffset) != tw->ctx->write(tw->ctx, (char*)&fstOffset, sizeof(fstOffset))) { return -1; }
+  if (sizeof(fstOffset) != tw->ctx->write(tw->ctx, (char*)&fstOffset, sizeof(fstOffset))) {
+    return -1;
+  }
   tw->offset += sizeof(fstOffset);
   return 0;
 }
@@ -468,7 +514,9 @@ static int tfileWriteHeader(TFileWriter* writer) {
   memcpy(buf, (char*)header, sizeof(buf));
 
   int nwrite = writer->ctx->write(writer->ctx, buf, sizeof(buf));
-  if (sizeof(buf) != nwrite) { return -1; }
+  if (sizeof(buf) != nwrite) {
+    return -1;
+  }
   writer->offset = nwrite;
   return 0;
 }
@@ -502,7 +550,9 @@ static int tfileReaderLoadFst(TFileReader* reader) {
   static int FST_MAX_SIZE = 16 * 1024;
 
   char* buf = calloc(1, sizeof(char) * FST_MAX_SIZE);
-  if (buf == NULL) { return -1; }
+  if (buf == NULL) {
+    return -1;
+  }
 
   WriterCtx* ctx = reader->ctx;
   int32_t    nread = ctx->readFrom(ctx, buf, FST_MAX_SIZE, reader->header.fstOffset);
@@ -525,7 +575,9 @@ static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray*
 
   int32_t total = sizeof(uint64_t) * nid;
   char*   buf = calloc(1, total);
-  if (buf == NULL) { return -1; }
+  if (buf == NULL) {
+    return -1;
+  }
 
   nread = ctx->read(ctx, buf, total);
   assert(total == nread);
@@ -543,12 +595,16 @@ void tfileReaderRef(TFileReader* reader) {
 
 void tfileReaderUnRef(TFileReader* reader) {
   int ref = T_REF_DEC(reader);
-  if (ref == 0) { tfileReaderDestroy(reader); }
+  if (ref == 0) {
+    tfileReaderDestroy(reader);
+  }
 }
 
 static int tfileGetFileList(const char* path, SArray* result) {
   DIR* dir = opendir(path);
-  if (NULL == dir) { return -1; }
+  if (NULL == dir) {
+    return -1;
+  }
 
   struct dirent* entry;
   while ((entry = readdir(dir)) != NULL) {
@@ -576,7 +632,9 @@ static int tfileCompare(const void* a, const void* b) {
   size_t bLen = strlen(bName);
 
   int ret = strncmp(aName, bName, aLen > bLen ? aLen : bLen);
-  if (ret == 0) { return ret; }
+  if (ret == 0) {
+    return ret;
+  }
   return ret < 0 ? -1 : 1;
 }
 // tfile name suid-colId-version.tindex

source/libs/index/test/indexTests.cc

@@ -2,7 +2,8 @@
  * 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.
+ * 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
@@ -75,7 +76,9 @@ class FstReadMemory {
   bool init() {
     char* buf = (char*)calloc(1, sizeof(char) * _size);
     int   nRead = fstCountingWriterRead(_w, (uint8_t*)buf, _size);
-    if (nRead <= 0) { return false; }
+    if (nRead <= 0) {
+      return false;
+    }
     _size = nRead;
     _s = fstSliceCreate((uint8_t*)buf, _size);
     _fst = fstCreate(&_s);
@@ -179,7 +182,9 @@ void checkFstPerf() {
   delete fw;
 
   FstReadMemory* m = new FstReadMemory(1024 * 64);
-  if (m->init()) { printf("success to init fst read"); }
+  if (m->init()) {
+    printf("success to init fst read");
+  }
   Performance_fstReadRecords(m);
   delete m;
 }
@@ -283,7 +288,8 @@ class IndexEnv : public ::testing::Test {
 //      / {
 //    / std::string colName("tag1"), colVal("Hello world");
 //    / SIndexTerm* term =
-//        indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), / colVal.size());
+//        indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), /
+//        colVal.size());
 //    SIndexMultiTerm* terms = indexMultiTermCreate();
 //    indexMultiTermAdd(terms, term);
 //    / / for (size_t i = 0; i < 100; i++) {
@@ -301,14 +307,16 @@ class IndexEnv : public ::testing::Test {
 //    / {
 //      / std::string colName("tag1"), colVal("Hello world");
 //      / SIndexTerm* term =
-//          / indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+//          / indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(),
+//          colVal.size());
 //      / indexMultiTermAdd(terms, term);
 //      /
 //    }
 //    / {
 //      / std::string colName("tag2"), colVal("Hello world");
 //      / SIndexTerm* term =
-//          / indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+//          / indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(),
+//          colVal.size());
 //      / indexMultiTermAdd(terms, term);
 //      /
 //    }
@@ -327,7 +335,8 @@ class IndexEnv : public ::testing::Test {
 
 class TFileObj {
  public:
-  TFileObj(const std::string& path = "/tmp/tindex", const std::string& colName = "voltage") : path_(path), colName_(colName) {
+  TFileObj(const std::string& path = "/tmp/tindex", const std::string& colName = "voltage")
+      : path_(path), colName_(colName) {
     colId_ = 10;
     // Do Nothing
     //
@@ -337,7 +346,9 @@ class TFileObj {
       tfileReaderDestroy(reader_);
       reader_ = NULL;
     }
-    if (writer_ == NULL) { InitWriter(); }
+    if (writer_ == NULL) {
+      InitWriter();
+    }
     return tfileWriterPut(writer_, tv);
   }
   bool InitWriter() {
@@ -377,8 +388,12 @@ class TFileObj {
     return tfileReaderSearch(reader_, query, result);
   }
   ~TFileObj() {
-    if (writer_) { tfileWriterDestroy(writer_); }
+    if (writer_) {
-    if (reader_) { tfileReaderDestroy(reader_); }
+      tfileWriterDestroy(writer_);
+    }
+    if (reader_) {
+      tfileReaderDestroy(reader_);
+    }
   }
 
  private:
@@ -455,9 +470,10 @@ TEST_F(IndexTFileEnv, test_tfile_write) {
   }
   taosArrayDestroy(data);
 
-  std::string colName("voltage");
+  std::string     colName("voltage");
-  std::string colVal("ab");
+  std::string     colVal("ab");
-  SIndexTerm* term = indexTermCreate(1, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+  SIndexTerm*     term = indexTermCreate(1, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                     colVal.c_str(), colVal.size());
   SIndexTermQuery query = {.term = term, .qType = QUERY_TERM};
 
   SArray* result = (SArray*)taosArrayInit(1, sizeof(uint64_t));
@@ -525,54 +541,62 @@ TEST_F(IndexCacheEnv, cache_test) {
   std::string colName("voltage");
   {
     std::string colVal("v1");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
   }
   {
     std::string colVal("v3");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
   }
   {
     std::string colVal("v2");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
   }
   {
     std::string colVal("v3");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
   }
   {
     std::string colVal("v3");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     coj->Put(term, colId, version++, suid++);
   }
 
   {
     std::string colVal("v3");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     coj->Put(term, othColId, version++, suid++);
   }
   {
     std::string colVal("v4");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     coj->Put(term, othColId, version++, suid++);
   }
   {
     std::string colVal("v4");
     for (size_t i = 0; i < 10; i++) {
       colVal[colVal.size() - 1] = 'a' + i;
-      SIndexTerm* term =
+      SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
-          indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+                                         colVal.c_str(), colVal.size());
       coj->Put(term, colId, version++, suid++);
     }
   }
   coj->Debug();
   // begin query
   {
-    std::string colVal("v3");
+    std::string     colVal("v3");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm*     term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     SIndexTermQuery query = {.term = term, .qType = QUERY_TERM};
     SArray*         ret = (SArray*)taosArrayInit(4, sizeof(suid));
     STermValueType  valType;
@@ -582,8 +606,9 @@ TEST_F(IndexCacheEnv, cache_test) {
     assert(taosArrayGetSize(ret) == 4);
   }
   {
-    std::string colVal("v2");
+    std::string     colVal("v2");
-    SIndexTerm* term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(), colVal.c_str(), colVal.size());
+    SIndexTerm*     term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
     SIndexTermQuery query = {.term = term, .qType = QUERY_TERM};
     SArray*         ret = (SArray*)taosArrayInit(4, sizeof(suid));
     STermValueType  valType;
@@ -592,3 +617,132 @@ TEST_F(IndexCacheEnv, cache_test) {
     assert(taosArrayGetSize(ret) == 1);
   }
 }
+class IndexObj {
+ public:
+  IndexObj() {
+    // opt
+    numOfWrite = 0;
+    numOfRead = 0;
+    indexInit();
+  }
+  int Init(const std::string& dir) {
+    taosRemoveDir(dir.c_str());
+    taosMkDir(dir.c_str());
+    int ret = indexOpen(&opts, dir.c_str(), &idx);
+    if (ret != 0) {
+      // opt
+      std::cout << "failed to open index: %s" << dir << std::endl;
+    }
+    return ret;
+  }
+  int Put(SIndexMultiTerm* fvs, uint64_t uid) {
+    numOfWrite += taosArrayGetSize(fvs);
+    return indexPut(idx, fvs, uid);
+  }
+  int Search(SIndexMultiTermQuery* multiQ, SArray* result) {
+    SArray* query = multiQ->query;
+    numOfRead = taosArrayGetSize(query);
+    return indexSearch(idx, multiQ, result);
+  }
+
+  void Debug() {
+    std::cout << "numOfWrite:" << numOfWrite << std::endl;
+    std::cout << "numOfRead:" << numOfRead << std::endl;
+  }
+
+  ~IndexObj() {
+    indexClose(idx);
+    indexCleanUp();
+  }
+
+ private:
+  SIndexOpts opts;
+  SIndex*    idx;
+  int        numOfWrite;
+  int        numOfRead;
+};
+
+class IndexEnv2 : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    index = new IndexObj();
+    //
+  }
+  virtual void TearDown() {
+    // r
+    delete index;
+  }
+  IndexObj* index;
+};
+TEST_F(IndexEnv2, testIndexOpen) {
+  std::string path = "/tmp";
+  if (index->Init(path) != 0) {
+    std::cout << "failed to init index" << std::endl;
+    exit(1);
+  }
+
+  int targetSize = 100;
+  {
+    std::string colName("tag1"), colVal("Hello world");
+
+    SIndexTerm*      term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
+    SIndexMultiTerm* terms = indexMultiTermCreate();
+    indexMultiTermAdd(terms, term);
+    for (size_t i = 0; i < targetSize; i++) {
+      int tableId = i;
+      int ret = index->Put(terms, tableId);
+      assert(ret == 0);
+    }
+    indexMultiTermDestroy(terms);
+  }
+  {
+    size_t      size = 100;
+    std::string colName("tag1"), colVal("hello world");
+
+    SIndexTerm*      term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
+    SIndexMultiTerm* terms = indexMultiTermCreate();
+    indexMultiTermAdd(terms, term);
+    for (size_t i = 0; i < size; i++) {
+      int tableId = i;
+      int ret = index->Put(terms, tableId);
+      assert(ret == 0);
+    }
+    indexMultiTermDestroy(terms);
+  }
+
+  {
+    std::string colName("tag1"), colVal("Hello world");
+
+    SIndexMultiTermQuery* mq = indexMultiTermQueryCreate(MUST);
+    SIndexTerm*           term = indexTermCreate(0, ADD_VALUE, TSDB_DATA_TYPE_BINARY, colName.c_str(), colName.size(),
+                                       colVal.c_str(), colVal.size());
+    indexMultiTermQueryAdd(mq, term, QUERY_TERM);
+
+    SArray* result = (SArray*)taosArrayInit(1, sizeof(uint64_t));
+    index->Search(mq, result);
+    assert(taosArrayGetSize(result) == targetSize);
+  }
+}
+TEST_F(IndexEnv2, testIndex_CachePut) {
+  std::string path = "/tmp";
+  if (index->Init(path) != 0) {
+  }
+}
+
+TEST_F(IndexEnv2, testIndexr_TFilePut) {
+  std::string path = "/tmp";
+  if (index->Init(path) != 0) {
+  }
+}
+TEST_F(IndexEnv2, testIndex_CacheSearch) {
+  std::string path = "/tmp";
+  if (index->Init(path) != 0) {
+  }
+}
+TEST_F(IndexEnv2, testIndex_TFileSearch) {
+  std::string path = "/tmp";
+  if (index->Init(path) != 0) {
+  }
+}

source/libs/parser/inc/astGenerator.h

@@ -156,7 +156,7 @@ typedef struct SCreateDbInfo {
   SToken             dbname;
   int32_t            replica;
   int32_t            cacheBlockSize;
-  int32_t            maxTablesPerVnode;
+  int32_t            numOfVgroups;
   int32_t            numOfBlocks;
   int32_t            daysPerFile;
   int32_t            minRowsPerBlock;

source/libs/parser/inc/astToMsg.h

@@ -4,7 +4,6 @@
 #include "parserInt.h"
 #include "tmsg.h"
 
-int32_t createSName(SName* pName, SToken* pTableName, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf);
 
 SCreateUserMsg* buildUserManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);
 SCreateAcctMsg* buildAcctManipulationMsg(SSqlInfo* pInfo, int32_t* outputLen, int64_t id, char* msgBuf, int32_t msgLen);

source/libs/parser/inc/parserUtil.h

@@ -62,7 +62,7 @@ void cleanupTagCond(STagCond* pTagCond);
 void cleanupColumnCond(SArray** pCond);
 
 uint32_t convertRelationalOperator(SToken *pToken);
-int32_t    getExprFunctionId(SExprInfo *pExprInfo);
+int32_t  getExprFunctionId(SExprInfo *pExprInfo);
 
 STableMeta* tableMetaDup(const STableMeta* pTableMeta);
 
@@ -70,6 +70,19 @@ bool isDclSqlStatement(SSqlInfo* pSqlInfo);
 bool isDdlSqlStatement(SSqlInfo* pSqlInfo);
 bool isDqlSqlStatement(SSqlInfo* pSqlInfo);
 
+typedef struct SKvParam {
+  SKVRowBuilder *builder;
+  SSchema       *schema;
+  char           buf[TSDB_MAX_TAGS_LEN];
+} SKvParam;
+
+int32_t KvRowAppend(const void *value, int32_t len, void *param);
+
+typedef int32_t (*_row_append_fn_t)(const void *value, int32_t len, void *param);
+int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, _row_append_fn_t func, void* param, SMsgBuf* pMsgBuf);
+
+int32_t createSName(SName* pName, SToken* pTableName, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf);
+
 #ifdef __cplusplus
 }
 #endif

source/libs/parser/inc/sql.y

@@ -280,6 +280,7 @@ comp(Y)    ::= COMP INTEGER(X).               { Y = X; }
 prec(Y)    ::= PRECISION STRING(X).           { Y = X; }
 update(Y)  ::= UPDATE INTEGER(X).             { Y = X; }     
 cachelast(Y) ::= CACHELAST INTEGER(X).        { Y = X; }
+vgroups(Y) ::= VGROUPS INTEGER(X).            { Y = X; }
 //partitions(Y) ::= PARTITIONS INTEGER(X).      { Y = X; }
 
 %type db_optr {SCreateDbInfo}
@@ -300,6 +301,7 @@ db_optr(Y) ::= db_optr(Z) prec(X).           { Y = Z; Y.precision = X; }
 db_optr(Y) ::= db_optr(Z) keep(X).           { Y = Z; Y.keep = X; }
 db_optr(Y) ::= db_optr(Z) update(X).         { Y = Z; Y.update = strtol(X.z, NULL, 10); }
 db_optr(Y) ::= db_optr(Z) cachelast(X).      { Y = Z; Y.cachelast = strtol(X.z, NULL, 10); }
+db_optr(Y) ::= db_optr(Z) vgroups(X).        { Y = Z; Y.numOfVgroups = strtol(X.z, NULL, 10); }
 
 //%type topic_optr {SCreateDbInfo}
 //

source/libs/parser/src/astGenerator.c

@@ -13,11 +13,12 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "astGenerator.h"
-#include <parserInt.h>
 #include "os.h"
 #include "taos.h"
+#include "tmsg.h"
+#include "parserInt.h"
 #include "tmsgtype.h"
+#include "astGenerator.h"
 
 SArray *tListItemAppend(SArray *pList, SVariant *pVar, uint8_t sortOrder) {
   if (pList == NULL) {
@@ -947,25 +948,21 @@ void setCompactVnodeSql(SSqlInfo *pInfo, int32_t type, SArray *pParam) {
 }
 
 void setDefaultCreateDbOption(SCreateDbInfo *pDBInfo) {
-  pDBInfo->compressionLevel = -1;
+  pDBInfo->compressionLevel= -1;
-
+  pDBInfo->walLevel        = -1;
-  pDBInfo->walLevel    = -1;
+  pDBInfo->fsyncPeriod     = -1;
-  pDBInfo->fsyncPeriod = -1;
+  pDBInfo->commitTime      = -1;
-  pDBInfo->commitTime  = -1;
+  pDBInfo->numOfVgroups    = 2;
-  pDBInfo->maxTablesPerVnode = -1;
-
   pDBInfo->cacheBlockSize  = -1;
   pDBInfo->numOfBlocks     = -1;
   pDBInfo->maxRowsPerBlock = -1;
   pDBInfo->minRowsPerBlock = -1;
   pDBInfo->daysPerFile     = -1;
-
+  pDBInfo->replica         = -1;
-  pDBInfo->replica = -1;
+  pDBInfo->quorum          = -1;
-  pDBInfo->quorum  = -1;
+  pDBInfo->keep            = NULL;
-  pDBInfo->keep    = NULL;
+  pDBInfo->update          = -1;
-
+  pDBInfo->cachelast       = -1;
-  pDBInfo->update  = -1;
-  pDBInfo->cachelast = -1;
 
   memset(&pDBInfo->precision, 0, sizeof(SToken));
 }

source/libs/parser/src/astToMsg.c

@@ -182,19 +182,20 @@ static int32_t setTimePrecision(SCreateDbMsg* pMsg, const SCreateDbInfo* pCreate
 
 static void doSetDbOptions(SCreateDbMsg* pMsg, const SCreateDbInfo* pCreateDb) {
   pMsg->cacheBlockSize = htonl(pCreateDb->cacheBlockSize);
-  pMsg->totalBlocks  = htonl(pCreateDb->numOfBlocks);
+  pMsg->totalBlocks    = htonl(pCreateDb->numOfBlocks);
-  pMsg->daysPerFile  = htonl(pCreateDb->daysPerFile);
+  pMsg->daysPerFile    = htonl(pCreateDb->daysPerFile);
-  pMsg->commitTime   = htonl((int32_t)pCreateDb->commitTime);
+  pMsg->commitTime     = htonl((int32_t)pCreateDb->commitTime);
-  pMsg->minRows = htonl(pCreateDb->minRowsPerBlock);
+  pMsg->minRows        = htonl(pCreateDb->minRowsPerBlock);
-  pMsg->maxRows = htonl(pCreateDb->maxRowsPerBlock);
+  pMsg->maxRows        = htonl(pCreateDb->maxRowsPerBlock);
-  pMsg->fsyncPeriod  = htonl(pCreateDb->fsyncPeriod);
+  pMsg->fsyncPeriod    = htonl(pCreateDb->fsyncPeriod);
-  pMsg->compression  = pCreateDb->compressionLevel;
+  pMsg->compression    = (int8_t) pCreateDb->compressionLevel;
-  pMsg->walLevel     = (char)pCreateDb->walLevel;
+  pMsg->walLevel       = (char)pCreateDb->walLevel;
-  pMsg->replications = pCreateDb->replica;
+  pMsg->replications   = pCreateDb->replica;
-  pMsg->quorum       = pCreateDb->quorum;
+  pMsg->quorum         = pCreateDb->quorum;
-  pMsg->ignoreExist  = pCreateDb->ignoreExists;
+  pMsg->ignoreExist    = pCreateDb->ignoreExists;
-  pMsg->update       = pCreateDb->update;
+  pMsg->update         = pCreateDb->update;
-  pMsg->cacheLastRow = pCreateDb->cachelast;
+  pMsg->cacheLastRow   = pCreateDb->cachelast;
+  pMsg->numOfVgroups   = htonl(pCreateDb->numOfVgroups);
 }
 
 int32_t setDbOptions(SCreateDbMsg* pCreateDbMsg, const SCreateDbInfo* pCreateDbSql, SMsgBuf* pMsgBuf) {
@@ -208,8 +209,6 @@ int32_t setDbOptions(SCreateDbMsg* pCreateDbMsg, const SCreateDbInfo* pCreateDbS
     return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
-  // todo configurable
-  pCreateDbMsg->numOfVgroups = htonl(2);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -233,45 +232,6 @@ SCreateDbMsg* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseBasicCtx *pCt
   return pCreateMsg;
 }
 
-int32_t createSName(SName* pName, SToken* pTableName, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
-  const char* msg1 = "name too long";
-  const char* msg2 = "acctId too long";
-
-  int32_t  code = TSDB_CODE_SUCCESS;
-  char* p  = strnchr(pTableName->z, TS_PATH_DELIMITER[0], pTableName->n, false);
-
-  if (p != NULL) { // db has been specified in sql string so we ignore current db path
-    code = tNameSetAcctId(pName, pParseCtx->acctId);
-    if (code != 0) {
-      return buildInvalidOperationMsg(pMsgBuf, msg2);
-    }
-
-    char name[TSDB_TABLE_FNAME_LEN] = {0};
-    strncpy(name, pTableName->z, pTableName->n);
-
-    code = tNameFromString(pName, name, T_NAME_DB|T_NAME_TABLE);
-    if (code != 0) {
-      return buildInvalidOperationMsg(pMsgBuf, msg1);
-    }
-  } else {  // get current DB name first, and then set it into path
-    if (pTableName->n >= TSDB_TABLE_NAME_LEN) {
-      return buildInvalidOperationMsg(pMsgBuf, msg1);
-    }
-
-    tNameSetDbName(pName, pParseCtx->acctId, pParseCtx->db, strlen(pParseCtx->db));
-
-    char name[TSDB_TABLE_FNAME_LEN] = {0};
-    strncpy(name, pTableName->z, pTableName->n);
-
-    code = tNameFromString(pName, name, T_NAME_TABLE);
-    if (code != 0) {
-      code = buildInvalidOperationMsg(pMsgBuf, msg1);
-    }
-  }
-
-  return code;
-}
-
 SCreateStbMsg* buildCreateTableMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
   SSchema* pSchema;
 

source/libs/parser/src/dCDAstProcess.c

@@ -17,7 +17,8 @@ static bool has(SArray* pFieldList, int32_t startIndex, const char* name) {
   return false;
 }
 
-static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx *pCtx, void** output, int32_t* outputLen, SMsgBuf* pMsgBuf) {
+static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx* pCtx, void** output, int32_t* outputLen,
+                           SMsgBuf* pMsgBuf) {
   const char* msg1 = "invalid name";
   const char* msg2 = "wildcard string should be less than %d characters";
   const char* msg3 = "database name too long";
@@ -29,7 +30,7 @@ static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx *pCtx, void** ou
    * database prefix in pInfo->pMiscInfo->a[0]
    * wildcard in like clause in pInfo->pMiscInfo->a[1]
    */
-  int16_t    showType = pShowInfo->showType;
+  int16_t showType = pShowInfo->showType;
   if (showType == TSDB_MGMT_TABLE_STB || showType == TSDB_MGMT_TABLE_VGROUP) {
     SToken* pDbPrefixToken = &pShowInfo->prefix;
     if (pDbPrefixToken->type != 0) {
@@ -80,7 +81,7 @@ static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx *pCtx, void** ou
   }
 
   *output = buildShowMsg(pShowInfo, pCtx, pMsgBuf->buf, pMsgBuf->len);
-  *outputLen = sizeof(SShowMsg)/* + htons(pShowMsg->payloadLen)*/;
+  *outputLen = sizeof(SShowMsg) /* + htons(pShowMsg->payloadLen)*/;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -116,8 +117,8 @@ static int32_t doCheckDbOptions(SCreateDbMsg* pCreate, SMsgBuf* pMsgBuf) {
 
   int32_t val = htonl(pCreate->daysPerFile);
   if (val != -1 && (val < TSDB_MIN_DAYS_PER_FILE || val > TSDB_MAX_DAYS_PER_FILE)) {
-    snprintf(msg, tListLen(msg), "invalid db option daysPerFile: %d valid range: [%d, %d]", val,
+    snprintf(msg, tListLen(msg), "invalid db option daysPerFile: %d valid range: [%d, %d]", val, TSDB_MIN_DAYS_PER_FILE,
-             TSDB_MIN_DAYS_PER_FILE, TSDB_MAX_DAYS_PER_FILE);
+             TSDB_MAX_DAYS_PER_FILE);
     return buildInvalidOperationMsg(pMsgBuf, msg);
   }
 
@@ -137,15 +138,15 @@ static int32_t doCheckDbOptions(SCreateDbMsg* pCreate, SMsgBuf* pMsgBuf) {
 
   val = htonl(pCreate->commitTime);
   if (val != -1 && (val < TSDB_MIN_COMMIT_TIME || val > TSDB_MAX_COMMIT_TIME)) {
-    snprintf(msg, tListLen(msg), "invalid db option commitTime: %d valid range: [%d, %d]", val,
+    snprintf(msg, tListLen(msg), "invalid db option commitTime: %d valid range: [%d, %d]", val, TSDB_MIN_COMMIT_TIME,
-             TSDB_MIN_COMMIT_TIME, TSDB_MAX_COMMIT_TIME);
+             TSDB_MAX_COMMIT_TIME);
     return buildInvalidOperationMsg(pMsgBuf, msg);
   }
 
   val = htonl(pCreate->fsyncPeriod);
   if (val != -1 && (val < TSDB_MIN_FSYNC_PERIOD || val > TSDB_MAX_FSYNC_PERIOD)) {
-    snprintf(msg, tListLen(msg), "invalid db option fsyncPeriod: %d valid range: [%d, %d]", val,
+    snprintf(msg, tListLen(msg), "invalid db option fsyncPeriod: %d valid range: [%d, %d]", val, TSDB_MIN_FSYNC_PERIOD,
-             TSDB_MIN_FSYNC_PERIOD, TSDB_MAX_FSYNC_PERIOD);
+             TSDB_MAX_FSYNC_PERIOD);
     return buildInvalidOperationMsg(pMsgBuf, msg);
   }
 
@@ -156,6 +157,12 @@ static int32_t doCheckDbOptions(SCreateDbMsg* pCreate, SMsgBuf* pMsgBuf) {
     return buildInvalidOperationMsg(pMsgBuf, msg);
   }
 
+  val = htonl(pCreate->numOfVgroups);
+  if (val < TSDB_MIN_VNODES_PER_DB || val > TSDB_MAX_VNODES_PER_DB) {
+    snprintf(msg, tListLen(msg), "invalid number of vgroups for DB:%d valid range: [%d, %d]", val,
+        TSDB_MIN_VNODES_PER_DB, TSDB_MAX_VNODES_PER_DB);
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -284,7 +291,8 @@ int32_t doCheckForCreateTable(SSqlInfo* pInfo, SMsgBuf* pMsgBuf) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* pMsgBuf, char** pOutput, int32_t* len, SEpSet* pEpSet) {
+int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SMsgBuf* pMsgBuf, char** pOutput, int32_t* len,
+                               SEpSet* pEpSet) {
   const char* msg1 = "invalid table name";
   const char* msg2 = "tags number not matched";
   const char* msg3 = "tag value too long";
@@ -293,13 +301,13 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
   SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
 
   // super table name, create table by using dst
-  int32_t numOfTables = (int32_t) taosArrayGetSize(pCreateTable->childTableInfo);
+  int32_t numOfTables = (int32_t)taosArrayGetSize(pCreateTable->childTableInfo);
-  for(int32_t j = 0; j < numOfTables; ++j) {
+  for (int32_t j = 0; j < numOfTables; ++j) {
     SCreatedTableInfo* pCreateTableInfo = taosArrayGet(pCreateTable->childTableInfo, j);
 
     SToken* pSTableNameToken = &pCreateTableInfo->stbName;
 
-    char buf[TSDB_TABLE_FNAME_LEN];
+    char   buf[TSDB_TABLE_FNAME_LEN];
     SToken sTblToken;
     sTblToken.z = buf;
 
@@ -314,22 +322,18 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
       return code;
     }
 
-    const char* pStableName = tNameGetTableName(&name);
     SArray* pValList = pCreateTableInfo->pTagVals;
 
     size_t      numOfInputTag = taosArrayGetSize(pValList);
     STableMeta* pSuperTableMeta = NULL;
 
-    char dbName[TSDB_DB_FNAME_LEN] = {0};
+    catalogGetTableMeta(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, &name, &pSuperTableMeta);
-    tNameGetFullDbName(&name, dbName);
-
-    catalogGetTableMeta(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, dbName, pStableName, &pSuperTableMeta);
     assert(pSuperTableMeta != NULL);
 
     // too long tag values will return invalid sql, not be truncated automatically
-    SSchema  *pTagSchema = getTableTagSchema(pSuperTableMeta);
+    SSchema*      pTagSchema = getTableTagSchema(pSuperTableMeta);
     STableComInfo tinfo = getTableInfo(pSuperTableMeta);
-    STagData *pTag = &pCreateTableInfo->tagdata;
+    STagData*     pTag = &pCreateTableInfo->tagdata;
 
     SKVRowBuilder kvRowBuilder = {0};
     if (tdInitKVRowBuilder(&kvRowBuilder) < 0) {
@@ -353,17 +357,17 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
       for (int32_t i = 0; i < nameSize; ++i) {
         SToken* sToken = taosArrayGet(pNameList, i);
 
-        char tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0}; // create tmp buf to avoid alter orginal sqlstr
+        char tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0};  // create tmp buf to avoid alter orginal sqlstr
         strncpy(tmpTokenBuf, sToken->z, sToken->n);
         sToken->z = tmpTokenBuf;
 
-//        if (TK_STRING == sToken->type) {
+        //        if (TK_STRING == sToken->type) {
-//          tscDequoteAndTrimToken(sToken);
+        //          tscDequoteAndTrimToken(sToken);
-//        }
+        //        }
 
-//        if (TK_ID == sToken->type) {
+        //        if (TK_ID == sToken->type) {
-//          tscRmEscapeAndTrimToken(sToken);
+        //          tscRmEscapeAndTrimToken(sToken);
-//        }
+        //        }
 
         SListItem* pItem = taosArrayGet(pValList, i);
 
@@ -372,7 +376,7 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
         // todo speedup by using hash list
         for (int32_t t = 0; t < schemaSize; ++t) {
           if (strncmp(sToken->z, pTagSchema[t].name, sToken->n) == 0 && strlen(pTagSchema[t].name) == sToken->n) {
-            SSchema*          pSchema = &pTagSchema[t];
+            SSchema* pSchema = &pTagSchema[t];
 
             char tagVal[TSDB_MAX_TAGS_LEN] = {0};
             if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
@@ -382,10 +386,10 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
               }
             } else if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP) {
               if (pItem->pVar.nType == TSDB_DATA_TYPE_BINARY) {
-//                code = convertTimestampStrToInt64(&(pItem->pVar), tinfo.precision);
+                //                code = convertTimestampStrToInt64(&(pItem->pVar), tinfo.precision);
-//                if (code != TSDB_CODE_SUCCESS) {
+                //                if (code != TSDB_CODE_SUCCESS) {
-//                  return buildInvalidOperationMsg(pMsgBuf, msg4);
+                //                  return buildInvalidOperationMsg(pMsgBuf, msg4);
-//                }
+                //                }
               } else if (pItem->pVar.nType == TSDB_DATA_TYPE_TIMESTAMP) {
                 pItem->pVar.i = convertTimePrecision(pItem->pVar.i, TSDB_TIME_PRECISION_NANO, tinfo.precision);
               }
@@ -416,7 +420,7 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
 
         if (!findColumnIndex) {
           tdDestroyKVRowBuilder(&kvRowBuilder);
-//          return buildInvalidOperationMsg(pMsgBuf, "invalid tag name", sToken->z);
+          //          return buildInvalidOperationMsg(pMsgBuf, "invalid tag name", sToken->z);
         }
       }
     } else {
@@ -426,46 +430,35 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
       }
 
       for (int32_t i = 0; i < numOfInputTag; ++i) {
-        SSchema   *pSchema = &pTagSchema[i];
+        SSchema* pSchema = &pTagSchema[i];
-        SToken* pItem = taosArrayGet(pValList, i);
+        SToken*  pItem = taosArrayGet(pValList, i);
 
-        char tagVal[TSDB_MAX_TAGS_LEN];
         if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
           if (pItem->n > pSchema->bytes) {
             tdDestroyKVRowBuilder(&kvRowBuilder);
             return buildInvalidOperationMsg(pMsgBuf, msg3);
           }
         } else if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP) {
-//          if (pItem->pVar.nType == TSDB_DATA_TYPE_BINARY) {
+          //          if (pItem->pVar.nType == TSDB_DATA_TYPE_BINARY) {
-////            code = convertTimestampStrToInt64(&(pItem->pVar), tinfo.precision);
+          ////            code = convertTimestampStrToInt64(&(pItem->pVar), tinfo.precision);
-//            if (code != TSDB_CODE_SUCCESS) {
+          //            if (code != TSDB_CODE_SUCCESS) {
-//              return buildInvalidOperationMsg(pMsgBuf, msg4);
+          //              return buildInvalidOperationMsg(pMsgBuf, msg4);
-//            }
+          //            }
-//          } else if (pItem->pVar.nType == TSDB_DATA_TYPE_TIMESTAMP) {
+          //          } else if (pItem->pVar.nType == TSDB_DATA_TYPE_TIMESTAMP) {
-//            pItem->pVar.i = convertTimePrecision(pItem->pVar.i, TSDB_TIME_PRECISION_NANO, tinfo.precision);
+          //            pItem->pVar.i = convertTimePrecision(pItem->pVar.i, TSDB_TIME_PRECISION_NANO, tinfo.precision);
-//          }
+          //          }
         }
 
+        char     tmpTokenBuf[TSDB_MAX_TAGS_LEN] = {0};
+        SKvParam param = {.builder = &kvRowBuilder, .schema = pSchema};
+
         char* endPtr = NULL;
-        int64_t v = strtoll(pItem->z, &endPtr, 10);
+        code = parseValueToken(&endPtr, pItem, pSchema, tinfo.precision, tmpTokenBuf, KvRowAppend, &param, pMsgBuf);
-        *(int32_t*) tagVal = v;
-//        code = taosVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
-
-        // check again after the convert since it may be converted from binary to nchar.
-        if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
-          int16_t len = varDataTLen(tagVal);
-          if (len > pSchema->bytes) {
-            tdDestroyKVRowBuilder(&kvRowBuilder);
-            return buildInvalidOperationMsg(pMsgBuf, msg3);
-          }
-        }
 
         if (code != TSDB_CODE_SUCCESS) {
           tdDestroyKVRowBuilder(&kvRowBuilder);
           return buildInvalidOperationMsg(pMsgBuf, msg4);
         }
-
-        tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
       }
     }
 
@@ -489,32 +482,36 @@ int32_t doCheckForCreateCTable(SSqlInfo* pInfo, SParseBasicCtx *pCtx, SMsgBuf* p
     req.ctbCfg.suid = pSuperTableMeta->suid;
     req.ctbCfg.pTag = row;
 
-    int32_t serLen = tSerializeSVCreateTbReq(NULL, &req);
+    int32_t serLen = sizeof(SMsgHead) + tSerializeSVCreateTbReq(NULL, &req);
-    char* buf1 = calloc(1, serLen);
+    char*   buf1 = calloc(1, serLen);
-    char* p = buf1;
+    *pOutput = buf1;
-    tSerializeSVCreateTbReq((void*) &buf1, &req);
+    buf1 += sizeof(SMsgHead);
-    *pOutput = p;
+    tSerializeSVCreateTbReq((void*)&buf1, &req);
     *len = serLen;
 
     SVgroupInfo info = {0};
-    catalogGetTableHashVgroup(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, dbName, req.name, &info);
+    catalogGetTableHashVgroup(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, &tableName, &info);
 
-    pEpSet->inUse    = info.inUse;
+    pEpSet->inUse = info.inUse;
     pEpSet->numOfEps = info.numOfEps;
-    for(int32_t i = 0; i < pEpSet->numOfEps; ++i) {
+    for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
       pEpSet->port[i] = info.epAddr[i].port;
       tstrncpy(pEpSet->fqdn[i], info.epAddr[i].fqdn, tListLen(pEpSet->fqdn[i]));
     }
+
+    ((SMsgHead*)(*pOutput))->vgId = htonl(info.vgId);
+    ((SMsgHead*)(*pOutput))->contLen = htonl(serLen);
   }
 
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStmtInfo* pDcl, char* msgBuf, int32_t msgBufLen) {
+int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStmtInfo* pDcl, char* msgBuf,
+                                  int32_t msgBufLen) {
   int32_t code = 0;
 
-  SMsgBuf m = {.buf = msgBuf, .len = msgBufLen};
+  SMsgBuf  m = {.buf = msgBuf, .len = msgBufLen};
-  SMsgBuf *pMsgBuf = &m;
+  SMsgBuf* pMsgBuf = &m;
 
   switch (pInfo->type) {
     case TSDB_SQL_CREATE_USER:
@@ -562,7 +559,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       }
 
       pDcl->pMsg = (char*)buildUserManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
-      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_USER)? TDMT_MND_CREATE_USER:TDMT_MND_ALTER_USER;
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_USER) ? TDMT_MND_CREATE_USER : TDMT_MND_ALTER_USER;
       break;
     }
 
@@ -599,14 +596,14 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
       }
 
       pDcl->pMsg = (char*)buildAcctManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
-      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_ACCT)? TDMT_MND_CREATE_ACCT:TDMT_MND_ALTER_ACCT;
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_ACCT) ? TDMT_MND_CREATE_ACCT : TDMT_MND_ALTER_ACCT;
       break;
     }
 
     case TSDB_SQL_DROP_ACCT:
     case TSDB_SQL_DROP_USER: {
       pDcl->pMsg = (char*)buildDropUserMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
-      pDcl->msgType = (pInfo->type == TSDB_SQL_DROP_ACCT)? TDMT_MND_DROP_ACCT:TDMT_MND_DROP_USER;
+      pDcl->msgType = (pInfo->type == TSDB_SQL_DROP_ACCT) ? TDMT_MND_DROP_ACCT : TDMT_MND_DROP_USER;
       break;
     }
 
@@ -624,13 +621,13 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
         return buildInvalidOperationMsg(pMsgBuf, msg);
       }
 
-      SName n = {0};
+      SName   n = {0};
       int32_t ret = tNameSetDbName(&n, pCtx->acctId, pToken->z, pToken->n);
       if (ret != TSDB_CODE_SUCCESS) {
         return buildInvalidOperationMsg(pMsgBuf, msg);
       }
 
-      SUseDbMsg *pUseDbMsg = (SUseDbMsg *) calloc(1, sizeof(SUseDbMsg));
+      SUseDbMsg* pUseDbMsg = (SUseDbMsg*)calloc(1, sizeof(SUseDbMsg));
       tNameExtractFullName(&n, pUseDbMsg->db);
 
       pDcl->pMsg = (char*)pUseDbMsg;
@@ -649,7 +646,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
         return buildInvalidOperationMsg(pMsgBuf, msg2);
       }
 
-      char buf[TSDB_DB_NAME_LEN] = {0};
+      char   buf[TSDB_DB_NAME_LEN] = {0};
       SToken token = taosTokenDup(&pCreateDB->dbname, buf, tListLen(buf));
 
       if (parserValidateNameToken(&token) != TSDB_CODE_SUCCESS) {
@@ -663,7 +660,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
       pDcl->pMsg = (char*)pCreateMsg;
       pDcl->msgLen = sizeof(SCreateDbMsg);
-      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_DB)? TDMT_MND_CREATE_DB:TDMT_MND_ALTER_DB;
+      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_DB) ? TDMT_MND_CREATE_DB : TDMT_MND_ALTER_DB;
       break;
     }
 
@@ -679,7 +676,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
         return buildInvalidOperationMsg(pMsgBuf, msg1);
       }
 
-      SDropDbMsg *pDropDbMsg = (SDropDbMsg*) calloc(1, sizeof(SDropDbMsg));
+      SDropDbMsg* pDropDbMsg = (SDropDbMsg*)calloc(1, sizeof(SDropDbMsg));
 
       code = tNameExtractFullName(&name, pDropDbMsg->db);
       pDropDbMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
@@ -699,9 +696,10 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
           return code;
         }
         pDcl->pMsg = (char*)buildCreateTableMsg(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf);
-        pDcl->msgType = (pCreateTable->type == TSQL_CREATE_TABLE)? TDMT_VND_CREATE_TABLE:TDMT_MND_CREATE_STB;
+        pDcl->msgType = (pCreateTable->type == TSQL_CREATE_TABLE) ? TDMT_VND_CREATE_TABLE : TDMT_MND_CREATE_STB;
-      }  else if (pCreateTable->type == TSQL_CREATE_CTABLE) {
+      } else if (pCreateTable->type == TSQL_CREATE_CTABLE) {
-        if ((code = doCheckForCreateCTable(pInfo, pCtx, pMsgBuf, &pDcl->pMsg, &pDcl->msgLen, &pDcl->epSet)) != TSDB_CODE_SUCCESS) {
+        if ((code = doCheckForCreateCTable(pInfo, pCtx, pMsgBuf, &pDcl->pMsg, &pDcl->msgLen, &pDcl->epSet)) !=
+            TSDB_CODE_SUCCESS) {
           return code;
         }
 
@@ -725,7 +723,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
     }
 
     case TSDB_SQL_CREATE_DNODE: {
-      pDcl->pMsg = (char*) buildCreateDnodeMsg(pInfo, &pDcl->msgLen, pMsgBuf);
+      pDcl->pMsg = (char*)buildCreateDnodeMsg(pInfo, &pDcl->msgLen, pMsgBuf);
       if (pDcl->pMsg == NULL) {
         code = terrno;
       }
@@ -735,7 +733,7 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
     }
 
     case TSDB_SQL_DROP_DNODE: {
-      pDcl->pMsg = (char*) buildDropDnodeMsg(pInfo, &pDcl->msgLen, pMsgBuf);
+      pDcl->pMsg = (char*)buildDropDnodeMsg(pInfo, &pDcl->msgLen, pMsgBuf);
       if (pDcl->pMsg == NULL) {
         code = terrno;
       }
@@ -750,4 +748,3 @@ int32_t qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, SDclStm
 
   return code;
 }
-

source/libs/parser/src/insertParser.c

@@ -51,8 +51,8 @@ enum {
 
 typedef struct SInsertParseContext {
   SParseContext* pComCxt;       // input
-  const char* pSql;             // input
+  char          *pSql;          // input
-  SMsgBuf msg;                  // input
+  SMsgBuf        msg;           // input
   STableMeta* pTableMeta;       // each table
   SParsedDataColInfo tags;      // each table
   SKVRowBuilder tagsBuilder;    // each table
@@ -64,22 +64,6 @@ typedef struct SInsertParseContext {
   SInsertStmtInfo* pOutput;
 } SInsertParseContext;
 
-typedef int32_t (*FRowAppend)(const void *value, int32_t len, void *param);
-
-typedef struct SKvParam {
-  char buf[TSDB_MAX_TAGS_LEN];
-  SKVRowBuilder* builder;
-  SSchema* schema;
-} SKvParam;
-
-static uint8_t TRUE_VALUE = (uint8_t)TSDB_TRUE;
-static uint8_t FALSE_VALUE = (uint8_t)TSDB_FALSE;
-
-static bool isNullStr(SToken *pToken) {
-  return (pToken->type == TK_NULL) || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
-                                       (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0));
-}
-
 static FORCE_INLINE int32_t toDouble(SToken *pToken, double *value, char **endPtr) {
   errno = 0;
   *value = strtold(pToken->z, endPtr);
@@ -170,12 +154,17 @@ static int32_t buildName(SInsertParseContext* pCxt, SToken* pStname, char* fullD
 }
 
 static int32_t getTableMeta(SInsertParseContext* pCxt, SToken* pTname) {
-  char fullDbName[TSDB_DB_FNAME_LEN] = {0};
+  SName name = {0};
-  char tableName[TSDB_TABLE_NAME_LEN] = {0};
+  createSName(&name, pTname, &pCxt->pComCxt->ctx, &pCxt->msg);
-  CHECK_CODE(buildName(pCxt, pTname, fullDbName, tableName));
+
-  CHECK_CODE(catalogGetTableMeta(pCxt->pComCxt->ctx.pCatalog, pCxt->pComCxt->ctx.pTransporter, &pCxt->pComCxt->ctx.mgmtEpSet, fullDbName, tableName, &pCxt->pTableMeta));
+  char tableName[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameExtractFullName(&name, tableName);
+
+  SParseBasicCtx* pBasicCtx = &pCxt->pComCxt->ctx;
+  CHECK_CODE(catalogGetTableMeta(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name, &pCxt->pTableMeta));
+
   SVgroupInfo vg;
-  CHECK_CODE(catalogGetTableHashVgroup(pCxt->pComCxt->ctx.pCatalog, pCxt->pComCxt->ctx.pTransporter, &pCxt->pComCxt->ctx.mgmtEpSet, fullDbName, tableName, &vg));
+  CHECK_CODE(catalogGetTableHashVgroup(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name, &vg));
   CHECK_CODE(taosHashPut(pCxt->pVgroupsHashObj, (const char*)&vg.vgId, sizeof(vg.vgId), (char*)&vg, sizeof(vg)));
   return TSDB_CODE_SUCCESS;
 }
@@ -263,23 +252,21 @@ static int32_t checkTimestamp(STableDataBlocks *pDataBlocks, const char *start)
   return TSDB_CODE_SUCCESS;
 }
 
-static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec, int64_t *time) {
+static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time, SMsgBuf* pMsgBuf) {
   int32_t   index = 0;
-  SToken sToken;
+  SToken    sToken;
   int64_t   interval;
-  int64_t   useconds = 0;
+  int64_t   ts = 0;
-  const char* pTokenEnd = pCxt->pSql;
+  char* pTokenEnd = *end;
 
   if (pToken->type == TK_NOW) {
-    useconds = taosGetTimestamp(timePrec);
+    ts = taosGetTimestamp(timePrec);
-  } else if (strncmp(pToken->z, "0", 1) == 0 && pToken->n == 1) {
-    // do nothing
   } else if (pToken->type == TK_INTEGER) {
-    useconds = taosStr2int64(pToken->z);
+    bool isSigned = false;
-  } else {
+    toInteger(pToken->z, pToken->n, 10, &ts, &isSigned);
-    // strptime("2001-11-12 18:31:01", "%Y-%m-%d %H:%M:%S", &tm);
+  } else { // parse the RFC-3339/ISO-8601 timestamp format string
     if (taosParseTime(pToken->z, time, pToken->n, timePrec, tsDaylight) != TSDB_CODE_SUCCESS) {
-      return buildSyntaxErrMsg(&pCxt->msg, "invalid timestamp format", pToken->z);
+      return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp format", pToken->z);
     }
 
     return TSDB_CODE_SUCCESS;
@@ -288,8 +275,8 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec
   for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
     if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
     if (pToken->z[k] == ',') {
-      pCxt->pSql = pTokenEnd;
+      *end = pTokenEnd;
-      *time = useconds;
+      *time = ts;
       return 0;
     }
 
@@ -311,7 +298,7 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec
     pTokenEnd += index;
 
     if (valueToken.n < 2) {
-      return buildSyntaxErrMsg(&pCxt->msg, "value expected in timestamp", sToken.z);
+      return buildSyntaxErrMsg(pMsgBuf, "value expected in timestamp", sToken.z);
     }
 
     char unit = 0;
@@ -320,34 +307,15 @@ static int parseTime(SInsertParseContext* pCxt, SToken *pToken, int16_t timePrec
     }
 
     if (sToken.type == TK_PLUS) {
-      useconds += interval;
+      ts += interval;
     } else {
-      useconds = useconds - interval;
+      ts = ts - interval;
     }
 
-    pCxt->pSql = pTokenEnd;
+    *end = pTokenEnd;
   }
 
-  *time = useconds;
+  *time = ts;
-  return TSDB_CODE_SUCCESS;
-}
-
-static FORCE_INLINE int32_t KvRowAppend(const void *value, int32_t len, void *param) {
-  SKvParam* pa = (SKvParam*)param;
-  if (TSDB_DATA_TYPE_BINARY == pa->schema->type) {
-    STR_WITH_SIZE_TO_VARSTR(pa->buf, value, len);
-    tdAddColToKVRow(pa->builder, pa->schema->colId, pa->schema->type, pa->buf);
-  } else if (TSDB_DATA_TYPE_NCHAR == pa->schema->type) {
-    // if the converted output len is over than pColumnModel->bytes, return error: 'Argument list too long'
-    int32_t output = 0;
-    if (!taosMbsToUcs4(value, len, varDataVal(pa->buf), pa->schema->bytes - VARSTR_HEADER_SIZE, &output)) {
-      return TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
-    }
-    varDataSetLen(pa->buf, output);
-    tdAddColToKVRow(pa->builder, pa->schema->colId, pa->schema->type, pa->buf);
-  } else {
-    tdAddColToKVRow(pa->builder, pa->schema->colId, pa->schema->type, value);
-  }
   return TSDB_CODE_SUCCESS;
 }
 
@@ -381,193 +349,206 @@ static FORCE_INLINE int32_t MemRowAppend(const void *value, int32_t len, void *p
   return TSDB_CODE_SUCCESS;
 }
 
-static FORCE_INLINE int32_t checkAndTrimValue(SInsertParseContext* pCxt, SToken* pToken, SSchema* pSchema, char* tmpTokenBuf) {
+//static FORCE_INLINE int32_t checkAndTrimValue(SToken* pToken, uint32_t type, char* tmpTokenBuf, SMsgBuf* pMsgBuf) {
-  int16_t type = pToken->type;
+//  if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL &&
-  if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL &&
+//       type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) ||
-        type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) ||
+//      (pToken->n == 0) || (type == TK_RP)) {
-      (pToken->n == 0) || (type == TK_RP)) {
+//    return buildSyntaxErrMsg(pMsgBuf, "invalid data or symbol", pToken->z);
-    return buildSyntaxErrMsg(&pCxt->msg, "invalid data or symbol", pToken->z);
+//  }
-  }
+//
+//  if (IS_NUMERIC_TYPE(type) && pToken->n == 0) {
+//    return buildSyntaxErrMsg(pMsgBuf, "invalid numeric data", pToken->z);
+//  }
+//
+//  // Remove quotation marks
+//  if (TK_STRING == type) {
+//    if (pToken->n >= TSDB_MAX_BYTES_PER_ROW) {
+//      return buildSyntaxErrMsg(pMsgBuf, "too long string", pToken->z);
+//    }
+//
+//    // delete escape character: \\, \', \"
+//    char delim = pToken->z[0];
+//    int32_t cnt = 0;
+//    int32_t j = 0;
+//    for (uint32_t k = 1; k < pToken->n - 1; ++k) {
+//      if (pToken->z[k] == '\\' || (pToken->z[k] == delim && pToken->z[k + 1] == delim)) {
+//        tmpTokenBuf[j] = pToken->z[k + 1];
+//        cnt++;
+//        j++;
+//        k++;
+//        continue;
+//      }
+//      tmpTokenBuf[j] = pToken->z[k];
+//      j++;
+//    }
+//
+//    tmpTokenBuf[j] = 0;
+//    pToken->z = tmpTokenBuf;
+//    pToken->n -= 2 + cnt;
+//  }
+//
+//  return TSDB_CODE_SUCCESS;
+//}
 
-  if (IS_NUMERIC_TYPE(pSchema->type) && pToken->n == 0) {
+//static FORCE_INLINE int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, _row_append_fn_t func, void* param, SMsgBuf* pMsgBuf) {
-    return buildSyntaxErrMsg(&pCxt->msg, "invalid numeric data", pToken->z);
+//  int64_t iv;
-  }
+//  char   *endptr = NULL;
-
+//  bool    isSigned = false;
-  // Remove quotation marks
+//
-  if (TK_STRING == type) {
+//  CHECK_CODE(checkAndTrimValue(pToken, pSchema->type, tmpTokenBuf, pMsgBuf));
-    if (pToken->n >= TSDB_MAX_BYTES_PER_ROW) {
+//
-      return buildSyntaxErrMsg(&pCxt->msg, "too long string", pToken->z);
+//  if (isNullStr(pToken)) {
-    }
+//    if (TSDB_DATA_TYPE_TIMESTAMP == pSchema->type && PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) {
-    // delete escape character: \\, \', \"
+//      int64_t tmpVal = 0;
-    char delim = pToken->z[0];
+//      return func(&tmpVal, pSchema->bytes, param);
-    int32_t cnt = 0;
+//    }
-    int32_t j = 0;
+//
-    for (uint32_t k = 1; k < pToken->n - 1; ++k) {
+//    return func(getNullValue(pSchema->type), 0, param);
-      if (pToken->z[k] == '\\' || (pToken->z[k] == delim && pToken->z[k + 1] == delim)) {
+//  }
-        tmpTokenBuf[j] = pToken->z[k + 1];
+//
-        cnt++;
+//  switch (pSchema->type) {
-        j++;
+//    case TSDB_DATA_TYPE_BOOL: {
-        k++;
+//      if ((pToken->type == TK_BOOL || pToken->type == TK_STRING) && (pToken->n != 0)) {
-        continue;
+//        if (strncmp(pToken->z, "true", pToken->n) == 0) {
-      }
+//          return func(&TRUE_VALUE, pSchema->bytes, param);
-      tmpTokenBuf[j] = pToken->z[k];
+//        } else if (strncmp(pToken->z, "false", pToken->n) == 0) {
-      j++;
+//          return func(&FALSE_VALUE, pSchema->bytes, param);
-    }
+//        } else {
-    tmpTokenBuf[j] = 0;
+//          return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z);
-    pToken->z = tmpTokenBuf;
+//        }
-    pToken->n -= 2 + cnt;
+//      } else if (pToken->type == TK_INTEGER) {
-  }
+//        return func(((strtoll(pToken->z, NULL, 10) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
-
+//      } else if (pToken->type == TK_FLOAT) {
-  return TSDB_CODE_SUCCESS;
+//        return func(((strtod(pToken->z, NULL) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
-}
+//      } else {
-
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z);
-static FORCE_INLINE int32_t parseOneValue(SInsertParseContext* pCxt, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, FRowAppend func, void* param) {
+//      }
-  int64_t iv;
+//    }
-  int32_t ret;
+//
-  char *  endptr = NULL;
+//    case TSDB_DATA_TYPE_TINYINT: {
-
+//      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
-  CHECK_CODE(checkAndTrimValue(pCxt, pToken, pSchema, tmpTokenBuf));
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid tinyint data", pToken->z);
-
+//      } else if (!IS_VALID_TINYINT(iv)) {
-  if (isNullStr(pToken)) {
+//        return buildSyntaxErrMsg(pMsgBuf, "tinyint data overflow", pToken->z);
-    if (TSDB_DATA_TYPE_TIMESTAMP == pSchema->type && PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) {
+//      }
-      int64_t tmpVal = 0;
+//
-      return func(&tmpVal, pSchema->bytes, param);
+//      uint8_t tmpVal = (uint8_t)iv;
-    }
+//      return func(&tmpVal, pSchema->bytes, param);
-    return func(getNullValue(pSchema->type), 0, param);
+//    }
-  }
+//
-
+//    case TSDB_DATA_TYPE_UTINYINT:{
-  switch (pSchema->type) {
+//      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
-    case TSDB_DATA_TYPE_BOOL: {
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned tinyint data", pToken->z);
-      if ((pToken->type == TK_BOOL || pToken->type == TK_STRING) && (pToken->n != 0)) {
+//      } else if (!IS_VALID_UTINYINT(iv)) {
-        if (strncmp(pToken->z, "true", pToken->n) == 0) {
+//        return buildSyntaxErrMsg(pMsgBuf, "unsigned tinyint data overflow", pToken->z);
-          return func(&TRUE_VALUE, pSchema->bytes, param);
+//      }
-        } else if (strncmp(pToken->z, "false", pToken->n) == 0) {
+//      uint8_t tmpVal = (uint8_t)iv;
-          return func(&FALSE_VALUE, pSchema->bytes, param);
+//      return func(&tmpVal, pSchema->bytes, param);
-        } else {
+//    }
-          return buildSyntaxErrMsg(&pCxt->msg, "invalid bool data", pToken->z);
+//
-        }
+//    case TSDB_DATA_TYPE_SMALLINT: {
-      } else if (pToken->type == TK_INTEGER) {
+//      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
-        return func(((strtoll(pToken->z, NULL, 10) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid smallint data", pToken->z);
-      } else if (pToken->type == TK_FLOAT) {
+//      } else if (!IS_VALID_SMALLINT(iv)) {
-        return func(((strtod(pToken->z, NULL) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
+//        return buildSyntaxErrMsg(pMsgBuf, "smallint data overflow", pToken->z);
-      } else {
+//      }
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid bool data", pToken->z);
+//      int16_t tmpVal = (int16_t)iv;
-      }
+//      return func(&tmpVal, pSchema->bytes, param);
-      break;
+//    }
-    }
+//
-    case TSDB_DATA_TYPE_TINYINT: {
+//    case TSDB_DATA_TYPE_USMALLINT: {
-      if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, true)) {
+//      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid tinyint data", pToken->z);
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned smallint data", pToken->z);
-      } else if (!IS_VALID_TINYINT(iv)) {
+//      } else if (!IS_VALID_USMALLINT(iv)) {
-        return buildSyntaxErrMsg(&pCxt->msg, "data overflow", pToken->z);
+//        return buildSyntaxErrMsg(pMsgBuf, "unsigned smallint data overflow", pToken->z);
-      }
+//      }
-      uint8_t tmpVal = (uint8_t)iv;
+//      uint16_t tmpVal = (uint16_t)iv;
-      return func(&tmpVal, pSchema->bytes, param);
+//      return func(&tmpVal, pSchema->bytes, param);
-    }
+//    }
-    case TSDB_DATA_TYPE_UTINYINT:{
+//
-      if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, false)) {
+//    case TSDB_DATA_TYPE_INT: {
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid unsigned tinyint data", pToken->z);
+//      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
-      } else if (!IS_VALID_UTINYINT(iv)) {
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid int data", pToken->z);
-        return buildSyntaxErrMsg(&pCxt->msg, "unsigned tinyint data overflow", pToken->z);
+//      } else if (!IS_VALID_INT(iv)) {
-      }
+//        return buildSyntaxErrMsg(pMsgBuf, "int data overflow", pToken->z);
-      uint8_t tmpVal = (uint8_t)iv;
+//      }
-      return func(&tmpVal, pSchema->bytes, param);
+//      int32_t tmpVal = (int32_t)iv;
-    }
+//      return func(&tmpVal, pSchema->bytes, param);
-    case TSDB_DATA_TYPE_SMALLINT: {
+//    }
-      if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, true)) {
+//
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid smallint data", pToken->z);
+//    case TSDB_DATA_TYPE_UINT: {
-      } else if (!IS_VALID_SMALLINT(iv)) {
+//      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
-        return buildSyntaxErrMsg(&pCxt->msg, "smallint data overflow", pToken->z);
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned int data", pToken->z);
-      }
+//      } else if (!IS_VALID_UINT(iv)) {
-      int16_t tmpVal = (int16_t)iv;
+//        return buildSyntaxErrMsg(pMsgBuf, "unsigned int data overflow", pToken->z);
-      return func(&tmpVal, pSchema->bytes, param);
+//      }
-    }
+//      uint32_t tmpVal = (uint32_t)iv;
-    case TSDB_DATA_TYPE_USMALLINT: {
+//      return func(&tmpVal, pSchema->bytes, param);
-      if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, false)) {
+//    }
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid unsigned smallint data", pToken->z);
+//
-      } else if (!IS_VALID_USMALLINT(iv)) {
+//    case TSDB_DATA_TYPE_BIGINT: {
-        return buildSyntaxErrMsg(&pCxt->msg, "unsigned smallint data overflow", pToken->z);
+//      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
-      }
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid bigint data", pToken->z);
-      uint16_t tmpVal = (uint16_t)iv;
+//      } else if (!IS_VALID_BIGINT(iv)) {
-      return func(&tmpVal, pSchema->bytes, param);
+//        return buildSyntaxErrMsg(pMsgBuf, "bigint data overflow", pToken->z);
-    }
+//      }
-    case TSDB_DATA_TYPE_INT: {
+//      return func(&iv, pSchema->bytes, param);
-      if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, true)) {
+//    }
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid int data", pToken->z);
+//
-      } else if (!IS_VALID_INT(iv)) {
+//    case TSDB_DATA_TYPE_UBIGINT: {
-        return buildSyntaxErrMsg(&pCxt->msg, "int data overflow", pToken->z);
+//      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
-      }
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned bigint data", pToken->z);
-      int32_t tmpVal = (int32_t)iv;
+//      } else if (!IS_VALID_UBIGINT((uint64_t)iv)) {
-      return func(&tmpVal, pSchema->bytes, param);
+//        return buildSyntaxErrMsg(pMsgBuf, "unsigned bigint data overflow", pToken->z);
-    }
+//      }
-    case TSDB_DATA_TYPE_UINT: {
+//      uint64_t tmpVal = (uint64_t)iv;
-      if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, false)) {
+//      return func(&tmpVal, pSchema->bytes, param);
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid unsigned int data", pToken->z);
+//    }
-      } else if (!IS_VALID_UINT(iv)) {
+//
-        return buildSyntaxErrMsg(&pCxt->msg, "unsigned int data overflow", pToken->z);
+//    case TSDB_DATA_TYPE_FLOAT: {
-      }
+//      double dv;
-      uint32_t tmpVal = (uint32_t)iv;
+//      if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
-      return func(&tmpVal, pSchema->bytes, param);
+//        return buildSyntaxErrMsg(pMsgBuf, "illegal float data", pToken->z);
-    }
+//      }
-    case TSDB_DATA_TYPE_BIGINT: {
+//      if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || dv > FLT_MAX || dv < -FLT_MAX || isinf(dv) || isnan(dv)) {
-      if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, true)) {
+//        return buildSyntaxErrMsg(pMsgBuf, "illegal float data", pToken->z);
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid bigint data", pToken->z);
+//      }
-      } else if (!IS_VALID_BIGINT(iv)) {
+//      float tmpVal = (float)dv;
-        return buildSyntaxErrMsg(&pCxt->msg, "bigint data overflow", pToken->z);
+//      return func(&tmpVal, pSchema->bytes, param);
-      }
+//    }
-      return func(&iv, pSchema->bytes, param);
+//
-    }
+//    case TSDB_DATA_TYPE_DOUBLE: {
-    case TSDB_DATA_TYPE_UBIGINT: {
+//      double dv;
-      if (TSDB_CODE_SUCCESS != toInt64(pToken->z, pToken->type, pToken->n, &iv, false)) {
+//      if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid unsigned bigint data", pToken->z);
+//        return buildSyntaxErrMsg(pMsgBuf, "illegal double data", pToken->z);
-      } else if (!IS_VALID_UBIGINT((uint64_t)iv)) {
+//      }
-        return buildSyntaxErrMsg(&pCxt->msg, "unsigned bigint data overflow", pToken->z);
+//      if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || isinf(dv) || isnan(dv)) {
-      }
+//        return buildSyntaxErrMsg(pMsgBuf, "illegal double data", pToken->z);
-      uint64_t tmpVal = (uint64_t)iv;
+//      }
-      return func(&tmpVal, pSchema->bytes, param);
+//      return func(&dv, pSchema->bytes, param);
-    }
+//    }
-    case TSDB_DATA_TYPE_FLOAT: {
+//
-      double dv;
+//    case TSDB_DATA_TYPE_BINARY: {
-      if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
+//      // too long values will return invalid sql, not be truncated automatically
-        return buildSyntaxErrMsg(&pCxt->msg, "illegal float data", pToken->z);
+//      if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {
-      }
+//        return buildSyntaxErrMsg(pMsgBuf, "string data overflow", pToken->z);
-      if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || dv > FLT_MAX || dv < -FLT_MAX || isinf(dv) || isnan(dv)) {
+//      }
-        return buildSyntaxErrMsg(&pCxt->msg, "illegal float data", pToken->z);
+//      return func(pToken->z, pToken->n, param);
-      }
+//    }
-      float tmpVal = (float)dv;
+//    case TSDB_DATA_TYPE_NCHAR: {
-      return func(&tmpVal, pSchema->bytes, param);
+//      return func(pToken->z, pToken->n, param);
-    }
+//    }
-    case TSDB_DATA_TYPE_DOUBLE: {
+//    case TSDB_DATA_TYPE_TIMESTAMP: {
-      double dv;
+//      int64_t tmpVal;
-      if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
+//      if (parseTime(end, pToken, timePrec, &tmpVal, pMsgBuf) != TSDB_CODE_SUCCESS) {
-        return buildSyntaxErrMsg(&pCxt->msg, "illegal double data", pToken->z);
+//        return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp", pToken->z);
-      }
+//      }
-      if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || isinf(dv) || isnan(dv)) {
+//      return func(&tmpVal, pSchema->bytes, param);
-        return buildSyntaxErrMsg(&pCxt->msg, "illegal double data", pToken->z);
+//    }
-      }
+//  }
-      return func(&dv, pSchema->bytes, param);
+//
-    }
+//  return TSDB_CODE_FAILED;
-    case TSDB_DATA_TYPE_BINARY: {
+//}
-      // too long values will return invalid sql, not be truncated automatically
-      if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {
-        return buildSyntaxErrMsg(&pCxt->msg, "string data overflow", pToken->z);
-      }
-      return func(pToken->z, pToken->n, param);
-    }
-    case TSDB_DATA_TYPE_NCHAR: {
-      return func(pToken->z, pToken->n, param);
-    }
-    case TSDB_DATA_TYPE_TIMESTAMP: {
-      int64_t tmpVal;
-      if (parseTime(pCxt, pToken, timePrec, &tmpVal) != TSDB_CODE_SUCCESS) {
-        return buildSyntaxErrMsg(&pCxt->msg, "invalid timestamp", pToken->z);
-      }
-      return func(&tmpVal, pSchema->bytes, param);
-    }
-  }
-
-  return TSDB_CODE_FAILED;
-}
 
 // pSql -> tag1_name, ...)
 static int32_t parseBoundColumns(SInsertParseContext* pCxt, SParsedDataColInfo* pColList, SSchema* pSchema) {
@@ -644,7 +625,7 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pTagsSchema,
     NEXT_TOKEN(pCxt->pSql, sToken);
     SSchema* pSchema = &pTagsSchema[pCxt->tags.boundedColumns[i]];
     param.schema = pSchema;
-    CHECK_CODE(parseOneValue(pCxt, &sToken, pSchema, precision, tmpTokenBuf, KvRowAppend, &param));
+    CHECK_CODE(parseValueToken(&pCxt->pSql, &sToken, pSchema, precision, tmpTokenBuf, KvRowAppend, &param, &pCxt->msg));
   }
 
   SKVRow row = tdGetKVRowFromBuilder(&pCxt->tagsBuilder);
@@ -709,7 +690,7 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
     param.schema = pSchema;
     param.compareStat = pBuilder->compareStat;
     getMemRowAppendInfo(schema, pBuilder->memRowType, spd, i, &param.toffset);
-    CHECK_CODE(parseOneValue(pCxt, &sToken, pSchema, timePrec, tmpTokenBuf, MemRowAppend, &param));
+    CHECK_CODE(parseValueToken(&pCxt->pSql, &sToken, pSchema, timePrec, tmpTokenBuf, MemRowAppend, &param, &pCxt->msg));
 
     if (PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) {
       TSKEY tsKey = memRowKey(row);
@@ -894,7 +875,7 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
 int32_t parseInsertSql(SParseContext* pContext, SInsertStmtInfo** pInfo) {
   SInsertParseContext context = {
     .pComCxt = pContext,
-    .pSql = pContext->pSql,
+    .pSql = (char*) pContext->pSql,
     .msg = {.buf = pContext->pMsg, .len = pContext->msgLen},
     .pTableMeta = NULL,
     .pVgroupsHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, false),

source/libs/parser/src/parserUtil.c

@@ -13,19 +13,20 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-#include "tmsg.h"
-#include "parser.h"
-#include "taoserror.h"
-#include "tutil.h"
-#include "ttypes.h"
-#include "thash.h"
-#include "tbuffer.h"
-#include "parserInt.h"
 #include "parserUtil.h"
-#include "tmsgtype.h"
+#include <tglobal.h>
-#include "queryInfoUtil.h"
+#include <ttime.h>
 #include "function.h"
+#include "parser.h"
+#include "parserInt.h"
+#include "queryInfoUtil.h"
+#include "taoserror.h"
+#include "tbuffer.h"
+#include "thash.h"
+#include "tmsg.h"
+#include "tmsgtype.h"
+#include "ttypes.h"
+#include "tutil.h"
 
 typedef struct STableFilterCond {
   uint64_t uid;
@@ -1627,313 +1628,357 @@ bool isDqlSqlStatement(SSqlInfo* pSqlInfo) {
   return pSqlInfo->type == TSDB_SQL_SELECT;
 }
 
-#if 0
+static uint8_t TRUE_VALUE = (uint8_t)TSDB_TRUE;
-int32_t tscCreateQueryFromQueryInfo(SQueryStmtInfo* pQueryInfo, SQueryAttr* pQueryAttr, void* addr) {
+static uint8_t FALSE_VALUE = (uint8_t)TSDB_FALSE;
-  memset(pQueryAttr, 0, sizeof(SQueryAttr));
 
-  int16_t numOfCols        = (int16_t) taosArrayGetSize(pQueryInfo->colList);
+static FORCE_INLINE int32_t toDouble(SToken *pToken, double *value, char **endPtr) {
-  int16_t numOfOutput      = (int16_t) getNumOfExprs(pQueryInfo);
+  errno = 0;
+  *value = strtold(pToken->z, endPtr);
 
-  pQueryAttr->topBotQuery       = tscIsTopBotQuery(pQueryInfo);
+  // not a valid integer number, return error
-  pQueryAttr->hasTagResults     = hasTagValOutput(pQueryInfo);
+  if ((*endPtr - pToken->z) != pToken->n) {
-  pQueryAttr->stabledev         = isStabledev(pQueryInfo);
+    return TK_ILLEGAL;
-  pQueryAttr->tsCompQuery       = isTsCompQuery(pQueryInfo);
-  pQueryAttr->diffQuery         = tscIsDiffDerivQuery(pQueryInfo);
-  pQueryAttr->simpleAgg         = isSimpleAggregateRv(pQueryInfo);
-  pQueryAttr->needReverseScan   = tscNeedReverseScan(pQueryInfo);
-  pQueryAttr->stableQuery       = QUERY_IS_STABLE_QUERY(pQueryInfo->type);
-  pQueryAttr->groupbyColumn     = (!pQueryInfo->stateWindow) && tscGroupbyColumn(pQueryInfo);
-  pQueryAttr->queryBlockDist    = isBlockDistQuery(pQueryInfo);
-  pQueryAttr->pointInterpQuery  = tscIsPointInterpQuery(pQueryInfo);
-  pQueryAttr->timeWindowInterpo = timeWindowInterpoRequired(pQueryInfo);
-  pQueryAttr->distinct          = pQueryInfo->distinct;
-  pQueryAttr->sw                = pQueryInfo->sessionWindow;
-  pQueryAttr->stateWindow       = pQueryInfo->stateWindow;
-  pQueryAttr->multigroupResult  = pQueryInfo->multigroupResult;
-
-  pQueryAttr->numOfCols         = numOfCols;
-  pQueryAttr->numOfOutput       = numOfOutput;
-  pQueryAttr->limit             = pQueryInfo->limit;
-  pQueryAttr->slimit            = pQueryInfo->slimit;
-  pQueryAttr->order             = pQueryInfo->order;
-  pQueryAttr->fillType          = pQueryInfo->fillType;
-  pQueryAttr->havingNum         = pQueryInfo->havingFieldNum;
-  pQueryAttr->pUdfInfo          = pQueryInfo->pUdfInfo;
-
-  if (pQueryInfo->order.order == TSDB_ORDER_ASC) {   // TODO refactor
-    pQueryAttr->window = pQueryInfo->window;
-  } else {
-    pQueryAttr->window.skey = pQueryInfo->window.ekey;
-    pQueryAttr->window.ekey = pQueryInfo->window.skey;
   }
 
-  memcpy(&pQueryAttr->interval, &pQueryInfo->interval, sizeof(pQueryAttr->interval));
+  return pToken->type;
+}
 
-  STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
+static bool isNullStr(SToken *pToken) {
+  return (pToken->type == TK_NULL) || ((pToken->type == TK_STRING) && (pToken->n != 0) &&
+                                       (strncasecmp(TSDB_DATA_NULL_STR_L, pToken->z, pToken->n) == 0));
+}
 
-  if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
+static FORCE_INLINE int32_t checkAndTrimValue(SToken* pToken, uint32_t type, char* tmpTokenBuf, SMsgBuf* pMsgBuf) {
-    pQueryAttr->pGroupbyExpr    = calloc(1, sizeof(SGroupbyExpr));
+  if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL &&
-    *(pQueryAttr->pGroupbyExpr) = pQueryInfo->groupbyExpr;
+       type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) ||
-    pQueryAttr->pGroupbyExpr->columnInfo = taosArrayDup(pQueryInfo->groupbyExpr.columnInfo);
+      (pToken->n == 0) || (type == TK_RP)) {
-  } else {
+    return buildSyntaxErrMsg(pMsgBuf, "invalid data or symbol", pToken->z);
-    assert(pQueryInfo->groupbyExpr.columnInfo == NULL);
   }
 
-  pQueryAttr->pExpr1 = calloc(pQueryAttr->numOfOutput, sizeof(SExprInfo));
+  if (IS_NUMERIC_TYPE(type) && pToken->n == 0) {
-  for(int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
+    return buildSyntaxErrMsg(pMsgBuf, "invalid numeric data", pToken->z);
-    SExprInfo* pExpr = getExprInfo(pQueryInfo, i);
+  }
-    ExprInfoCopy(&pQueryAttr->pExpr1[i], pExpr);
 
-    if (pQueryAttr->pExpr1[i].base.functionId == FUNCTION_ARITHM) {
+  // Remove quotation marks
-      for (int32_t j = 0; j < pQueryAttr->pExpr1[i].base.numOfParams; ++j) {
+  if (TK_STRING == type) {
-        buildArithmeticExprFromMsg(&pQueryAttr->pExpr1[i], NULL);
+    if (pToken->n >= TSDB_MAX_BYTES_PER_ROW) {
+      return buildSyntaxErrMsg(pMsgBuf, "too long string", pToken->z);
+    }
+
+    // delete escape character: \\, \', \"
+    char delim = pToken->z[0];
+    int32_t cnt = 0;
+    int32_t j = 0;
+    for (uint32_t k = 1; k < pToken->n - 1; ++k) {
+      if (pToken->z[k] == '\\' || (pToken->z[k] == delim && pToken->z[k + 1] == delim)) {
+        tmpTokenBuf[j] = pToken->z[k + 1];
+        cnt++;
+        j++;
+        k++;
+        continue;
       }
-    }
+      tmpTokenBuf[j] = pToken->z[k];
-  }
+      j++;
-
-  pQueryAttr->tableCols = calloc(numOfCols, sizeof(SColumnInfo));
-  for(int32_t i = 0; i < numOfCols; ++i) {
-    SColumn* pCol = taosArrayGetP(pQueryInfo->colList, i);
-    if (!isValidDataType(pCol->info.type) || pCol->info.type == TSDB_DATA_TYPE_NULL) {
-      assert(0);
     }
 
-    pQueryAttr->tableCols[i] = pCol->info;
+    tmpTokenBuf[j] = 0;
-    pQueryAttr->tableCols[i].flist.filterInfo = tFilterInfoDup(pCol->info.flist.filterInfo, pQueryAttr->tableCols[i].flist.numOfFilters);
+    pToken->z = tmpTokenBuf;
+    pToken->n -= 2 + cnt;
   }
 
-  // global aggregate query
+  return TSDB_CODE_SUCCESS;
-  if (pQueryAttr->stableQuery && (pQueryAttr->simpleAgg || pQueryAttr->interval.interval > 0) && tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
+}
-    createGlobalAggregateExpr(pQueryAttr, pQueryInfo);
-  }
 
-  // for simple table, not for super table
+static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time, SMsgBuf* pMsgBuf) {
-  if (pQueryInfo->arithmeticOnAgg) {
+  int32_t   index = 0;
-    pQueryAttr->numOfExpr2 = (int32_t) taosArrayGetSize(pQueryInfo->exprList1);
+  SToken    sToken;
-    pQueryAttr->pExpr2 = calloc(pQueryAttr->numOfExpr2, sizeof(SExprInfo));
+  int64_t   interval;
-    for(int32_t i = 0; i < pQueryAttr->numOfExpr2; ++i) {
+  int64_t   ts = 0;
-      SExprInfo* p = taosArrayGetP(pQueryInfo->exprList1, i);
+  char* pTokenEnd = *end;
-      ExprInfoCopy(&pQueryAttr->pExpr2[i], p);
+
+  if (pToken->type == TK_NOW) {
+    ts = taosGetTimestamp(timePrec);
+  } else if (pToken->type == TK_INTEGER) {
+    bool isSigned = false;
+    toInteger(pToken->z, pToken->n, 10, &ts, &isSigned);
+  } else { // parse the RFC-3339/ISO-8601 timestamp format string
+    if (taosParseTime(pToken->z, time, pToken->n, timePrec, tsDaylight) != TSDB_CODE_SUCCESS) {
+      return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp format", pToken->z);
     }
+
+    return TSDB_CODE_SUCCESS;
   }
 
-  // tag column info
+  for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
-  int32_t code = createTagColumnInfo(pQueryAttr, pQueryInfo, pTableMetaInfo);
+    if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
+    if (pToken->z[k] == ',') {
+      *end = pTokenEnd;
+      *time = ts;
+      return 0;
+    }
+
+    break;
+  }
+
+  /*
+   * time expression:
+   * e.g., now+12a, now-5h
+   */
+  SToken valueToken;
+  index = 0;
+  sToken = tStrGetToken(pTokenEnd, &index, false);
+  pTokenEnd += index;
+
+  if (sToken.type == TK_MINUS || sToken.type == TK_PLUS) {
+    index = 0;
+    valueToken = tStrGetToken(pTokenEnd, &index, false);
+    pTokenEnd += index;
+
+    if (valueToken.n < 2) {
+      return buildSyntaxErrMsg(pMsgBuf, "value expected in timestamp", sToken.z);
+    }
+
+    char unit = 0;
+    if (parseAbsoluteDuration(valueToken.z, valueToken.n, &interval, &unit, timePrec) != TSDB_CODE_SUCCESS) {
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+
+    if (sToken.type == TK_PLUS) {
+      ts += interval;
+    } else {
+      ts = ts - interval;
+    }
+
+    *end = pTokenEnd;
+  }
+
+  *time = ts;
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, _row_append_fn_t func, void* param, SMsgBuf* pMsgBuf) {
+  int64_t iv;
+  char   *endptr = NULL;
+  bool    isSigned = false;
+
+  int32_t code = checkAndTrimValue(pToken, pSchema->type, tmpTokenBuf, pMsgBuf);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
 
-  if (pQueryAttr->fillType != TSDB_FILL_NONE) {
+  if (isNullStr(pToken)) {
-    pQueryAttr->fillVal = calloc(pQueryAttr->numOfOutput, sizeof(int64_t));
+    if (TSDB_DATA_TYPE_TIMESTAMP == pSchema->type && PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) {
-    memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryInfo->numOfFillVal * sizeof(int64_t));
+      int64_t tmpVal = 0;
-  }
+      return func(&tmpVal, pSchema->bytes, param);
-
-  pQueryAttr->srcRowSize = 0;
-  pQueryAttr->maxTableColumnWidth = 0;
-  for (int16_t i = 0; i < numOfCols; ++i) {
-    pQueryAttr->srcRowSize += pQueryAttr->tableCols[i].bytes;
-    if (pQueryAttr->maxTableColumnWidth < pQueryAttr->tableCols[i].bytes) {
-      pQueryAttr->maxTableColumnWidth = pQueryAttr->tableCols[i].bytes;
-    }
-  }
-
-  pQueryAttr->interBufSize = getOutputInterResultBufSize(pQueryAttr);
-
-  if (pQueryAttr->numOfCols <= 0 && !tscQueryTags(pQueryInfo) && !pQueryAttr->queryBlockDist) {
-    tscError("%p illegal value of numOfCols in query msg: %" PRIu64 ", table cols:%d", addr,
-             (uint64_t)pQueryAttr->numOfCols, numOfCols);
-
-    return TSDB_CODE_TSC_INVALID_OPERATION;
-  }
-
-  if (pQueryAttr->interval.interval < 0) {
-    tscError("%p illegal value of aggregation time interval in query msg: %" PRId64, addr,
-             (int64_t)pQueryInfo->interval.interval);
-    return TSDB_CODE_TSC_INVALID_OPERATION;
-  }
-
-  if (pQueryAttr->pGroupbyExpr != NULL && pQueryAttr->pGroupbyExpr->numOfGroupCols < 0) {
-    tscError("%p illegal value of numOfGroupCols in query msg: %d", addr, pQueryInfo->groupbyExpr.numOfGroupCols);
-    return TSDB_CODE_TSC_INVALID_OPERATION;
-  }
-
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t doAddTableName(char* nextStr, char** str, SArray* pNameArray, SSqlObj* pSql) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  SSqlCmd* pCmd = &pSql->cmd;
-
-  char  tablename[TSDB_TABLE_FNAME_LEN] = {0};
-  int32_t len = 0;
-
-  if (nextStr == NULL) {
-    tstrncpy(tablename, *str, TSDB_TABLE_FNAME_LEN);
-    len = (int32_t) strlen(tablename);
-  } else {
-    len = (int32_t)(nextStr - (*str));
-    if (len >= TSDB_TABLE_NAME_LEN) {
-      sprintf(pCmd->payload, "table name too long");
-      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
-    memcpy(tablename, *str, nextStr - (*str));
+    return func(getNullValue(pSchema->type), 0, param);
-    tablename[len] = '\0';
   }
 
-  (*str) = nextStr + 1;
+  switch (pSchema->type) {
-  len = (int32_t)strtrim(tablename);
+    case TSDB_DATA_TYPE_BOOL: {
-
+      if ((pToken->type == TK_BOOL || pToken->type == TK_STRING) && (pToken->n != 0)) {
-  SToken sToken = {.n = len, .type = TK_ID, .z = tablename};
+        if (strncmp(pToken->z, "true", pToken->n) == 0) {
-  tGetToken(tablename, &sToken.type);
+          return func(&TRUE_VALUE, pSchema->bytes, param);
-
+        } else if (strncmp(pToken->z, "false", pToken->n) == 0) {
-  // Check if the table name available or not
+          return func(&FALSE_VALUE, pSchema->bytes, param);
-  if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) {
+        } else {
-    sprintf(pCmd->payload, "table name is invalid");
+          return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z);
-    return TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+        }
-  }
+      } else if (pToken->type == TK_INTEGER) {
-
+        return func(((strtoll(pToken->z, NULL, 10) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
-  SName name = {0};
+      } else if (pToken->type == TK_FLOAT) {
-  if ((code = tscSetTableFullName(&name, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
+        return func(((strtod(pToken->z, NULL) == 0) ? &FALSE_VALUE : &TRUE_VALUE), pSchema->bytes, param);
-    return code;
+      } else {
-  }
+        return buildSyntaxErrMsg(pMsgBuf, "invalid bool data", pToken->z);
-
-  memset(tablename, 0, tListLen(tablename));
-  tNameExtractFullName(&name, tablename);
-
-  char* p = strdup(tablename);
-  taosArrayPush(pNameArray, &p);
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t nameComparFn(const void* n1, const void* n2) {
-  int32_t ret = strcmp(*(char**)n1, *(char**)n2);
-  if (ret == 0) {
-    return 0;
-  } else {
-    return ret > 0? 1:-1;
-  }
-}
-
-static void freeContent(void* p) {
-  char* ptr = *(char**)p;
-  tfree(ptr);
-}
-
-
-int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length, SArray* pNameArray) {
-  SSqlCmd *pCmd = &pSql->cmd;
-
-  pCmd->command = TSDB_SQL_MULTI_META;
-  pCmd->msgType = TDMT_VND_TABLES_META;
-
-  int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-  char *str = (char *)pNameList;
-
-  SQueryStmtInfo *pQueryInfo = tscGetQueryInfoS(pCmd);
-  if (pQueryInfo == NULL) {
-    pSql->res.code = terrno;
-    return terrno;
-  }
-
-  char *nextStr;
-  while (1) {
-    nextStr = strchr(str, ',');
-    if (nextStr == NULL) {
-      code = doAddTableName(nextStr, &str, pNameArray, pSql);
-      break;
-    }
-
-    code = doAddTableName(nextStr, &str, pNameArray, pSql);
-    if (code != TSDB_CODE_SUCCESS) {
-      return code;
-    }
-
-    if (taosArrayGetSize(pNameArray) > TSDB_MULTI_TABLEMETA_MAX_NUM) {
-      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-      sprintf(pCmd->payload, "tables over the max number");
-      return code;
-    }
-  }
-
-  size_t len = taosArrayGetSize(pNameArray);
-  if (len == 1) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  if (len > TSDB_MULTI_TABLEMETA_MAX_NUM) {
-    code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-    sprintf(pCmd->payload, "tables over the max number");
-    return code;
-  }
-
-  taosArraySort(pNameArray, nameComparFn);
-  taosArrayRemoveDuplicate(pNameArray, nameComparFn, freeContent);
-  return TSDB_CODE_SUCCESS;
-}
-
-bool vgroupInfoIdentical(SNewVgroupInfo *pExisted, SVgroupMsg* src) {
-  assert(pExisted != NULL && src != NULL);
-  if (pExisted->numOfEps != src->numOfEps) {
-    return false;
-  }
-
-  for(int32_t i = 0; i < pExisted->numOfEps; ++i) {
-    if (pExisted->ep[i].port != src->epAddr[i].port) {
-      return false;
-    }
-
-    if (strncmp(pExisted->ep[i].fqdn, src->epAddr[i].fqdn, tListLen(pExisted->ep[i].fqdn)) != 0) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-SNewVgroupInfo createNewVgroupInfo(SVgroupMsg *pVgroupMsg) {
-  assert(pVgroupMsg != NULL);
-
-  SNewVgroupInfo info = {0};
-  info.numOfEps = pVgroupMsg->numOfEps;
-  info.vgId     = pVgroupMsg->vgId;
-  info.inUse    = 0;   // 0 is the default value of inUse in case of multiple replica
-
-  assert(info.numOfEps >= 1 && info.vgId >= 1);
-  for(int32_t i = 0; i < pVgroupMsg->numOfEps; ++i) {
-    tstrncpy(info.ep[i].fqdn, pVgroupMsg->epAddr[i].fqdn, TSDB_FQDN_LEN);
-    info.ep[i].port = pVgroupMsg->epAddr[i].port;
-  }
-
-  return info;
-}
-
-char* cloneCurrentDBName(SSqlObj* pSql) {
-  char        *p = NULL;
-  HttpContext *pCtx = NULL;
-
-  pthread_mutex_lock(&pSql->pTscObj->mutex);
-  STscObj *pTscObj = pSql->pTscObj;
-  switch (pTscObj->from) {
-    case TAOS_REQ_FROM_HTTP:
-      pCtx = pSql->param;
-      if (pCtx && pCtx->db[0] != '\0') {
-        char db[TSDB_DB_FNAME_LEN] = {0};
-        int32_t len = sprintf(db, "%s%s%s", pTscObj->acctId, TS_PATH_DELIMITER, pCtx->db);
-        assert(len <= sizeof(db));
-
-        p = strdup(db);
       }
-      break;
+    }
-    default:
-      break;
-  }
-  if (p == NULL) {
-    p = strdup(pSql->pTscObj->db);
-  }
-  pthread_mutex_unlock(&pSql->pTscObj->mutex);
 
-  return p;
+    case TSDB_DATA_TYPE_TINYINT: {
+      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid tinyint data", pToken->z);
+      } else if (!IS_VALID_TINYINT(iv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "tinyint data overflow", pToken->z);
+      }
+
+      uint8_t tmpVal = (uint8_t)iv;
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_UTINYINT:{
+      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned tinyint data", pToken->z);
+      } else if (!IS_VALID_UTINYINT(iv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "unsigned tinyint data overflow", pToken->z);
+      }
+      uint8_t tmpVal = (uint8_t)iv;
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_SMALLINT: {
+      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid smallint data", pToken->z);
+      } else if (!IS_VALID_SMALLINT(iv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "smallint data overflow", pToken->z);
+      }
+      int16_t tmpVal = (int16_t)iv;
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_USMALLINT: {
+      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned smallint data", pToken->z);
+      } else if (!IS_VALID_USMALLINT(iv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "unsigned smallint data overflow", pToken->z);
+      }
+      uint16_t tmpVal = (uint16_t)iv;
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_INT: {
+      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid int data", pToken->z);
+      } else if (!IS_VALID_INT(iv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "int data overflow", pToken->z);
+      }
+      int32_t tmpVal = (int32_t)iv;
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_UINT: {
+      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned int data", pToken->z);
+      } else if (!IS_VALID_UINT(iv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "unsigned int data overflow", pToken->z);
+      }
+      uint32_t tmpVal = (uint32_t)iv;
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_BIGINT: {
+      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid bigint data", pToken->z);
+      } else if (!IS_VALID_BIGINT(iv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "bigint data overflow", pToken->z);
+      }
+      return func(&iv, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_UBIGINT: {
+      if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, pToken->type, &iv, &isSigned)) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned bigint data", pToken->z);
+      } else if (!IS_VALID_UBIGINT((uint64_t)iv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "unsigned bigint data overflow", pToken->z);
+      }
+      uint64_t tmpVal = (uint64_t)iv;
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_FLOAT: {
+      double dv;
+      if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
+        return buildSyntaxErrMsg(pMsgBuf, "illegal float data", pToken->z);
+      }
+      if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || dv > FLT_MAX || dv < -FLT_MAX || isinf(dv) || isnan(dv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "illegal float data", pToken->z);
+      }
+      float tmpVal = (float)dv;
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_DOUBLE: {
+      double dv;
+      if (TK_ILLEGAL == toDouble(pToken, &dv, &endptr)) {
+        return buildSyntaxErrMsg(pMsgBuf, "illegal double data", pToken->z);
+      }
+      if (((dv == HUGE_VAL || dv == -HUGE_VAL) && errno == ERANGE) || isinf(dv) || isnan(dv)) {
+        return buildSyntaxErrMsg(pMsgBuf, "illegal double data", pToken->z);
+      }
+      return func(&dv, pSchema->bytes, param);
+    }
+
+    case TSDB_DATA_TYPE_BINARY: {
+      // Too long values will raise the invalid sql error message
+      if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {
+        return buildSyntaxErrMsg(pMsgBuf, "string data overflow", pToken->z);
+      }
+
+      return func(pToken->z, pToken->n, param);
+    }
+
+    case TSDB_DATA_TYPE_NCHAR: {
+      return func(pToken->z, pToken->n, param);
+    }
+
+    case TSDB_DATA_TYPE_TIMESTAMP: {
+      int64_t tmpVal;
+      if (parseTime(end, pToken, timePrec, &tmpVal, pMsgBuf) != TSDB_CODE_SUCCESS) {
+        return buildSyntaxErrMsg(pMsgBuf, "invalid timestamp", pToken->z);
+      }
+
+      return func(&tmpVal, pSchema->bytes, param);
+    }
+  }
+
+  return TSDB_CODE_FAILED;
 }
 
-#endif
+int32_t KvRowAppend(const void *value, int32_t len, void *param) {
+  SKvParam* pa = (SKvParam*) param;
+
+  int32_t type  = pa->schema->type;
+  int32_t colId = pa->schema->colId;
+
+  if (TSDB_DATA_TYPE_BINARY == type) {
+    STR_WITH_SIZE_TO_VARSTR(pa->buf, value, len);
+    tdAddColToKVRow(pa->builder, colId, type, pa->buf);
+  } else if (TSDB_DATA_TYPE_NCHAR == type) {
+    // if the converted output len is over than pColumnModel->bytes, return error: 'Argument list too long'
+    int32_t output = 0;
+    if (!taosMbsToUcs4(value, len, varDataVal(pa->buf), pa->schema->bytes - VARSTR_HEADER_SIZE, &output)) {
+      return TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
+    }
+
+    varDataSetLen(pa->buf, output);
+    tdAddColToKVRow(pa->builder, colId, type, pa->buf);
+  } else {
+    tdAddColToKVRow(pa->builder, colId, type, value);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t createSName(SName* pName, SToken* pTableName, SParseBasicCtx* pParseCtx, SMsgBuf* pMsgBuf) {
+  const char* msg1 = "name too long";
+
+  int32_t  code = TSDB_CODE_SUCCESS;
+  char* p  = strnchr(pTableName->z, TS_PATH_DELIMITER[0], pTableName->n, false);
+
+  if (p != NULL) { // db has been specified in sql string so we ignore current db path
+    tNameSetAcctId(pName, pParseCtx->acctId);
+
+    char name[TSDB_TABLE_FNAME_LEN] = {0};
+    strncpy(name, pTableName->z, pTableName->n);
+
+    code = tNameFromString(pName, name, T_NAME_DB|T_NAME_TABLE);
+    if (code != 0) {
+      return buildInvalidOperationMsg(pMsgBuf, msg1);
+    }
+  } else {  // get current DB name first, and then set it into path
+    if (pTableName->n >= TSDB_TABLE_NAME_LEN) {
+      return buildInvalidOperationMsg(pMsgBuf, msg1);
+    }
+
+    tNameSetDbName(pName, pParseCtx->acctId, pParseCtx->db, strlen(pParseCtx->db));
+
+    char name[TSDB_TABLE_FNAME_LEN] = {0};
+    strncpy(name, pTableName->z, pTableName->n);
+
+    code = tNameFromString(pName, name, T_NAME_TABLE);
+    if (code != 0) {
+      code = buildInvalidOperationMsg(pMsgBuf, msg1);
+    }
+  }
+
+  return code;
+}

source/libs/parser/test/mockCatalog.cpp

@@ -45,12 +45,12 @@ int32_t __catalogGetHandle(const char *clusterId, struct SCatalog** catalogHandl
   return 0;
 }
 
-int32_t __catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, STableMeta** pTableMeta) {
+int32_t __catalogGetTableMeta(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, STableMeta** pTableMeta) {
-  return mockCatalogService->catalogGetTableMeta(pDBName, pTableName, pTableMeta);
+  return mockCatalogService->catalogGetTableMeta(pTableName, pTableMeta);
 }
 
-int32_t __catalogGetTableHashVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo) {
+int32_t __catalogGetTableHashVgroup(struct SCatalog* pCatalog, void *pRpc, const SEpSet* pMgmtEps, const SName* pTableName, SVgroupInfo* vgInfo) {
-  return mockCatalogService->catalogGetTableHashVgroup(pDBName, pTableName, vgInfo);
+  return mockCatalogService->catalogGetTableHashVgroup(pTableName, vgInfo);
 }
 
 void initMetaDataEnv() {

source/libs/parser/test/mockCatalogService.cpp

@@ -94,9 +94,14 @@ public:
     return 0;
   }
 
-  int32_t catalogGetTableMeta(const char* pDbFullName, const char* pTableName, STableMeta** pTableMeta) const {
+  int32_t catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta) const {
     std::unique_ptr<STableMeta> table;
-    int32_t code = copyTableSchemaMeta(toDbname(pDbFullName), pTableName, &table);
+
+    char db[TSDB_DB_FNAME_LEN] = {0};
+    tNameGetFullDbName(pTableName, db);
+
+    const char* tname = tNameGetTableName(pTableName);
+    int32_t code = copyTableSchemaMeta(db, tname, &table);
     if (TSDB_CODE_SUCCESS != code) {
       return code;
     }
@@ -104,7 +109,7 @@ public:
     return TSDB_CODE_SUCCESS;
   }
 
-  int32_t catalogGetTableHashVgroup(const char* pDbFullName, const char* pTableName, SVgroupInfo* vgInfo) const {
+  int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const {
     // todo
     return 0;
   }
@@ -283,10 +288,10 @@ std::shared_ptr<MockTableMeta> MockCatalogService::getTableMeta(const std::strin
   return impl_->getTableMeta(db, tbname);
 }
 
-int32_t MockCatalogService::catalogGetTableMeta(const char* pDBName, const char* pTableName, STableMeta** pTableMeta) const {
+int32_t MockCatalogService::catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta) const {
-  return impl_->catalogGetTableMeta(pDBName, pTableName, pTableMeta);
+  return impl_->catalogGetTableMeta(pTableName, pTableMeta);
 }
 
-int32_t MockCatalogService::catalogGetTableHashVgroup(const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo) const {
+int32_t MockCatalogService::catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const {
-  return impl_->catalogGetTableHashVgroup(pDBName, pTableName, vgInfo);
+  return impl_->catalogGetTableHashVgroup(pTableName, vgInfo);
 }

source/libs/parser/test/mockCatalogService.h

@@ -57,8 +57,8 @@ public:
   void showTables() const;
   std::shared_ptr<MockTableMeta> getTableMeta(const std::string& db, const std::string& tbname) const;
 
-  int32_t catalogGetTableMeta(const char* pDBName, const char* pTableName, STableMeta** pTableMeta) const;
+  int32_t catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta) const;
-  int32_t catalogGetTableHashVgroup(const char* pDBName, const char* pTableName, SVgroupInfo* vgInfo) const;
+  int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const;
 
 private:
   std::unique_ptr<MockCatalogServiceImpl> impl_;

source/util/src/tbuffer.c

@@ -13,14 +13,14 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "os.h"
 #include "tbuffer.h"
 #include "exception.h"
+#include "os.h"
 //#include "taoserror.h"
 
 typedef union Un4B {
   uint32_t ui;
-  float     f;
+  float    f;
 } Un4B;
 #if __STDC_VERSION__ >= 201112L
 static_assert(sizeof(Un4B) == sizeof(uint32_t), "sizeof(Un4B) must equal to sizeof(uint32_t)");
@@ -29,7 +29,7 @@ static_assert(sizeof(Un4B) == sizeof(float), "sizeof(Un4B) must equal to sizeof(
 
 typedef union Un8B {
   uint64_t ull;
-  double     d;
+  double   d;
 } Un8B;
 #if __STDC_VERSION__ >= 201112L
 static_assert(sizeof(Un8B) == sizeof(uint64_t), "sizeof(Un8B) must equal to sizeof(uint64_t)");
@@ -40,172 +40,172 @@ static_assert(sizeof(Un8B) == sizeof(double), "sizeof(Un8B) must equal to sizeof
 // reader functions
 
 size_t tbufSkip(SBufferReader* buf, size_t size) {
-  if( (buf->pos + size) > buf->size ) {
+  if ((buf->pos + size) > buf->size) {
-    THROW( -1 );
+    THROW(-1);
   }
   size_t old = buf->pos;
   buf->pos += size;
   return old;
 }
 
-const char* tbufRead( SBufferReader* buf, size_t size ) {
+const char* tbufRead(SBufferReader* buf, size_t size) {
   const char* ret = buf->data + buf->pos;
-  tbufSkip( buf, size );
+  tbufSkip(buf, size);
   return ret;
 }
 
-void tbufReadToBuffer( SBufferReader* buf, void* dst, size_t size ) {
+void tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size) {
-  assert( dst != NULL );
+  assert(dst != NULL);
   // always using memcpy, leave optimization to compiler
-  memcpy( dst, tbufRead(buf, size), size );
+  memcpy(dst, tbufRead(buf, size), size);
 }
 
-static size_t tbufReadLength( SBufferReader* buf ) {
+static size_t tbufReadLength(SBufferReader* buf) {
   // maximum length is 65535, if larger length is required
   // this function and the corresponding write function need to be
   // revised.
-  uint16_t l = tbufReadUint16( buf );
+  uint16_t l = tbufReadUint16(buf);
   return l;
 }
 
-const char* tbufReadString( SBufferReader* buf, size_t* len ) {
+const char* tbufReadString(SBufferReader* buf, size_t* len) {
-  size_t l = tbufReadLength( buf );
+  size_t      l = tbufReadLength(buf);
   const char* ret = buf->data + buf->pos;
-  tbufSkip( buf, l + 1 );
+  tbufSkip(buf, l + 1);
-  if( ret[l] != 0 ) {
+  if (ret[l] != 0) {
-    THROW( -1 );
+    THROW(-1);
   }
-  if( len != NULL ) {
+  if (len != NULL) {
     *len = l;
   }
   return ret;
 }
 
-size_t tbufReadToString( SBufferReader* buf, char* dst, size_t size ) {
+size_t tbufReadToString(SBufferReader* buf, char* dst, size_t size) {
-  assert( dst != NULL );
+  assert(dst != NULL);
-  size_t len;
+  size_t      len;
-  const char* str = tbufReadString( buf, &len );
+  const char* str = tbufReadString(buf, &len);
   if (len >= size) {
     len = size - 1;
   }
-  memcpy( dst, str, len );
+  memcpy(dst, str, len);
   dst[len] = 0;
   return len;
 }
 
-const char* tbufReadBinary( SBufferReader* buf, size_t *len ) {
+const char* tbufReadBinary(SBufferReader* buf, size_t* len) {
-  size_t l = tbufReadLength( buf );
+  size_t      l = tbufReadLength(buf);
   const char* ret = buf->data + buf->pos;
-  tbufSkip( buf, l );
+  tbufSkip(buf, l);
-  if( len != NULL ) {
+  if (len != NULL) {
     *len = l;
   }
   return ret;
 }
 
-size_t tbufReadToBinary( SBufferReader* buf, void* dst, size_t size ) {
+size_t tbufReadToBinary(SBufferReader* buf, void* dst, size_t size) {
-  assert( dst != NULL );
+  assert(dst != NULL);
-  size_t len;
+  size_t      len;
-  const char* data = tbufReadBinary( buf, &len );
+  const char* data = tbufReadBinary(buf, &len);
-  if( len >= size ) {
+  if (len >= size) {
     len = size;
   }
-  memcpy( dst, data, len );
+  memcpy(dst, data, len);
   return len;
 }
 
-bool tbufReadBool( SBufferReader* buf ) {
+bool tbufReadBool(SBufferReader* buf) {
   bool ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
   return ret;
 }
 
-char tbufReadChar( SBufferReader* buf ) {
+char tbufReadChar(SBufferReader* buf) {
   char ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
   return ret;
 }
 
-int8_t tbufReadInt8( SBufferReader* buf ) {
+int8_t tbufReadInt8(SBufferReader* buf) {
   int8_t ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
   return ret;
 }
 
-uint8_t tbufReadUint8( SBufferReader* buf ) {
+uint8_t tbufReadUint8(SBufferReader* buf) {
   uint8_t ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
   return ret;
 }
 
-int16_t tbufReadInt16( SBufferReader* buf ) {
+int16_t tbufReadInt16(SBufferReader* buf) {
   int16_t ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if( buf->endian ) {
+  if (buf->endian) {
-    return (int16_t)ntohs( ret );
+    return (int16_t)ntohs(ret);
   }
   return ret;
 }
 
-uint16_t tbufReadUint16( SBufferReader* buf ) {
+uint16_t tbufReadUint16(SBufferReader* buf) {
   uint16_t ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if( buf->endian ) {
+  if (buf->endian) {
-    return ntohs( ret );
+    return ntohs(ret);
   }
   return ret;
 }
 
-int32_t tbufReadInt32( SBufferReader* buf ) {
+int32_t tbufReadInt32(SBufferReader* buf) {
   int32_t ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if( buf->endian ) {
+  if (buf->endian) {
-    return (int32_t)ntohl( ret );
+    return (int32_t)ntohl(ret);
   }
   return ret;
 }
 
-uint32_t tbufReadUint32( SBufferReader* buf ) {
+uint32_t tbufReadUint32(SBufferReader* buf) {
   uint32_t ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if( buf->endian ) {
+  if (buf->endian) {
-    return ntohl( ret );
+    return ntohl(ret);
   }
   return ret;
 }
 
-int64_t tbufReadInt64( SBufferReader* buf ) {
+int64_t tbufReadInt64(SBufferReader* buf) {
   int64_t ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if( buf->endian ) {
+  if (buf->endian) {
-    return (int64_t)htobe64( ret ); // TODO: ntohll
+    return (int64_t)htobe64(ret);  // TODO: ntohll
   }
   return ret;
 }
 
-uint64_t tbufReadUint64( SBufferReader* buf ) {
+uint64_t tbufReadUint64(SBufferReader* buf) {
   uint64_t ret;
-  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if( buf->endian ) {
+  if (buf->endian) {
-    return htobe64( ret ); // TODO: ntohll
+    return htobe64(ret);  // TODO: ntohll
   }
   return ret;
 }
 
-float tbufReadFloat( SBufferReader* buf ) {
+float tbufReadFloat(SBufferReader* buf) {
   Un4B _un;
-  tbufReadToBuffer( buf, &_un, sizeof(_un) );
+  tbufReadToBuffer(buf, &_un, sizeof(_un));
-  if( buf->endian ) {
+  if (buf->endian) {
-    _un.ui = ntohl( _un.ui );
+    _un.ui = ntohl(_un.ui);
   }
   return _un.f;
 }
 
 double tbufReadDouble(SBufferReader* buf) {
   Un8B _un;
-  tbufReadToBuffer( buf, &_un, sizeof(_un) );
+  tbufReadToBuffer(buf, &_un, sizeof(_un));
-  if( buf->endian ) {
+  if (buf->endian) {
-    _un.ull = htobe64( _un.ull );
+    _un.ull = htobe64(_un.ull);
   }
   return _un.d;
 }
@@ -213,38 +213,38 @@ double tbufReadDouble(SBufferReader* buf) {
 ////////////////////////////////////////////////////////////////////////////////
 // writer functions
 
-void tbufCloseWriter( SBufferWriter* buf ) {
+void tbufCloseWriter(SBufferWriter* buf) {
   tfree(buf->data);
-//  (*buf->allocator)( buf->data, 0 );  // potential memory leak.
+  //  (*buf->allocator)( buf->data, 0 );  // potential memory leak.
   buf->data = NULL;
   buf->pos = 0;
   buf->size = 0;
 }
 
-void tbufEnsureCapacity( SBufferWriter* buf, size_t size ) {
+void tbufEnsureCapacity(SBufferWriter* buf, size_t size) {
   size += buf->pos;
-  if( size > buf->size ) {
+  if (size > buf->size) {
     size_t nsize = size + buf->size;
-    char* data = (*buf->allocator)( buf->data, nsize );
+    char*  data = (*buf->allocator)(buf->data, nsize);
     // TODO: the exception should be thrown by the allocator function
-    if( data == NULL ) {
+    if (data == NULL) {
-      THROW( -1 );
+      THROW(-1);
     }
     buf->data = data;
     buf->size = nsize;
   }
 }
 
-size_t tbufReserve( SBufferWriter* buf, size_t size ) {
+size_t tbufReserve(SBufferWriter* buf, size_t size) {
-  tbufEnsureCapacity( buf, size );
+  tbufEnsureCapacity(buf, size);
   size_t old = buf->pos;
   buf->pos += size;
   return old;
 }
 
-char* tbufGetData( SBufferWriter* buf, bool takeOver ) {
+char* tbufGetData(SBufferWriter* buf, bool takeOver) {
   char* ret = buf->data;
-  if( takeOver ) {
+  if (takeOver) {
     buf->pos = 0;
     buf->size = 0;
     buf->data = NULL;
@@ -252,192 +252,174 @@ char* tbufGetData( SBufferWriter* buf, bool takeOver ) {
   return ret;
 }
 
-void tbufWrite( SBufferWriter* buf, const void* data, size_t size ) {
+void tbufWrite(SBufferWriter* buf, const void* data, size_t size) {
-  assert( data != NULL );
+  assert(data != NULL);
-  tbufEnsureCapacity( buf, size );
+  tbufEnsureCapacity(buf, size);
-  memcpy( buf->data + buf->pos, data, size );
+  memcpy(buf->data + buf->pos, data, size);
   buf->pos += size;
 }
 
-void tbufWriteAt( SBufferWriter* buf, size_t pos, const void* data, size_t size ) {
+void tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size) {
-  assert( data != NULL );
+  assert(data != NULL);
   // this function can only be called to fill the gap on previous writes,
   // so 'pos + size <= buf->pos' must be true
-  assert( pos + size <= buf->pos );
+  assert(pos + size <= buf->pos);
-  memcpy( buf->data + pos, data, size );
+  memcpy(buf->data + pos, data, size);
 }
 
-static void tbufWriteLength( SBufferWriter* buf, size_t len ) {
+static void tbufWriteLength(SBufferWriter* buf, size_t len) {
   // maximum length is 65535, if larger length is required
   // this function and the corresponding read function need to be
   // revised.
-  assert( len <= 0xffff );
+  assert(len <= 0xffff);
-  tbufWriteUint16( buf, (uint16_t)len );
+  tbufWriteUint16(buf, (uint16_t)len);
 }
 
-void tbufWriteStringLen( SBufferWriter* buf, const char* str, size_t len ) {
+void tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len) {
-  tbufWriteLength( buf, len );
+  tbufWriteLength(buf, len);
-  tbufWrite( buf, str, len );
+  tbufWrite(buf, str, len);
-  tbufWriteChar( buf, '\0' );
+  tbufWriteChar(buf, '\0');
 }
 
-void tbufWriteString( SBufferWriter* buf, const char* str ) {
+void tbufWriteString(SBufferWriter* buf, const char* str) { tbufWriteStringLen(buf, str, strlen(str)); }
-  tbufWriteStringLen( buf, str, strlen(str) );
+
+void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len) {
+  tbufWriteLength(buf, len);
+  tbufWrite(buf, data, len);
 }
 
-void tbufWriteBinary( SBufferWriter* buf, const void* data, size_t len ) {
+void tbufWriteBool(SBufferWriter* buf, bool data) { tbufWrite(buf, &data, sizeof(data)); }
-  tbufWriteLength( buf, len );
-  tbufWrite( buf, data, len );
-}
 
-void tbufWriteBool( SBufferWriter* buf, bool data ) {
+void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
-  tbufWrite( buf, &data, sizeof(data) );
-}
 
-void tbufWriteBoolAt( SBufferWriter* buf, size_t pos, bool data ) {
+void tbufWriteChar(SBufferWriter* buf, char data) { tbufWrite(buf, &data, sizeof(data)); }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
-}
 
-void tbufWriteChar( SBufferWriter* buf, char data ) {
+void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
-  tbufWrite( buf, &data, sizeof(data) );
-}
 
-void tbufWriteCharAt( SBufferWriter* buf, size_t pos, char data ) {
+void tbufWriteInt8(SBufferWriter* buf, int8_t data) { tbufWrite(buf, &data, sizeof(data)); }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
-}
 
-void tbufWriteInt8( SBufferWriter* buf, int8_t data ) {
+void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
-  tbufWrite( buf, &data, sizeof(data) );
-}
 
-void tbufWriteInt8At( SBufferWriter* buf, size_t pos, int8_t data ) {
+void tbufWriteUint8(SBufferWriter* buf, uint8_t data) { tbufWrite(buf, &data, sizeof(data)); }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
-}
 
-void tbufWriteUint8( SBufferWriter* buf, uint8_t data ) {
+void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
-  tbufWrite( buf, &data, sizeof(data) );
-}
 
-void tbufWriteUint8At( SBufferWriter* buf, size_t pos, uint8_t data ) {
+void tbufWriteInt16(SBufferWriter* buf, int16_t data) {
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
+  if (buf->endian) {
-}
+    data = (int16_t)htons(data);
-
-void tbufWriteInt16( SBufferWriter* buf, int16_t data ) {
-  if( buf->endian ) {
-    data = (int16_t)htons( data );
   }
-  tbufWrite( buf, &data, sizeof(data) );
+  tbufWrite(buf, &data, sizeof(data));
 }
 
-void tbufWriteInt16At( SBufferWriter* buf, size_t pos, int16_t data ) {
+void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = (int16_t)htons( data );
+    data = (int16_t)htons(data);
   }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
+  tbufWriteAt(buf, pos, &data, sizeof(data));
 }
 
-void tbufWriteUint16( SBufferWriter* buf, uint16_t data ) {
+void tbufWriteUint16(SBufferWriter* buf, uint16_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = htons( data );
+    data = htons(data);
   }
-  tbufWrite( buf, &data, sizeof(data) );
+  tbufWrite(buf, &data, sizeof(data));
 }
 
-void tbufWriteUint16At( SBufferWriter* buf, size_t pos, uint16_t data ) {
+void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = htons( data );
+    data = htons(data);
   }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
+  tbufWriteAt(buf, pos, &data, sizeof(data));
 }
 
-void tbufWriteInt32( SBufferWriter* buf, int32_t data ) {
+void tbufWriteInt32(SBufferWriter* buf, int32_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = (int32_t)htonl( data );
+    data = (int32_t)htonl(data);
   }
-  tbufWrite( buf, &data, sizeof(data) );
+  tbufWrite(buf, &data, sizeof(data));
 }
 
-void tbufWriteInt32At( SBufferWriter* buf, size_t pos, int32_t data ) {
+void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = (int32_t)htonl( data );
+    data = (int32_t)htonl(data);
   }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
+  tbufWriteAt(buf, pos, &data, sizeof(data));
 }
 
-void tbufWriteUint32( SBufferWriter* buf, uint32_t data ) {
+void tbufWriteUint32(SBufferWriter* buf, uint32_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = htonl( data );
+    data = htonl(data);
   }
-  tbufWrite( buf, &data, sizeof(data) );
+  tbufWrite(buf, &data, sizeof(data));
 }
 
-void tbufWriteUint32At( SBufferWriter* buf, size_t pos, uint32_t data ) {
+void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = htonl( data );
+    data = htonl(data);
   }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
+  tbufWriteAt(buf, pos, &data, sizeof(data));
 }
 
-void tbufWriteInt64( SBufferWriter* buf, int64_t data ) {
+void tbufWriteInt64(SBufferWriter* buf, int64_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = (int64_t)htobe64( data );
+    data = (int64_t)htobe64(data);
   }
-  tbufWrite( buf, &data, sizeof(data) );
+  tbufWrite(buf, &data, sizeof(data));
 }
 
-void tbufWriteInt64At( SBufferWriter* buf, size_t pos, int64_t data ) {
+void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = (int64_t)htobe64( data );
+    data = (int64_t)htobe64(data);
   }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
+  tbufWriteAt(buf, pos, &data, sizeof(data));
 }
 
-void tbufWriteUint64( SBufferWriter* buf, uint64_t data ) {
+void tbufWriteUint64(SBufferWriter* buf, uint64_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = htobe64( data );
+    data = htobe64(data);
   }
-  tbufWrite( buf, &data, sizeof(data) );
+  tbufWrite(buf, &data, sizeof(data));
 }
 
-void tbufWriteUint64At( SBufferWriter* buf, size_t pos, uint64_t data ) {
+void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data) {
-  if( buf->endian ) {
+  if (buf->endian) {
-    data = htobe64( data );
+    data = htobe64(data);
   }
-  tbufWriteAt( buf, pos, &data, sizeof(data) );
+  tbufWriteAt(buf, pos, &data, sizeof(data));
 }
 
-void tbufWriteFloat( SBufferWriter* buf, float data ) {
+void tbufWriteFloat(SBufferWriter* buf, float data) {
   Un4B _un;
   _un.f = data;
-  if( buf->endian ) {
+  if (buf->endian) {
-    _un.ui = htonl( _un.ui );
+    _un.ui = htonl(_un.ui);
   }
-  tbufWrite( buf, &_un, sizeof(_un) );
+  tbufWrite(buf, &_un, sizeof(_un));
 }
 
-void tbufWriteFloatAt( SBufferWriter* buf, size_t pos, float data ) {
+void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data) {
   Un4B _un;
   _un.f = data;
-  if( buf->endian ) {
+  if (buf->endian) {
-    _un.ui = htonl( _un.ui );
+    _un.ui = htonl(_un.ui);
   }
-  tbufWriteAt( buf, pos, &_un, sizeof(_un) );
+  tbufWriteAt(buf, pos, &_un, sizeof(_un));
 }
 
-void tbufWriteDouble( SBufferWriter* buf, double data ) {
+void tbufWriteDouble(SBufferWriter* buf, double data) {
   Un8B _un;
   _un.d = data;
-  if( buf->endian ) {
+  if (buf->endian) {
-    _un.ull = htobe64( _un.ull );
+    _un.ull = htobe64(_un.ull);
   }
-  tbufWrite( buf, &_un, sizeof(_un) );
+  tbufWrite(buf, &_un, sizeof(_un));
 }
 
-void tbufWriteDoubleAt( SBufferWriter* buf, size_t pos, double data ) {
+void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data) {
   Un8B _un;
   _un.d = data;
-  if( buf->endian ) {
+  if (buf->endian) {
-    _un.ull = htobe64( _un.ull );
+    _un.ull = htobe64(_un.ull);
   }
-  tbufWriteAt( buf, pos, &_un, sizeof(_un) );
+  tbufWriteAt(buf, pos, &_un, sizeof(_un));
 }

tests/script/general/db/basic1.sim

@@ -59,9 +59,29 @@ if $data03 != 0 then
 endi
 
 print =============== show vgroups
-sql use d4
+sql show databases
 
-if $rows == 0 then 
+if $rows != 1 then 
+  return -1
+endi
+
+sql_error use d1
+
+sql use d4
+sql show vgroups
+
+if $rows != 2 then
+  return -1
+endi
+
+print =============== show dnodes
+sql show dnodes
+
+if $data00 != 1 then
+  return -1
+endi
+
+if $data02 != 2 then
   return -1
 endi
 

tests/script/general/table/basic1.sim

@@ -23,7 +23,7 @@ endi
 
 print $data00 $data01 $data02
 
-sql create table st2 (ts timestamp, i float) tags (j bigint)
+sql create table st2 (ts timestamp, i float) tags (j int)
 sql show stables
 if $rows != 2 then 
   return -1
@@ -39,15 +39,14 @@ if $rows != 1 then
   return -1
 endi
 
-print -->
 print $data00 $data01 $data02
 print $data10 $data11 $data12
 
-return
-
 print =============== create child table
 sql create table c1 using st tags(1)
 sql create table c2 using st tags(2)
+
+return 
 sql show tables
 if $rows != 2 then 
   return -1

tests/script/sh/exec.sh

@@ -17,7 +17,7 @@ OS_TYPE=`$UNAME_BIN`
 NODE_NAME=
 EXEC_OPTON=
 CLEAR_OPTION="false"
-while getopts "n:s:u:x:ct" arg
+while getopts "n:s:u:x:cv" arg
 do
   case $arg in
     n)
@@ -29,7 +29,7 @@ do
     c)
       CLEAR_OPTION="clear"
       ;;
-    t)
+    v)
       SHELL_OPTION="true"
       ;;
     u)

tests/script/tmp/dnodes.sim

@@ -2,20 +2,19 @@ system sh/stop_dnodes.sh
 
 
 ############## config parameter  #####################
-$node1 = 192.168.101.174 
+$node1 = 192.168.0.201 
 $node2 = 192.168.0.202
-$node2 = 192.168.0.203
+$node3 = 192.168.0.203
-$node3 = 192.168.0.204
+$node4 = 192.168.0.204
 
-$first = 1
-$num = 5
 $self = $node1
+$num = 25
 
 ###############  deploy firstEp  #####################
 
 $firstEp = $node1 . :7100
 $firstPort = 7100
-if $first == 1 then 
+if $self == $node1 then 
   system sh/deploy.sh -n dnode1 -i 1
   system sh/cfg.sh -n dnode1 -c firstEp -v $firstEp
   system sh/cfg.sh -n dnode1 -c secondEp -v $firstEp
@@ -28,7 +27,7 @@ if $first == 1 then
   $i = 0
   while $i < $num
     $port = $i * 100
-    $port = $port + 8000
+    $port = $port + 8100
     $i = $i + 1
     sql create dnode $node1 port $port
   endw
@@ -36,7 +35,7 @@ if $first == 1 then
   $i = 0
   while $i < $num
     $port = $i * 100
-    $port = $port + 8000
+    $port = $port + 8100
     $i = $i + 1
     sql create dnode $node2 port $port
   endw
@@ -44,7 +43,7 @@ if $first == 1 then
   $i = 0
   while $i < $num
     $port = $i * 100
-    $port = $port + 8000
+    $port = $port + 8100
     $i = $i + 1
     sql create dnode $node3 port $port
   endw
@@ -52,7 +51,7 @@ if $first == 1 then
   $i = 0
   while $i < $num
     $port = $i * 100
-    $port = $port + 8000
+    $port = $port + 8100
     $i = $i + 1
     sql create dnode $node4 port $port
   endw
@@ -64,7 +63,7 @@ $i = 0
 while $i < $num
   $index = $i + 80
   $port = $i * 100
-  $port = $port + 8000
+  $port = $port + 8100
   $dnodename = dnode . $index
   $i = $i + 1 
 
@@ -74,5 +73,5 @@ while $i < $num
   system sh/cfg.sh -n $dnodename -c fqdn -v $self
   system sh/cfg.sh -n $dnodename -c serverPort -v $port
 
-  #system sh/exec.sh -n $dnodename -s start
+  system sh/exec.sh -n $dnodename -s start
 endw