Merge pull request #11617 from taosdata/feature/vnode_refact1

refactor: vnode

include/common/tmsg.h

@@ -1432,7 +1432,6 @@ typedef struct {
 
 typedef struct SVCreateTbReq {
   int64_t  ver;  // use a general definition
-  char*    dbFName;
   char*    name;
   uint32_t ttl;
   uint32_t keep;

source/common/src/tmsg.c

@@ -398,7 +398,6 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
   int32_t tlen = 0;
 
   tlen += taosEncodeFixedI64(buf, pReq->ver);
-  tlen += taosEncodeString(buf, pReq->dbFName);
   tlen += taosEncodeString(buf, pReq->name);
   tlen += taosEncodeFixedU32(buf, pReq->ttl);
   tlen += taosEncodeFixedU32(buf, pReq->keep);
@@ -467,7 +466,6 @@ int32_t tSerializeSVCreateTbReq(void **buf, SVCreateTbReq *pReq) {
 
 void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
   buf = taosDecodeFixedI64(buf, &(pReq->ver));
-  buf = taosDecodeString(buf, &(pReq->dbFName));
   buf = taosDecodeString(buf, &(pReq->name));
   buf = taosDecodeFixedU32(buf, &(pReq->ttl));
   buf = taosDecodeFixedU32(buf, &(pReq->keep));

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

@@ -82,13 +82,13 @@ int32_t vmProcessGetVnodeLoadsReq(SMgmtWrapper *pWrapper, SNodeMsg *pReq) {
 }
 
 static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
+  memcpy(pCfg, &vnodeCfgDefault, sizeof(SVnodeCfg));
+
   pCfg->vgId = pCreate->vgId;
+  strcpy(pCfg->dbname, pCreate->db);
   pCfg->wsize = pCreate->cacheBlockSize * 1024 * 1024;
   pCfg->ssize = 1024;
   pCfg->lsize = 1024 * 1024;
-  pCfg->isHeapAllocator = true;
-  pCfg->ttl = 4;
-  pCfg->keep = pCreate->daysToKeep0;
   pCfg->streamMode = pCreate->streamMode;
   pCfg->isWeak = true;
   pCfg->tsdbCfg.keep2 = pCreate->daysToKeep0;
@@ -96,12 +96,6 @@ static void vmGenerateVnodeCfg(SCreateVnodeReq *pCreate, SVnodeCfg *pCfg) {
   pCfg->tsdbCfg.keep1 = pCreate->daysToKeep0;
   pCfg->tsdbCfg.lruCacheSize = pCreate->cacheBlockSize;
   pCfg->tsdbCfg.retentions = pCreate->pRetensions;
-  pCfg->walCfg.level = TAOS_WAL_WRITE;
-  pCfg->walCfg.fsyncPeriod = 0;
-  pCfg->walCfg.retentionPeriod = 0;
-  pCfg->walCfg.retentionSize = 0;
-  pCfg->walCfg.rollPeriod = 0;
-  pCfg->walCfg.segSize = 0;
   pCfg->walCfg.vgId = pCreate->vgId;
   pCfg->hashBegin = pCreate->hashBegin;
   pCfg->hashEnd = pCreate->hashEnd;

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

@@ -349,7 +349,6 @@ static void *mndBuildVCreateStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pSt
 
   SVCreateTbReq req = {0};
   req.ver = 0;
-  req.dbFName = dbFName;
   req.name = (char *)tNameGetTableName(&name);
   req.ttl = 0;
   req.keep = 0;

source/dnode/vnode/inc/vnode.h

@@ -40,6 +40,8 @@ typedef struct SVnode    SVnode;
 typedef struct STsdbCfg  STsdbCfg;  // todo: remove
 typedef struct SVnodeCfg SVnodeCfg;
 
+extern const SVnodeCfg vnodeCfgDefault;
+
 int     vnodeInit(int nthreads);
 void    vnodeCleanup();
 int     vnodeCreate(const char *path, SVnodeCfg *pCfg, STfs *pTfs);
@@ -133,6 +135,7 @@ struct STsdbCfg {
 
 struct SVnodeCfg {
   int32_t  vgId;
+  char     dbname[TSDB_DB_NAME_LEN];
   uint64_t dbId;
   uint64_t wsize;
   uint64_t ssize;

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

@@ -31,6 +31,8 @@ extern "C" {
 // clang-format on
 
 // vnodeCfg ====================
+int vnodeEncodeConfig(const void* pObj, SJson* pJson);
+int vnodeDecodeConfig(const SJson* pJson, void* pObj);
 
 // vnodeModule ====================
 int vnodeScheduleTask(int (*execute)(void*), void* arg);

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

@@ -16,13 +16,113 @@
 #include "vnodeInt.h"
 
 const SVnodeCfg vnodeCfgDefault = {
-    .wsize = 96 * 1024 * 1024, .ssize = 1 * 1024 * 1024, .lsize = 1024, .walCfg = {.level = TAOS_WAL_WRITE}};
+    .vgId = -1,
+    .dbname = "",
+    .dbId = 0,
+    .wsize = 96 * 1024 * 1024,
+    .ssize = 1 * 1024 * 1024,
+    .lsize = 1024,
+    .isHeapAllocator = false,
+    .ttl = 0,
+    .keep = 0,
+    .streamMode = 0,
+    .isWeak = 0,
+    .tsdbCfg = {.precision = TWO_STAGE_COMP,
+                .update = 0,
+                .compression = 2,
+                .days = 10,
+                .minRows = 100,
+                .maxRows = 4096,
+                .keep2 = 3650,
+                .keep0 = 3650,
+                .keep1 = 3650},
+    .walCfg =
+        {.vgId = -1, .fsyncPeriod = 0, .retentionPeriod = 0, .rollPeriod = 0, .segSize = 0, .level = TAOS_WAL_WRITE},
+    .hashBegin = 0,
+    .hashEnd = 0,
+    .hashMethod = 0};
 
 int vnodeCheckCfg(const SVnodeCfg *pCfg) {
   // TODO
   return 0;
 }
 
+int vnodeEncodeConfig(const void *pObj, SJson *pJson) {
+  const SVnodeCfg *pCfg = (SVnodeCfg *)pObj;
+
+  if (tjsonAddIntegerToObject(pJson, "vgId", pCfg->vgId) < 0) return -1;
+  if (tjsonAddStringToObject(pJson, "dbname", pCfg->dbname) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "dbId", pCfg->dbId) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "wsize", pCfg->wsize) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "ssize", pCfg->ssize) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "lsize", pCfg->lsize) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "isHeap", pCfg->isHeapAllocator) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "ttl", pCfg->ttl) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "keep", pCfg->keep) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "streamMode", pCfg->streamMode) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "isWeak", pCfg->isWeak) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "precision", pCfg->tsdbCfg.precision) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "update", pCfg->tsdbCfg.update) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "compression", pCfg->tsdbCfg.compression) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "daysPerFile", pCfg->tsdbCfg.days) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "minRows", pCfg->tsdbCfg.minRows) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "maxRows", pCfg->tsdbCfg.maxRows) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "keep0", pCfg->tsdbCfg.keep0) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "keep1", pCfg->tsdbCfg.keep1) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "keep2", pCfg->tsdbCfg.keep2) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "lruCacheSize", pCfg->tsdbCfg.lruCacheSize) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "wal.vgId", pCfg->walCfg.vgId) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "wal.fsyncPeriod", pCfg->walCfg.fsyncPeriod) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "wal.retentionPeriod", pCfg->walCfg.retentionPeriod) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "wal.rollPeriod", pCfg->walCfg.rollPeriod) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "wal.retentionSize", pCfg->walCfg.retentionSize) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "wal.segSize", pCfg->walCfg.segSize) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "wal.level", pCfg->walCfg.level) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "hashBegin", pCfg->hashBegin) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "hashEnd", pCfg->hashEnd) < 0) return -1;
+  if (tjsonAddIntegerToObject(pJson, "hashMethod", pCfg->hashMethod) < 0) return -1;
+
+  return 0;
+}
+
+int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
+  SVnodeCfg *pCfg = (SVnodeCfg *)pObj;
+
+  if (tjsonGetNumberValue(pJson, "vgId", pCfg->vgId) < 0) return -1;
+  if (tjsonGetStringValue(pJson, "dbname", pCfg->dbname) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "dbId", pCfg->dbId) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "wsize", pCfg->wsize) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "ssize", pCfg->ssize) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "lsize", pCfg->lsize) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "isHeap", pCfg->isHeapAllocator) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "ttl", pCfg->ttl) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "keep", pCfg->keep) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "streamMode", pCfg->streamMode) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "isWeak", pCfg->isWeak) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "precision", pCfg->tsdbCfg.precision) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "update", pCfg->tsdbCfg.update) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "compression", pCfg->tsdbCfg.compression) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "daysPerFile", pCfg->tsdbCfg.days) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "minRows", pCfg->tsdbCfg.minRows) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "maxRows", pCfg->tsdbCfg.maxRows) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "keep0", pCfg->tsdbCfg.keep0) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "keep1", pCfg->tsdbCfg.keep1) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "keep2", pCfg->tsdbCfg.keep2) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "lruCacheSize", pCfg->tsdbCfg.lruCacheSize) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "wal.vgId", pCfg->walCfg.vgId) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "wal.fsyncPeriod", pCfg->walCfg.fsyncPeriod) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "wal.retentionPeriod", pCfg->walCfg.retentionPeriod) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "wal.rollPeriod", pCfg->walCfg.rollPeriod) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "wal.retentionSize", pCfg->walCfg.retentionSize) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "wal.segSize", pCfg->walCfg.segSize) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "wal.level", pCfg->walCfg.level) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "hashBegin", pCfg->hashBegin) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "hashEnd", pCfg->hashEnd) < 0) return -1;
+  if (tjsonGetNumberValue(pJson, "hashMethod", pCfg->hashMethod) < 0) return -1;
+
+  return 0;
+}
+
 int vnodeValidateTableHash(SVnodeCfg *pVnodeOptions, char *tableFName) {
   uint32_t hashValue = 0;
 

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

@@ -181,80 +181,6 @@ static int vnodeEndCommit(SVnode *pVnode) {
 
 static FORCE_INLINE void vnodeWaitCommit(SVnode *pVnode) { tsem_wait(&pVnode->canCommit); }
 
-static int vnodeEncodeConfig(const void *pObj, SJson *pJson) {
-  const SVnodeCfg *pCfg = (SVnodeCfg *)pObj;
-
-  if (tjsonAddIntegerToObject(pJson, "vgId", pCfg->vgId) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "dbId", pCfg->dbId) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "wsize", pCfg->wsize) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "ssize", pCfg->ssize) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "lsize", pCfg->lsize) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "isHeap", pCfg->isHeapAllocator) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "ttl", pCfg->ttl) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "keep", pCfg->keep) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "streamMode", pCfg->streamMode) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "isWeak", pCfg->isWeak) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "precision", pCfg->tsdbCfg.precision) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "update", pCfg->tsdbCfg.update) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "compression", pCfg->tsdbCfg.compression) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "daysPerFile", pCfg->tsdbCfg.days) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "minRows", pCfg->tsdbCfg.minRows) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "maxRows", pCfg->tsdbCfg.maxRows) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "keep0", pCfg->tsdbCfg.keep0) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "keep1", pCfg->tsdbCfg.keep1) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "keep2", pCfg->tsdbCfg.keep2) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "lruCacheSize", pCfg->tsdbCfg.lruCacheSize) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "wal.vgId", pCfg->walCfg.vgId) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "wal.fsyncPeriod", pCfg->walCfg.fsyncPeriod) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "wal.retentionPeriod", pCfg->walCfg.retentionPeriod) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "wal.rollPeriod", pCfg->walCfg.rollPeriod) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "wal.retentionSize", pCfg->walCfg.retentionSize) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "wal.segSize", pCfg->walCfg.segSize) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "wal.level", pCfg->walCfg.level) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "hashBegin", pCfg->hashBegin) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "hashEnd", pCfg->hashEnd) < 0) return -1;
-  if (tjsonAddIntegerToObject(pJson, "hashMethod", pCfg->hashMethod) < 0) return -1;
-
-  return 0;
-}
-
-static int vnodeDecodeConfig(const SJson *pJson, void *pObj) {
-  SVnodeCfg *pCfg = (SVnodeCfg *)pObj;
-
-  if (tjsonGetNumberValue(pJson, "vgId", pCfg->vgId) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "dbId", pCfg->dbId) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "wsize", pCfg->wsize) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "ssize", pCfg->ssize) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "lsize", pCfg->lsize) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "isHeap", pCfg->isHeapAllocator) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "ttl", pCfg->ttl) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "keep", pCfg->keep) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "streamMode", pCfg->streamMode) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "isWeak", pCfg->isWeak) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "precision", pCfg->tsdbCfg.precision) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "update", pCfg->tsdbCfg.update) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "compression", pCfg->tsdbCfg.compression) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "daysPerFile", pCfg->tsdbCfg.days) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "minRows", pCfg->tsdbCfg.minRows) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "maxRows", pCfg->tsdbCfg.maxRows) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "keep0", pCfg->tsdbCfg.keep0) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "keep1", pCfg->tsdbCfg.keep1) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "keep2", pCfg->tsdbCfg.keep2) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "lruCacheSize", pCfg->tsdbCfg.lruCacheSize) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "wal.vgId", pCfg->walCfg.vgId) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "wal.fsyncPeriod", pCfg->walCfg.fsyncPeriod) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "wal.retentionPeriod", pCfg->walCfg.retentionPeriod) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "wal.rollPeriod", pCfg->walCfg.rollPeriod) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "wal.retentionSize", pCfg->walCfg.retentionSize) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "wal.segSize", pCfg->walCfg.segSize) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "wal.level", pCfg->walCfg.level) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "hashBegin", pCfg->hashBegin) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "hashEnd", pCfg->hashEnd) < 0) return -1;
-  if (tjsonGetNumberValue(pJson, "hashMethod", pCfg->hashMethod) < 0) return -1;
-
-  return 0;
-}
-
 static int vnodeEncodeState(const void *pObj, SJson *pJson) {
   const SVState *pState = (SVState *)pObj;
 

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

@@ -217,7 +217,6 @@ static int vnodeProcessCreateStbReq(SVnode *pVnode, void *pReq) {
     taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam->pFuncIds);
     taosMemoryFree(vCreateTbReq.stbCfg.pRSmaParam);
   }
-  taosMemoryFree(vCreateTbReq.dbFName);
   taosMemoryFree(vCreateTbReq.name);
 
   return 0;
@@ -233,7 +232,7 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
 
     char      tableFName[TSDB_TABLE_FNAME_LEN];
     SMsgHead *pHead = (SMsgHead *)pMsg->pCont;
-    sprintf(tableFName, "%s.%s", pCreateTbReq->dbFName, pCreateTbReq->name);
+    sprintf(tableFName, "%s.%s", pVnode->config.dbname, pCreateTbReq->name);
 
     int32_t code = vnodeValidateTableHash(&pVnode->config, tableFName);
     if (code) {
@@ -249,7 +248,6 @@ static int vnodeProcessCreateTbReq(SVnode *pVnode, SRpcMsg *pMsg, void *pReq, SR
     }
     // TODO: to encapsule a free API
     taosMemoryFree(pCreateTbReq->name);
-    taosMemoryFree(pCreateTbReq->dbFName);
     if (pCreateTbReq->type == TD_SUPER_TABLE) {
       taosMemoryFree(pCreateTbReq->stbCfg.pSchema);
       taosMemoryFree(pCreateTbReq->stbCfg.pTagSchema);
@@ -298,7 +296,6 @@ static int vnodeProcessAlterStbReq(SVnode *pVnode, void *pReq) {
     taosMemoryFree(vAlterTbReq.stbCfg.pRSmaParam->pFuncIds);
     taosMemoryFree(vAlterTbReq.stbCfg.pRSmaParam);
   }
-  taosMemoryFree(vAlterTbReq.dbFName);
   taosMemoryFree(vAlterTbReq.name);
   return 0;
 }

source/libs/parser/src/parInsert.c

@@ -15,57 +15,57 @@
 
 #include "parInsertData.h"
 #include "parInt.h"
-#include "parUtil.h"
 #include "parToken.h"
+#include "parUtil.h"
 #include "tglobal.h"
 #include "ttime.h"
 #include "ttypes.h"
 
-#define NEXT_TOKEN(pSql, sToken) \
-  do { \
-    int32_t index = 0; \
+#define NEXT_TOKEN(pSql, sToken)                \
+  do {                                          \
+    int32_t index = 0;                          \
     sToken = tStrGetToken(pSql, &index, false); \
-    pSql += index; \
+    pSql += index;                              \
   } while (0)
 
-#define NEXT_TOKEN_WITH_PREV(pSql, sToken) \
-  do { \
-    int32_t index = 0; \
+#define NEXT_TOKEN_WITH_PREV(pSql, sToken)     \
+  do {                                         \
+    int32_t index = 0;                         \
     sToken = tStrGetToken(pSql, &index, true); \
-    pSql += index; \
+    pSql += index;                             \
   } while (0)
 
 #define NEXT_TOKEN_KEEP_SQL(pSql, sToken, index) \
-  do { \
-    sToken = tStrGetToken(pSql, &index, false); \
+  do {                                           \
+    sToken = tStrGetToken(pSql, &index, false);  \
   } while (0)
 
-#define CHECK_CODE(expr) \
-  do { \
-    int32_t code = expr; \
+#define CHECK_CODE(expr)             \
+  do {                               \
+    int32_t code = expr;             \
     if (TSDB_CODE_SUCCESS != code) { \
-      return code; \
-    } \
+      return code;                   \
+    }                                \
   } while (0)
 
 typedef struct SInsertParseContext {
-  SParseContext* pComCxt;       // input
-  char          *pSql;          // input
-  SMsgBuf        msg;           // input
-  STableMeta* pTableMeta;       // each table
-  SParsedDataColInfo tags;      // each table
-  SKVRowBuilder tagsBuilder;    // each table
-  SVCreateTbReq createTblReq;   // each table
-  SHashObj* pVgroupsHashObj;    // global
-  SHashObj* pTableBlockHashObj; // global
-  SHashObj* pSubTableHashObj;   // global
-  SArray* pTableDataBlocks;     // global
-  SArray* pVgDataBlocks;        // global
-  int32_t totalNum;
+  SParseContext*     pComCxt;             // input
+  char*              pSql;                // input
+  SMsgBuf            msg;                 // input
+  STableMeta*        pTableMeta;          // each table
+  SParsedDataColInfo tags;                // each table
+  SKVRowBuilder      tagsBuilder;         // each table
+  SVCreateTbReq      createTblReq;        // each table
+  SHashObj*          pVgroupsHashObj;     // global
+  SHashObj*          pTableBlockHashObj;  // global
+  SHashObj*          pSubTableHashObj;    // global
+  SArray*            pTableDataBlocks;    // global
+  SArray*            pVgDataBlocks;       // global
+  int32_t            totalNum;
   SVnodeModifOpStmt* pOutput;
 } SInsertParseContext;
 
-typedef int32_t (*_row_append_fn_t)(SMsgBuf* pMsgBuf, const void *value, int32_t len, void *param);
+typedef int32_t (*_row_append_fn_t)(SMsgBuf* pMsgBuf, const void* value, int32_t len, void* param);
 
 static uint8_t TRUE_VALUE = (uint8_t)TSDB_TRUE;
 static uint8_t FALSE_VALUE = (uint8_t)TSDB_FALSE;
@@ -151,7 +151,7 @@ static int32_t buildName(SInsertParseContext* pCxt, SToken* pStname, char* fullD
   }
 
   char* p = strnchr(pStname->z, TS_PATH_DELIMITER[0], pStname->n, false);
-  if (NULL != p) { // db.table
+  if (NULL != p) {  // db.table
     int32_t n = sprintf(fullDbName, "%d.", pCxt->pComCxt->acctId);
     strncpy(fullDbName + n, pStname->z, p - pStname->z);
     strncpy(tableName, p + 1, pStname->n - (p - pStname->z) - 1);
@@ -168,14 +168,14 @@ static int32_t createSName(SName* pName, SToken* pTableName, SParseContext* pPar
   const char* msg2 = "invalid database name";
   const char* msg3 = "db is not specified";
 
-  int32_t  code = TSDB_CODE_SUCCESS;
-  char* p  = strnchr(pTableName->z, TS_PATH_DELIMITER[0], pTableName->n, true);
+  int32_t code = TSDB_CODE_SUCCESS;
+  char*   p = strnchr(pTableName->z, TS_PATH_DELIMITER[0], pTableName->n, true);
 
-  if (p != NULL) { // db has been specified in sql string so we ignore current db path
+  if (p != NULL) {  // db has been specified in sql string so we ignore current db path
     assert(*p == TS_PATH_DELIMITER[0]);
 
     int32_t dbLen = p - pTableName->z;
-    char name[TSDB_DB_FNAME_LEN] = {0};
+    char    name[TSDB_DB_FNAME_LEN] = {0};
     strncpy(name, pTableName->z, dbLen);
     dbLen = strdequote(name);
 
@@ -185,9 +185,9 @@ static int32_t createSName(SName* pName, SToken* pTableName, SParseContext* pPar
     }
 
     int32_t tbLen = pTableName->n - dbLen - 1;
-    char tbname[TSDB_TABLE_FNAME_LEN] = {0};
+    char    tbname[TSDB_TABLE_FNAME_LEN] = {0};
     strncpy(tbname, p + 1, tbLen);
-    /*tbLen = */strdequote(tbname);
+    /*tbLen = */ strdequote(tbname);
 
     code = tNameFromString(pName, tbname, T_NAME_TABLE);
     if (code != 0) {
@@ -225,28 +225,26 @@ static int32_t createSName(SName* pName, SToken* pTableName, SParseContext* pPar
 
 static int32_t getTableMetaImpl(SInsertParseContext* pCxt, SToken* pTname, bool isStb) {
   SParseContext* pBasicCtx = pCxt->pComCxt;
-  SName name = {0};
-  createSName(&name, pTname, pBasicCtx, &pCxt->msg);  
+  SName          name = {0};
+  createSName(&name, pTname, pBasicCtx, &pCxt->msg);
   if (isStb) {
-    CHECK_CODE(catalogGetSTableMeta(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name, &pCxt->pTableMeta));
+    CHECK_CODE(catalogGetSTableMeta(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name,
+                                    &pCxt->pTableMeta));
   } else {
-    CHECK_CODE(catalogGetTableMeta(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name, &pCxt->pTableMeta));
+    CHECK_CODE(catalogGetTableMeta(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name,
+                                   &pCxt->pTableMeta));
   }
   SVgroupInfo vg;
-  CHECK_CODE(catalogGetTableHashVgroup(pBasicCtx->pCatalog, pBasicCtx->pTransporter, &pBasicCtx->mgmtEpSet, &name, &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;
-}
 
-static int32_t getTableMeta(SInsertParseContext* pCxt, SToken* pTname) {
-  return getTableMetaImpl(pCxt, pTname, false);
+  return TSDB_CODE_SUCCESS;
 }
 
-static int32_t getSTableMeta(SInsertParseContext* pCxt, SToken* pTname) {
-  return getTableMetaImpl(pCxt, pTname, true);
-}
+static int32_t getTableMeta(SInsertParseContext* pCxt, SToken* pTname) { return getTableMetaImpl(pCxt, pTname, false); }
 
+static int32_t getSTableMeta(SInsertParseContext* pCxt, SToken* pTname) { return getTableMetaImpl(pCxt, pTname, true); }
 
 static int32_t findCol(SToken* pColname, int32_t start, int32_t end, SSchema* pSchema) {
   while (start < end) {
@@ -259,24 +257,24 @@ static int32_t findCol(SToken* pColname, int32_t start, int32_t end, SSchema* pS
 }
 
 static void buildMsgHeader(STableDataBlocks* src, SVgDataBlocks* blocks) {
-    SSubmitReq* submit = (SSubmitReq*)blocks->pData;
-    submit->header.vgId    = htonl(blocks->vg.vgId);
-    submit->header.contLen = htonl(blocks->size);
-    submit->length         = submit->header.contLen;
-    submit->numOfBlocks    = htonl(blocks->numOfTables);
-    SSubmitBlk* blk = (SSubmitBlk*)(submit + 1);
-    int32_t numOfBlocks = blocks->numOfTables;
-    while (numOfBlocks--) {
-      int32_t dataLen = blk->dataLen;
-      blk->uid = htobe64(blk->uid);
-      blk->suid = htobe64(blk->suid);
-      blk->padding = htonl(blk->padding);
-      blk->sversion = htonl(blk->sversion);
-      blk->dataLen = htonl(blk->dataLen);
-      blk->schemaLen = htonl(blk->schemaLen);
-      blk->numOfRows = htons(blk->numOfRows);
-      blk = (SSubmitBlk*)(blk->data + dataLen);
-    }
+  SSubmitReq* submit = (SSubmitReq*)blocks->pData;
+  submit->header.vgId = htonl(blocks->vg.vgId);
+  submit->header.contLen = htonl(blocks->size);
+  submit->length = submit->header.contLen;
+  submit->numOfBlocks = htonl(blocks->numOfTables);
+  SSubmitBlk* blk = (SSubmitBlk*)(submit + 1);
+  int32_t     numOfBlocks = blocks->numOfTables;
+  while (numOfBlocks--) {
+    int32_t dataLen = blk->dataLen;
+    blk->uid = htobe64(blk->uid);
+    blk->suid = htobe64(blk->suid);
+    blk->padding = htonl(blk->padding);
+    blk->sversion = htonl(blk->sversion);
+    blk->dataLen = htonl(blk->dataLen);
+    blk->schemaLen = htonl(blk->schemaLen);
+    blk->numOfRows = htons(blk->numOfRows);
+    blk = (SSubmitBlk*)(blk->data + dataLen);
+  }
 }
 
 static int32_t buildOutput(SInsertParseContext* pCxt) {
@@ -287,7 +285,7 @@ static int32_t buildOutput(SInsertParseContext* pCxt) {
   }
   for (size_t i = 0; i < numOfVg; ++i) {
     STableDataBlocks* src = taosArrayGetP(pCxt->pVgDataBlocks, i);
-    SVgDataBlocks* dst = taosMemoryCalloc(1, sizeof(SVgDataBlocks));
+    SVgDataBlocks*    dst = taosMemoryCalloc(1, sizeof(SVgDataBlocks));
     if (NULL == dst) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
@@ -301,13 +299,13 @@ static int32_t buildOutput(SInsertParseContext* pCxt) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t checkTimestamp(STableDataBlocks *pDataBlocks, const char *start) {
+static int32_t checkTimestamp(STableDataBlocks* pDataBlocks, const char* start) {
   // once the data block is disordered, we do NOT keep previous timestamp any more
   if (!pDataBlocks->ordered) {
     return TSDB_CODE_SUCCESS;
   }
 
-  TSKEY k = *(TSKEY *)start;
+  TSKEY k = *(TSKEY*)start;
   if (k <= pDataBlocks->prevTS) {
     pDataBlocks->ordered = false;
   }
@@ -316,12 +314,12 @@ static int32_t checkTimestamp(STableDataBlocks *pDataBlocks, const char *start)
   return TSDB_CODE_SUCCESS;
 }
 
-static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time, SMsgBuf* pMsgBuf) {
-  int32_t   index = 0;
-  SToken    sToken;
-  int64_t   interval;
-  int64_t   ts = 0;
-  char* pTokenEnd = *end;
+static int parseTime(char** end, SToken* pToken, int16_t timePrec, int64_t* time, SMsgBuf* pMsgBuf) {
+  int32_t index = 0;
+  SToken  sToken;
+  int64_t interval;
+  int64_t ts = 0;
+  char*   pTokenEnd = *end;
 
   if (pToken->type == TK_NOW) {
     ts = taosGetTimestamp(timePrec);
@@ -330,7 +328,7 @@ static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time
   } else if (pToken->type == TK_NK_INTEGER) {
     bool isSigned = false;
     toInteger(pToken->z, pToken->n, 10, &ts, &isSigned);
-  } else { // parse the RFC-3339/ISO-8601 timestamp format string
+  } 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);
     }
@@ -340,7 +338,7 @@ static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time
 
   for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
     if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
-    if (pToken->z[k] == '(' && pToken->z[k + 1] == ')') { //for insert NOW()/TODAY()
+    if (pToken->z[k] == '(' && pToken->z[k + 1] == ')') {  // for insert NOW()/TODAY()
       *end = pTokenEnd = &pToken->z[k + 2];
       k++;
       continue;
@@ -391,8 +389,10 @@ static int parseTime(char **end, SToken *pToken, int16_t timePrec, int64_t *time
 }
 
 static FORCE_INLINE int32_t checkAndTrimValue(SToken* pToken, uint32_t type, char* tmpTokenBuf, SMsgBuf* pMsgBuf) {
-  if ((pToken->type != TK_NOW && pToken->type != TK_TODAY && pToken->type != TK_NK_INTEGER && pToken->type != TK_NK_STRING && pToken->type != TK_NK_FLOAT &&
-       pToken->type != TK_NK_BOOL && pToken->type != TK_NULL && pToken->type != TK_NK_HEX && pToken->type != TK_NK_OCT && pToken->type != TK_NK_BIN) ||
+  if ((pToken->type != TK_NOW && pToken->type != TK_TODAY && pToken->type != TK_NK_INTEGER &&
+       pToken->type != TK_NK_STRING && pToken->type != TK_NK_FLOAT && pToken->type != TK_NK_BOOL &&
+       pToken->type != TK_NULL && pToken->type != TK_NK_HEX && pToken->type != TK_NK_OCT &&
+       pToken->type != TK_NK_BIN) ||
       (pToken->n == 0) || (pToken->type == TK_NK_RP)) {
     return buildSyntaxErrMsg(pMsgBuf, "invalid data or symbol", pToken->z);
   }
@@ -408,7 +408,7 @@ static FORCE_INLINE int32_t checkAndTrimValue(SToken* pToken, uint32_t type, cha
     }
 
     // delete escape character: \\, \', \"
-    char delim = pToken->z[0];
+    char    delim = pToken->z[0];
     int32_t cnt = 0;
     int32_t j = 0;
     for (uint32_t k = 1; k < pToken->n - 1; ++k) {
@@ -431,12 +431,12 @@ static FORCE_INLINE int32_t checkAndTrimValue(SToken* pToken, uint32_t type, cha
   return TSDB_CODE_SUCCESS;
 }
 
-static bool isNullStr(SToken *pToken) {
+static bool isNullStr(SToken* pToken) {
   return (pToken->type == TK_NULL) || ((pToken->type == TK_NK_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) {
+static FORCE_INLINE int32_t toDouble(SToken* pToken, double* value, char** endPtr) {
   errno = 0;
   *value = strtold(pToken->z, endPtr);
 
@@ -448,9 +448,10 @@ static FORCE_INLINE int32_t toDouble(SToken *pToken, double *value, char **endPt
   return pToken->type;
 }
 
-static int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int16_t timePrec, char* tmpTokenBuf, _row_append_fn_t func, void* param, SMsgBuf* pMsgBuf) {
+static 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;
+  char*   endptr = NULL;
   bool    isSigned = false;
 
   int32_t code = checkAndTrimValue(pToken, pSchema->type, tmpTokenBuf, pMsgBuf);
@@ -497,7 +498,7 @@ static int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int
       return func(pMsgBuf, &tmpVal, pSchema->bytes, param);
     }
 
-    case TSDB_DATA_TYPE_UTINYINT:{
+    case TSDB_DATA_TYPE_UTINYINT: {
       if (TSDB_CODE_SUCCESS != toInteger(pToken->z, pToken->n, 10, &iv, &isSigned)) {
         return buildSyntaxErrMsg(pMsgBuf, "invalid unsigned tinyint data", pToken->z);
       } else if (!IS_VALID_UTINYINT(iv)) {
@@ -571,7 +572,8 @@ static int32_t parseValueToken(char** end, SToken* pToken, SSchema* pSchema, int
       if (TK_NK_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)) {
+      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;
@@ -657,15 +659,15 @@ static FORCE_INLINE int32_t MemRowAppend(SMsgBuf* pMsgBuf, const void* value, in
 static int32_t parseBoundColumns(SInsertParseContext* pCxt, SParsedDataColInfo* pColList, SSchema* pSchema) {
   col_id_t nCols = pColList->numOfCols;
 
-  pColList->numOfBound = 0; 
+  pColList->numOfBound = 0;
   pColList->boundNullLen = 0;
   memset(pColList->boundColumns, 0, sizeof(col_id_t) * nCols);
   for (col_id_t i = 0; i < nCols; ++i) {
     pColList->cols[i].valStat = VAL_STAT_NONE;
   }
 
-  SToken sToken;
-  bool    isOrdered = true;
+  SToken   sToken;
+  bool     isOrdered = true;
   col_id_t lastColIdx = -1;  // last column found
   while (1) {
     NEXT_TOKEN(pCxt->pSql, sToken);
@@ -729,13 +731,13 @@ static int32_t parseBoundColumns(SInsertParseContext* pCxt, SParsedDataColInfo*
 }
 
 typedef struct SKvParam {
-  SKVRowBuilder *builder;
-  SSchema       *schema;
+  SKVRowBuilder* builder;
+  SSchema*       schema;
   char           buf[TSDB_MAX_TAGS_LEN];
 } SKvParam;
 
-static int32_t KvRowAppend(SMsgBuf* pMsgBuf, const void *value, int32_t len, void *param) {
-  SKvParam* pa = (SKvParam*) param;
+static int32_t KvRowAppend(SMsgBuf* pMsgBuf, const void* value, int32_t len, void* param) {
+  SKvParam* pa = (SKvParam*)param;
 
   int8_t  type = pa->schema->type;
   int16_t colId = pa->schema->colId;
@@ -749,7 +751,8 @@ static int32_t KvRowAppend(SMsgBuf* pMsgBuf, const void *value, int32_t len, voi
     if (!taosMbsToUcs4(value, len, (TdUcs4*)varDataVal(pa->buf), pa->schema->bytes - VARSTR_HEADER_SIZE, &output)) {
       char buf[512] = {0};
       snprintf(buf, tListLen(buf), "%s", strerror(errno));
-      return buildSyntaxErrMsg(pMsgBuf, buf, value);;
+      return buildSyntaxErrMsg(pMsgBuf, buf, value);
+      ;
     }
 
     varDataSetLen(pa->buf, output);
@@ -765,7 +768,6 @@ static int32_t buildCreateTbReq(SInsertParseContext* pCxt, const SName* pName, S
   char dbFName[TSDB_DB_FNAME_LEN] = {0};
   tNameGetFullDbName(pName, dbFName);
   pCxt->createTblReq.type = TD_CHILD_TABLE;
-  pCxt->createTblReq.dbFName = strdup(dbFName);
   pCxt->createTblReq.name = strdup(pName->tname);
   pCxt->createTblReq.ctbCfg.suid = pCxt->pTableMeta->suid;
   pCxt->createTblReq.ctbCfg.pTag = row;
@@ -780,13 +782,14 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
   }
 
   SKvParam param = {.builder = &pCxt->tagsBuilder};
-  SToken sToken;
-  char tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0};  // used for deleting Escape character: \\, \', \"
+  SToken   sToken;
+  char     tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0};  // used for deleting Escape character: \\, \', \"
   for (int i = 0; i < pCxt->tags.numOfBound; ++i) {
     NEXT_TOKEN_WITH_PREV(pCxt->pSql, sToken);
-    SSchema* pTagSchema = &pSchema[pCxt->tags.boundColumns[i] - 1]; // colId starts with 1
+    SSchema* pTagSchema = &pSchema[pCxt->tags.boundColumns[i] - 1];  // colId starts with 1
     param.schema = pTagSchema;
-    CHECK_CODE(parseValueToken(&pCxt->pSql, &sToken, pTagSchema, precision, tmpTokenBuf, KvRowAppend, &param, &pCxt->msg));
+    CHECK_CODE(
+        parseValueToken(&pCxt->pSql, &sToken, pTagSchema, precision, tmpTokenBuf, KvRowAppend, &param, &pCxt->msg));
   }
 
   SKVRow row = tdGetKVRowFromBuilder(&pCxt->tagsBuilder);
@@ -822,7 +825,7 @@ static int32_t parseUsingClause(SInsertParseContext* pCxt, SToken* pTbnameToken)
   createSName(&name, pTbnameToken, pCxt->pComCxt, &pCxt->msg);
   char tbFName[TSDB_TABLE_FNAME_LEN];
   tNameExtractFullName(&name, tbFName);
-  int32_t len = strlen(tbFName);
+  int32_t      len = strlen(tbFName);
   STableMeta** pMeta = taosHashGet(pCxt->pSubTableHashObj, tbFName, len);
   if (NULL != pMeta) {
     return cloneTableMeta(*pMeta, &pCxt->pTableMeta);
@@ -864,17 +867,18 @@ static int32_t parseUsingClause(SInsertParseContext* pCxt, SToken* pTbnameToken)
   return TSDB_CODE_SUCCESS;
 }
 
-static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks, int16_t timePrec, int32_t* len, char* tmpTokenBuf) {
+static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks, int16_t timePrec, int32_t* len,
+                       char* tmpTokenBuf) {
   SParsedDataColInfo* spd = &pDataBlocks->boundColumnInfo;
   SRowBuilder*        pBuilder = &pDataBlocks->rowBuilder;
   STSRow*             row = (STSRow*)(pDataBlocks->pData + pDataBlocks->size);  // skip the SSubmitBlk header
 
   tdSRowResetBuf(pBuilder, row);
 
-  bool isParseBindParam = false;
-  SSchema* schema = getTableColumnSchema(pDataBlocks->pTableMeta);
+  bool      isParseBindParam = false;
+  SSchema*  schema = getTableColumnSchema(pDataBlocks->pTableMeta);
   SMemParam param = {.rb = pBuilder};
-  SToken sToken = {0};
+  SToken    sToken = {0};
   // 1. set the parsed value from sql string
   for (int i = 0; i < spd->numOfBound; ++i) {
     NEXT_TOKEN_WITH_PREV(pCxt->pSql, sToken);
@@ -885,7 +889,7 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
 
     if (PRIMARYKEY_TIMESTAMP_COL_ID == pSchema->colId) {
       TSKEY tsKey = TD_ROW_KEY(row);
-      if (checkTimestamp(pDataBlocks, (const char *)&tsKey) != TSDB_CODE_SUCCESS) {
+      if (checkTimestamp(pDataBlocks, (const char*)&tsKey) != TSDB_CODE_SUCCESS) {
         buildSyntaxErrMsg(&pCxt->msg, "client time/server time can not be mixed up", sToken.z);
         return TSDB_CODE_TSC_INVALID_TIME_STAMP;
       }
@@ -911,11 +915,11 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
 // pSql -> (field1_value, ...) [(field1_value2, ...) ...]
 static int32_t parseValues(SInsertParseContext* pCxt, STableDataBlocks* pDataBlock, int maxRows, int32_t* numOfRows) {
   STableComInfo tinfo = getTableInfo(pDataBlock->pTableMeta);
-  int32_t extendedRowSize = getExtendedRowSize(pDataBlock);
+  int32_t       extendedRowSize = getExtendedRowSize(pDataBlock);
   CHECK_CODE(initRowBuilder(&pDataBlock->rowBuilder, pDataBlock->pTableMeta->sversion, &pDataBlock->boundColumnInfo));
 
   (*numOfRows) = 0;
-  char tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0};  // used for deleting Escape character: \\, \', \"
+  char   tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0};  // used for deleting Escape character: \\, \', \"
   SToken sToken;
   while (1) {
     int32_t index = 0;
@@ -934,7 +938,7 @@ static int32_t parseValues(SInsertParseContext* pCxt, STableDataBlocks* pDataBlo
 
     int32_t len = 0;
     CHECK_CODE(parseOneRow(pCxt, pDataBlock, tinfo.precision, &len, tmpTokenBuf));
-    pDataBlock->size += extendedRowSize; //len;
+    pDataBlock->size += extendedRowSize;  // len;
 
     NEXT_TOKEN(pCxt->pSql, sToken);
     if (TK_NK_RP != sToken.type) {
@@ -945,19 +949,19 @@ static int32_t parseValues(SInsertParseContext* pCxt, STableDataBlocks* pDataBlo
   }
 
   if (0 == (*numOfRows)) {
-    return  buildSyntaxErrMsg(&pCxt->msg, "no any data points", NULL);
+    return buildSyntaxErrMsg(&pCxt->msg, "no any data points", NULL);
   }
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t parseValuesClause(SInsertParseContext* pCxt, STableDataBlocks* dataBuf) {  
+static int32_t parseValuesClause(SInsertParseContext* pCxt, STableDataBlocks* dataBuf) {
   int32_t maxNumOfRows;
   CHECK_CODE(allocateMemIfNeed(dataBuf, getExtendedRowSize(dataBuf), &maxNumOfRows));
 
   int32_t numOfRows = 0;
   CHECK_CODE(parseValues(pCxt, dataBuf, maxNumOfRows, &numOfRows));
 
-  SSubmitBlk *pBlocks = (SSubmitBlk *)(dataBuf->pData);
+  SSubmitBlk* pBlocks = (SSubmitBlk*)(dataBuf->pData);
   if (TSDB_CODE_SUCCESS != setBlockInfo(pBlocks, dataBuf, numOfRows)) {
     return buildInvalidOperationMsg(&pCxt->msg, "too many rows in sql, total number of rows should be less than 32767");
   }
@@ -968,7 +972,6 @@ static int32_t parseValuesClause(SInsertParseContext* pCxt, STableDataBlocks* da
 }
 
 static void destroyCreateSubTbReq(SVCreateTbReq* pReq) {
-  taosMemoryFreeClear(pReq->dbFName);
   taosMemoryFreeClear(pReq->name);
   taosMemoryFreeClear(pReq->ctbCfg.pTag);
 }
@@ -1023,7 +1026,8 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
     // no data in the sql string anymore.
     if (sToken.n == 0) {
       if (0 == pCxt->totalNum) {
-        return buildInvalidOperationMsg(&pCxt->msg, "no data in sql");;
+        return buildInvalidOperationMsg(&pCxt->msg, "no data in sql");
+        ;
       }
       break;
     }
@@ -1031,7 +1035,7 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
     SToken tbnameToken = sToken;
     NEXT_TOKEN(pCxt->pSql, sToken);
 
-    // USING cluase 
+    // USING cluase
     if (TK_USING == sToken.type) {
       CHECK_CODE(parseUsingClause(pCxt, &tbnameToken));
       NEXT_TOKEN(pCxt->pSql, sToken);
@@ -1039,10 +1043,11 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
       CHECK_CODE(getTableMeta(pCxt, &tbnameToken));
     }
 
-    STableDataBlocks *dataBuf = NULL;
+    STableDataBlocks* dataBuf = NULL;
     CHECK_CODE(getDataBlockFromList(pCxt->pTableBlockHashObj, pCxt->pTableMeta->uid, TSDB_DEFAULT_PAYLOAD_SIZE,
-        sizeof(SSubmitBlk), getTableInfo(pCxt->pTableMeta).rowSize, pCxt->pTableMeta, &dataBuf, NULL, &pCxt->createTblReq));
-        
+                                    sizeof(SSubmitBlk), getTableInfo(pCxt->pTableMeta).rowSize, pCxt->pTableMeta,
+                                    &dataBuf, NULL, &pCxt->createTblReq));
+
     if (TK_NK_LP == sToken.type) {
       // pSql -> field1_name, ...)
       CHECK_CODE(parseBoundColumns(pCxt, &dataBuf->boundColumnInfo, getTableColumnSchema(pCxt->pTableMeta)));
@@ -1071,7 +1076,8 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
     return buildSyntaxErrMsg(&pCxt->msg, "keyword VALUES or FILE is expected", sToken.z);
   }
   // merge according to vgId
-  if (!TSDB_QUERY_HAS_TYPE(pCxt->pOutput->insertType, TSDB_QUERY_TYPE_STMT_INSERT) && taosHashGetSize(pCxt->pTableBlockHashObj) > 0) {
+  if (!TSDB_QUERY_HAS_TYPE(pCxt->pOutput->insertType, TSDB_QUERY_TYPE_STMT_INSERT) &&
+      taosHashGetSize(pCxt->pTableBlockHashObj) > 0) {
     CHECK_CODE(mergeTableDataBlocks(pCxt->pTableBlockHashObj, pCxt->pOutput->payloadType, &pCxt->pVgDataBlocks));
   }
   return buildOutput(pCxt);
@@ -1085,19 +1091,18 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt) {
 //   [...];
 int32_t parseInsertSql(SParseContext* pContext, SQuery** pQuery) {
   SInsertParseContext context = {
-    .pComCxt = pContext,
-    .pSql = (char*) pContext->pSql,
-    .msg = {.buf = pContext->pMsg, .len = pContext->msgLen},
-    .pTableMeta = NULL,
-    .pVgroupsHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, false),
-    .pTableBlockHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false),
-    .pSubTableHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), true, false),
-    .totalNum = 0,
-    .pOutput = (SVnodeModifOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIF_STMT)
-  };
-
-  if (NULL == context.pVgroupsHashObj || NULL == context.pTableBlockHashObj ||
-      NULL == context.pSubTableHashObj || NULL == context.pOutput) {
+      .pComCxt = pContext,
+      .pSql = (char*)pContext->pSql,
+      .msg = {.buf = pContext->pMsg, .len = pContext->msgLen},
+      .pTableMeta = NULL,
+      .pVgroupsHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, false),
+      .pTableBlockHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false),
+      .pSubTableHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), true, false),
+      .totalNum = 0,
+      .pOutput = (SVnodeModifOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIF_STMT)};
+
+  if (NULL == context.pVgroupsHashObj || NULL == context.pTableBlockHashObj || NULL == context.pSubTableHashObj ||
+      NULL == context.pOutput) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 

source/libs/parser/src/parTranslater.c

@@ -2747,7 +2747,6 @@ static void toSchemaEx(const SColumnDefNode* pCol, col_id_t colId, SSchema* pSch
 }
 
 static void destroyCreateTbReq(SVCreateTbReq* pReq) {
-  taosMemoryFreeClear(pReq->dbFName);
   taosMemoryFreeClear(pReq->name);
   taosMemoryFreeClear(pReq->ntbCfg.pSchema);
 }
@@ -2784,7 +2783,6 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt*
 
   SVCreateTbReq req = {0};
   req.type = TD_NORMAL_TABLE;
-  req.dbFName = strdup(dbFName);
   req.name = strdup(pStmt->tableName);
   req.ntbCfg.nCols = LIST_LENGTH(pStmt->pCols);
   req.ntbCfg.pSchema = taosMemoryCalloc(req.ntbCfg.nCols, sizeof(SSchema));
@@ -2843,7 +2841,6 @@ static void destroyCreateTbReqBatch(SVgroupTablesBatch* pTbBatch) {
   size_t size = taosArrayGetSize(pTbBatch->req.pArray);
   for (int32_t i = 0; i < size; ++i) {
     SVCreateTbReq* pTableReq = taosArrayGet(pTbBatch->req.pArray, i);
-    taosMemoryFreeClear(pTableReq->dbFName);
     taosMemoryFreeClear(pTableReq->name);
 
     if (pTableReq->type == TSDB_NORMAL_TABLE) {
@@ -2929,7 +2926,6 @@ static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, c
 
   struct SVCreateTbReq req = {0};
   req.type = TD_CHILD_TABLE;
-  req.dbFName = strdup(dbFName);
   req.name = strdup(pTableName);
   req.ctbCfg.suid = suid;
   req.ctbCfg.pTag = row;