[TD-32] refactor the tablemeta

src/client/inc/tscUtil.h

@@ -30,10 +30,10 @@ extern "C" {
 #include "tsclient.h"
 
 #define UTIL_METER_IS_SUPERTABLE(metaInfo) \
-  (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->tableType == TSDB_SUPER_TABLE))
+  (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_SUPER_TABLE))
 #define UTIL_METER_IS_NOMRAL_METER(metaInfo) (!(UTIL_METER_IS_SUPERTABLE(metaInfo)))
 #define UTIL_METER_IS_CREATE_FROM_METRIC(metaInfo) \
-  (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->tableType == TSDB_CHILD_TABLE))
+  (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_CHILD_TABLE))
 
 #define TSDB_COL_IS_TAG(f) (((f)&TSDB_COL_TAG) != 0)
 
@@ -67,7 +67,7 @@ typedef struct SJoinSubquerySupporter {
 } SJoinSubquerySupporter;
 
 int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOffset, const char* name,
-                           STableMeta* pMeterMeta, STableDataBlocks** dataBlocks);
+                           STableMeta* pTableMeta, STableDataBlocks** dataBlocks);
 void    tscAppendDataBlock(SDataBlockList* pList, STableDataBlocks* pBlocks);
 void    tscDestroyDataBlock(STableDataBlocks* pDataBlock);
 
@@ -81,7 +81,7 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock);
 void    tscFreeUnusedDataBlocks(SDataBlockList* pList);
 int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SDataBlockList* pDataList);
 int32_t tscGetDataBlockFromList(void* pHashList, SDataBlockList* pDataBlockList, int64_t id, int32_t size,
-                                int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pMeterMeta,
+                                int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pTableMeta,
                                 STableDataBlocks** dataBlocks);
 
 SVnodeSidList*    tscGetVnodeSidList(SSuperTableMeta* pMetricmeta, int32_t vnodeIdx);
@@ -114,7 +114,7 @@ void tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex
 
 void addRequiredTagColumn(SQueryInfo* pQueryInfo, int32_t tagColIndex, int32_t tableIndex);
 
-int32_t setMeterID(SMeterMetaInfo* pMeterMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql);
+int32_t setMeterID(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql);
 void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 
 bool tscIsInsertOrImportData(char* sqlstr);
@@ -173,7 +173,7 @@ int32_t tscValidateName(SSQLToken* pToken);
 
 void tscIncStreamExecutionCount(void* pStream);
 
-bool tscValidateColumnId(SMeterMetaInfo* pMeterMetaInfo, int32_t colId);
+bool tscValidateColumnId(STableMetaInfo* pTableMetaInfo, int32_t colId);
 
 // get starter position of metric query condition (query on tags) in SSqlCmd.payload
 SCond* tsGetMetricQueryCondPos(STagCond* pCond, uint64_t tableIndex);
@@ -190,26 +190,26 @@ void tscCleanSqlCmd(SSqlCmd* pCmd);
 bool tscShouldFreeAsyncSqlObj(SSqlObj* pSql);
 
 void            tscRemoveAllMeterMetaInfo(SQueryInfo* pQueryInfo, const char* address, bool removeFromCache);
-SMeterMetaInfo* tscGetMeterMetaInfo(SSqlCmd *pCmd, int32_t subClauseIndex, int32_t tableIndex);
-SMeterMetaInfo* tscGetMeterMetaInfoFromQueryInfo(SQueryInfo *pQueryInfo, int32_t tableIndex);
+STableMetaInfo* tscGetMeterMetaInfo(SSqlCmd *pCmd, int32_t subClauseIndex, int32_t tableIndex);
+STableMetaInfo* tscGetMeterMetaInfoFromQueryInfo(SQueryInfo *pQueryInfo, int32_t tableIndex);
 
 SQueryInfo *tscGetQueryInfoDetail(SSqlCmd* pCmd, int32_t subClauseIndex);
 int32_t tscGetQueryInfoDetailSafely(SSqlCmd *pCmd, int32_t subClauseIndex, SQueryInfo** pQueryInfo);
 
-SMeterMetaInfo* tscGetMeterMetaInfoByUid(SQueryInfo* pQueryInfo, uint64_t uid, int32_t* index);
-void            tscClearMeterMetaInfo(SMeterMetaInfo* pMeterMetaInfo, bool removeFromCache);
+STableMetaInfo* tscGetMeterMetaInfoByUid(SQueryInfo* pQueryInfo, uint64_t uid, int32_t* index);
+void            tscClearMeterMetaInfo(STableMetaInfo* pTableMetaInfo, bool removeFromCache);
 
-SMeterMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pMeterMeta, SSuperTableMeta* pMetricMeta,
+STableMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pTableMeta, SSuperTableMeta* pMetricMeta,
                                     int16_t numOfTags, int16_t* tags);
-SMeterMetaInfo* tscAddEmptyMeterMetaInfo(SQueryInfo *pQueryInfo);
+STableMetaInfo* tscAddEmptyMeterMetaInfo(SQueryInfo *pQueryInfo);
 int32_t tscAddSubqueryInfo(SSqlCmd *pCmd);
 void tscFreeSubqueryInfo(SSqlCmd* pCmd);
 void tscClearSubqueryInfo(SSqlCmd* pCmd);
 
 void tscGetMetricMetaCacheKey(SQueryInfo* pQueryInfo, char* keyStr, uint64_t uid);
 int  tscGetMetricMeta(SSqlObj* pSql, int32_t clauseIndex);
-int  tscGetMeterMeta(SSqlObj* pSql, SMeterMetaInfo* pMeterMetaInfo);
-int  tscGetMeterMetaEx(SSqlObj* pSql, SMeterMetaInfo* pMeterMetaInfo, bool createIfNotExists);
+int  tscGetMeterMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
+int  tscGetMeterMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
 
 void tscResetForNextRetrieve(SSqlRes* pRes);
 

src/util/inc/tschemautil.h → src/client/inc/tschemautil.h

@@ -20,13 +20,56 @@
 extern "C" {
 #endif
 
-#include <stdint.h>
 #include "taosmsg.h"
 #include "tstoken.h"
+#include "tsclient.h"
 
 #define VALIDNUMOFCOLS(x) ((x) >= TSDB_MIN_COLUMNS && (x) <= TSDB_MAX_COLUMNS)
 
-struct SSchema;
+//struct SSchema;
+
+/**
+ * get the number of tags of this table
+ * @param pTableMeta
+ * @return
+ */
+int32_t tscGetNumOfTags(const STableMeta* pTableMeta);
+
+/**
+ * get the number of columns of this table
+ * @param pTableMeta
+ * @return
+ */
+int32_t tscGetNumOfColumns(const STableMeta* pTableMeta);
+
+/**
+ * get the basic info of this table
+ * @param pTableMeta
+ * @return
+ */
+STableInfo tscGetTableInfo(const STableMeta* pTableMeta);
+
+/**
+ * get the schema
+ * @param pTableMeta
+ * @return
+ */
+SSchema* tscGetTableSchema(const STableMeta* pTableMeta);
+
+/**
+ * get the tag schema
+ * @param pMeta
+ * @return
+ */
+SSchema *tscGetTableTagSchema(const STableMeta *pMeta);
+
+/**
+ *
+ * @param pMeta
+ * @param startCol
+ * @return
+ */
+SSchema *tscGetTableColumnSchema(const STableMeta *pMeta, int32_t startCol);
 
 /**
  * check if the schema is valid or not, including following aspects:
@@ -42,13 +85,13 @@ struct SSchema;
  */
 bool isValidSchema(struct SSchema *pSchema, int32_t numOfCols);
 
-struct SSchema *tsGetSchema(STableMeta *pMeta);
-
-struct SSchema *tsGetTagSchema(STableMeta *pMeta);
-
-struct SSchema *tsGetColumnSchema(STableMeta *pMeta, int32_t startCol);
-struct SSchema tsGetTbnameColumnSchema();
+/**
+ * get the schema for the "tbname" column. it is a built column
+ * @return
+ */
+SSchema tsGetTbnameColumnSchema();
 
+//todo tags value as well as the table id structure needs refactor
 char *tsGetTagsValue(STableMeta *pMeta);
 
 bool tsMeterMetaIdentical(STableMeta *p1, STableMeta *p2);

src/client/inc/tsclient.h

@@ -46,8 +46,47 @@ typedef struct SSqlGroupbyExpr {
   int16_t     orderType;                  // order by type: asc/desc
 } SSqlGroupbyExpr;
 
-typedef struct SMeterMetaInfo {
-  STableMeta * pMeterMeta;   // metermeta
+typedef struct STableInfo {
+  uint8_t numOfTags;
+  uint8_t precision;
+  int16_t numOfColumns;
+  int16_t rowSize;
+} STableInfo;
+
+typedef struct STableMeta {
+  char*   tableId;  // null-terminated string
+  
+  union {
+    // pointer to super table if it is created according to super table
+    struct STableMeta* pSTable;
+    
+    // otherwise, the following information is required.
+    STableInfo tableInfo;
+  };
+  
+  uint8_t tableType;
+  int16_t sversion;
+  int8_t  numOfVpeers;
+  SVnodeDesc vpeerDesc[TSDB_VNODES_SUPPORT];
+  int32_t  sid;
+  int32_t  vgid;
+  uint64_t uid;
+  
+  // if the table is TSDB_CHILD_TABLE, schema is acquired by super table meta info
+  SSchema  schema[];
+} STableMeta;
+
+typedef struct SSTableMeta {
+  char* tableId;
+  STableInfo tableInfo;
+  int32_t  sid;
+  int32_t  vgid;
+  uint64_t uid;
+  SSchema  schema[];
+} SSTableMeta;
+
+typedef struct STableMetaInfo {
+  STableMeta * pTableMeta;       // table meta info
   SSuperTableMeta *pMetricMeta;  // metricmeta
 
   /*
@@ -55,10 +94,10 @@ typedef struct SMeterMetaInfo {
    * 2. keep the vnode index for multi-vnode insertion
    */
   int32_t vnodeIndex;
-  char    name[TSDB_TABLE_ID_LEN + 1];    // table(super table) name
+  char    name[TSDB_TABLE_ID_LEN + 1];    // (super) table name
   int16_t numOfTags;                      // total required tags in query, including groupby tags
   int16_t tagColumnIndex[TSDB_MAX_TAGS];  // clause + tag projection
-} SMeterMetaInfo;
+} STableMetaInfo;
 
 /* the structure for sql function in select clause */
 typedef struct SSqlExpr {
@@ -174,7 +213,7 @@ typedef struct STableDataBlocks {
    * the metermeta for current table, the metermeta will be used during submit stage, keep a ref
    * to avoid it to be removed from cache
    */
-  STableMeta *pMeterMeta;
+  STableMeta *pTableMeta;
 
   union {
     char *filename;
@@ -215,7 +254,7 @@ typedef struct SQueryInfo {
   SOrderVal        order;
   int16_t          interpoType;  // interpolate type
   int16_t          numOfTables;
-  SMeterMetaInfo **pMeterInfo;
+  STableMetaInfo **pMeterInfo;
   struct STSBuf *  tsBuf;
   int64_t *        defaultVal;   // default value for interpolation
   char *           msg;          // pointer to the pCmd->payload to keep error message temporarily

src/client/src/tscAsync.c

@@ -406,11 +406,11 @@ void tscAsyncInsertMultiVnodesProxy(void *param, TAOS_RES *tres, int numOfRows)
   int32_t index = 0;
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, index);
   
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   assert(pQueryInfo->numOfTables == 1 || pQueryInfo->numOfTables == 2);
   
   SDataBlockList *pDataBlocks = pCmd->pDataBlocks;
-  if (pDataBlocks == NULL || pMeterMetaInfo->vnodeIndex >= pDataBlocks->nSize) {
+  if (pDataBlocks == NULL || pTableMetaInfo->vnodeIndex >= pDataBlocks->nSize) {
     // restore user defined fp
     pSql->fp = pSql->fetchFp;
     tscTrace("%p Async insertion completed, destroy data block list", pSql);
@@ -422,17 +422,17 @@ void tscAsyncInsertMultiVnodesProxy(void *param, TAOS_RES *tres, int numOfRows)
     (*pSql->fp)(pSql->param, tres, numOfRows);
   } else {
     do {
-      code = tscCopyDataBlockToPayload(pSql, pDataBlocks->pData[pMeterMetaInfo->vnodeIndex++]);
+      code = tscCopyDataBlockToPayload(pSql, pDataBlocks->pData[pTableMetaInfo->vnodeIndex++]);
       if (code != TSDB_CODE_SUCCESS) {
         tscTrace("%p prepare submit data block failed in async insertion, vnodeIdx:%d, total:%d, code:%d",
-                 pSql, pMeterMetaInfo->vnodeIndex - 1, pDataBlocks->nSize, code);
+                 pSql, pTableMetaInfo->vnodeIndex - 1, pDataBlocks->nSize, code);
       }
 
-    } while (code != TSDB_CODE_SUCCESS && pMeterMetaInfo->vnodeIndex < pDataBlocks->nSize);
+    } while (code != TSDB_CODE_SUCCESS && pTableMetaInfo->vnodeIndex < pDataBlocks->nSize);
 
     // build submit msg may fail
     if (code == TSDB_CODE_SUCCESS) {
-      tscTrace("%p async insertion, vnodeIdx:%d, total:%d", pSql, pMeterMetaInfo->vnodeIndex - 1, pDataBlocks->nSize);
+      tscTrace("%p async insertion, vnodeIdx:%d, total:%d", pSql, pTableMetaInfo->vnodeIndex - 1, pDataBlocks->nSize);
       tscProcessSql(pSql);
     }
   }
@@ -464,10 +464,10 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
       tscTrace("%p renew tableMeta successfully, command:%d, code:%d, retry:%d",
           pSql, pSql->cmd.command, pSql->res.code, pSql->retry);
   
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
-      assert(pMeterMetaInfo->pMeterMeta == NULL);
+      STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+      assert(pTableMetaInfo->pTableMeta == NULL);
       
-      tscGetMeterMeta(pSql, pMeterMetaInfo);
+      tscGetMeterMeta(pSql, pTableMetaInfo);
       code = tscSendMsgToServer(pSql);
       if (code != 0) {
         pRes->code = code;
@@ -489,18 +489,18 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
     SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
   
     if ((pQueryInfo->type & TSDB_QUERY_TYPE_STABLE_SUBQUERY) == TSDB_QUERY_TYPE_STABLE_SUBQUERY) {
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-      assert(pMeterMetaInfo->pMeterMeta->numOfTags != 0 && pMeterMetaInfo->vnodeIndex >= 0 && pSql->param != NULL);
+      STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+//      assert(pTableMetaInfo->pTableMeta->numOfTags != 0 && pTableMetaInfo->vnodeIndex >= 0 && pSql->param != NULL);
 
       SRetrieveSupport *trs = (SRetrieveSupport *)pSql->param;
       SSqlObj *         pParObj = trs->pParentSqlObj;
       
-      assert(pParObj->signature == pParObj && trs->subqueryIndex == pMeterMetaInfo->vnodeIndex &&
-          pMeterMetaInfo->pMeterMeta->numOfTags != 0);
+//      assert(pParObj->signature == pParObj && trs->subqueryIndex == pTableMetaInfo->vnodeIndex &&
+//          pTableMetaInfo->pTableMeta->numOfTags != 0);
 
       tscTrace("%p get metricMeta during super table query successfully", pSql);
       
-      code = tscGetMeterMeta(pSql, pMeterMetaInfo);
+      code = tscGetMeterMeta(pSql, pTableMetaInfo);
       pRes->code = code;
 
       if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
@@ -513,11 +513,11 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
       if (pCmd->isParseFinish) {
         tscTrace("%p resend data to vnode in metermeta callback since sql has been parsed completed", pSql);
         
-        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-        code = tscGetMeterMeta(pSql, pMeterMetaInfo);
+        STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+        code = tscGetMeterMeta(pSql, pTableMetaInfo);
         assert(code == TSDB_CODE_SUCCESS);
       
-        if (pMeterMetaInfo->pMeterMeta) {
+        if (pTableMetaInfo->pTableMeta) {
           code = tscSendMsgToServer(pSql);
           if (code == TSDB_CODE_SUCCESS) return;
         }
@@ -528,13 +528,13 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
     }
 
   } else {  // stream computing
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-    code = tscGetMeterMeta(pSql, pMeterMetaInfo);
+    STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+    code = tscGetMeterMeta(pSql, pTableMetaInfo);
     pRes->code = code;
 
     if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
 
-    if (code == TSDB_CODE_SUCCESS && UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+    if (code == TSDB_CODE_SUCCESS && UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
       code = tscGetMetricMeta(pSql, pCmd->clauseIndex);
       pRes->code = code;
 

src/client/src/tscJoinProcess.c

@@ -164,8 +164,8 @@ SJoinSubquerySupporter* tscCreateJoinSupporter(SSqlObj* pSql, SSubqueryState* pS
   pSupporter->interval = pQueryInfo->intervalTime;
   pSupporter->limit = pQueryInfo->limit;
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, index);
-  pSupporter->uid = pMeterMetaInfo->pMeterMeta->uid;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, index);
+  pSupporter->uid = pTableMetaInfo->pTableMeta->uid;
   
   assert (pSupporter->uid != 0);
 
@@ -315,7 +315,7 @@ int32_t tscLaunchSecondPhaseSubqueries(SSqlObj* pSql) {
   
     tscFieldInfoCalOffset(pNewQueryInfo);
   
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pNewQueryInfo, 0);
+    STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pNewQueryInfo, 0);
   
     /*
      * When handling the projection query, the offset value will be modified for table-table join, which is changed
@@ -325,11 +325,11 @@ int32_t tscLaunchSecondPhaseSubqueries(SSqlObj* pSql) {
     pNewQueryInfo->limit = pSupporter->limit;
   
     // fetch the join tag column
-    if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+    if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
       SSqlExpr *pExpr = tscSqlExprGet(pNewQueryInfo, 0);
       assert(pQueryInfo->tagCond.joinInfo.hasJoin);
     
-      int16_t tagColIndex = tscGetJoinTagColIndexByUid(&pQueryInfo->tagCond, pMeterMetaInfo->pMeterMeta->uid);
+      int16_t tagColIndex = tscGetJoinTagColIndexByUid(&pQueryInfo->tagCond, pTableMetaInfo->pTableMeta->uid);
       pExpr->param[0].i64Key = tagColIndex;
       pExpr->numOfParams = 1;
     }
@@ -337,7 +337,7 @@ int32_t tscLaunchSecondPhaseSubqueries(SSqlObj* pSql) {
     tscPrintSelectClause(pNew, 0);
   
     tscTrace("%p subquery:%p tableIndex:%d, vnodeIdx:%d, type:%d, exprInfo:%d, colList:%d, fieldsInfo:%d, name:%s",
-             pSql, pNew, 0, pMeterMetaInfo->vnodeIndex, pNewQueryInfo->type,
+             pSql, pNew, 0, pTableMetaInfo->vnodeIndex, pNewQueryInfo->type,
              pNewQueryInfo->exprsInfo.numOfExprs, pNewQueryInfo->colList.numOfCols,
              pNewQueryInfo->fieldsInfo.numOfOutputCols, pNewQueryInfo->pMeterInfo[0]->name);
   }
@@ -450,9 +450,9 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
         pSupporter->pTSBuf = pBuf;
       } else {
         assert(pQueryInfo->numOfTables == 1);  // for subquery, only one metermetaInfo
-        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+        STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-        tsBufMerge(pSupporter->pTSBuf, pBuf, pMeterMetaInfo->vnodeIndex);
+        tsBufMerge(pSupporter->pTSBuf, pBuf, pTableMetaInfo->vnodeIndex);
         tsBufDestory(pBuf);
       }
 
@@ -467,14 +467,14 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
       
       //todo refactor
       if (tscNonOrderedProjectionQueryOnSTable(pParentQueryInfo, 0)) {
-        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+        STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
         assert(pQueryInfo->numOfTables == 1);
 
         // for projection query, need to try next vnode
-        int32_t totalVnode = pMeterMetaInfo->pMetricMeta->numOfVnodes;
-        if ((++pMeterMetaInfo->vnodeIndex) < totalVnode) {
+        int32_t totalVnode = pTableMetaInfo->pMetricMeta->numOfVnodes;
+        if ((++pTableMetaInfo->vnodeIndex) < totalVnode) {
           tscTrace("%p current vnode:%d exhausted, try next:%d. total vnode:%d. current numOfRes:%d", pSql,
-                   pMeterMetaInfo->vnodeIndex - 1, pMeterMetaInfo->vnodeIndex, totalVnode, pRes->numOfTotal);
+                   pTableMetaInfo->vnodeIndex - 1, pTableMetaInfo->vnodeIndex, totalVnode, pRes->numOfTotal);
   
           pSql->cmd.command = TSDB_SQL_SELECT;
           pSql->fp = tscJoinQueryCallback;
@@ -532,11 +532,11 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
     }
   
     if (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) && numOfRows == 0) {
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+      STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
       assert(pQueryInfo->numOfTables == 1);
 
       // for projection query, need to try next vnode if current vnode is exhausted
-      if ((++pMeterMetaInfo->vnodeIndex) < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
+      if ((++pTableMetaInfo->vnodeIndex) < pTableMetaInfo->pMetricMeta->numOfVnodes) {
         pSupporter->pState->numOfCompleted = 0;
         pSupporter->pState->numOfTotal = 1;
 
@@ -600,10 +600,10 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql) {
     SSqlRes *pRes = &pSql->pSubs[i]->res;
     SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->pSubs[i]->cmd, 0);
   
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+    STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   
     if (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
-      if (pRes->row >= pRes->numOfRows && pMeterMetaInfo->vnodeIndex < pMeterMetaInfo->pMetricMeta->numOfVnodes &&
+      if (pRes->row >= pRes->numOfRows && pTableMetaInfo->vnodeIndex < pTableMetaInfo->pMetricMeta->numOfVnodes &&
           (!tscHasReachLimitation(pQueryInfo, pRes))) {
         numOfFetch++;
       }
@@ -638,11 +638,11 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql) {
     SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd1, 0);
     assert(pRes1->numOfRows >= 0 && pQueryInfo->numOfTables == 1);
 
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
     
     if (pRes1->row >= pRes1->numOfRows) {
       tscTrace("%p subquery:%p retrieve data from vnode, subquery:%d, vnodeIndex:%d", pSql, pSql1,
-               pSupporter->subqueryIndex, pMeterMetaInfo->vnodeIndex);
+               pSupporter->subqueryIndex, pTableMetaInfo->vnodeIndex);
 
       tscResetForNextRetrieve(pRes1);
       pSql1->fp = joinRetrieveCallback;
@@ -688,8 +688,8 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
 
     int32_t tableIndexOfSub = -1;
     for (int32_t j = 0; j < pQueryInfo->numOfTables; ++j) {
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, j);
-      if (pMeterMetaInfo->pMeterMeta->uid == pExpr->uid) {
+      STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, j);
+      if (pTableMetaInfo->pTableMeta->uid == pExpr->uid) {
         tableIndexOfSub = j;
         break;
       }
@@ -712,13 +712,13 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
 
 void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
   SSqlObj* pSql = (SSqlObj*)tres;
-  //  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+  //  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
 
   //  int32_t idx = pSql->cmd.vnodeIdx;
 
   //  SVnodeSidList *vnodeInfo = NULL;
-  //  if (pMeterMetaInfo->pMetricMeta != NULL) {
-  //    vnodeInfo = tscGetVnodeSidList(pMeterMetaInfo->pMetricMeta, idx - 1);
+  //  if (pTableMetaInfo->pMetricMeta != NULL) {
+  //    vnodeInfo = tscGetVnodeSidList(pTableMetaInfo->pMetricMeta, idx - 1);
   //  }
 
   SJoinSubquerySupporter* pSupporter = (SJoinSubquerySupporter*)param;
@@ -776,14 +776,14 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
         assert(finished == numOfTotal);
         
         tscSetupOutputColumnIndex(pParentSql);
-        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+        STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
         /**
          * if the query is a continue query (vnodeIndex > 0 for projection query) for next vnode, do the retrieval of
          * data instead of returning to its invoker
          */
-        if (pMeterMetaInfo->vnodeIndex > 0 && tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
-          assert(pMeterMetaInfo->vnodeIndex < pMeterMetaInfo->pMetricMeta->numOfVnodes);
+        if (pTableMetaInfo->vnodeIndex > 0 && tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
+          assert(pTableMetaInfo->vnodeIndex < pTableMetaInfo->pMetricMeta->numOfVnodes);
           pSupporter->pState->numOfCompleted = 0;  // reset the record value
 
           pSql->fp = joinRetrieveCallback;  // continue retrieve data

src/client/src/tscLocal.c

@@ -77,7 +77,7 @@ static int32_t getToStringLength(const char *pData, int32_t length, int32_t type
  * length((uint64_t) 123456789011) > 12, greater than sizsof(uint64_t)
  */
 static int32_t tscMaxLengthOfTagsFields(SSqlObj *pSql) {
-  STableMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0, 0)->pMeterMeta;
+  STableMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0, 0)->pTableMeta;
 
   if (pMeta->tableType == TSDB_SUPER_TABLE || pMeta->tableType == TSDB_NORMAL_TABLE ||
       pMeta->tableType == TSDB_STREAM_TABLE) {
@@ -85,12 +85,14 @@ static int32_t tscMaxLengthOfTagsFields(SSqlObj *pSql) {
   }
 
   char *   pTagValue = tsGetTagsValue(pMeta);
-  SSchema *pTagsSchema = tsGetTagSchema(pMeta);
+  SSchema *pTagsSchema = tscGetTableTagSchema(pMeta);
 
   int32_t len = getToStringLength(pTagValue, pTagsSchema[0].bytes, pTagsSchema[0].type);
 
   pTagValue += pTagsSchema[0].bytes;
-  for (int32_t i = 1; i < pMeta->numOfTags; ++i) {
+  int32_t numOfTags = tscGetNumOfTags(pMeta);
+  
+  for (int32_t i = 1; i < numOfTags; ++i) {
     int32_t tLen = getToStringLength(pTagValue, pTagsSchema[i].bytes, pTagsSchema[i].type);
     if (len < tLen) {
       len = tLen;
@@ -108,8 +110,8 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   // one column for each row
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
   
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  STableMeta *    pMeta = pMeterMetaInfo->pMeterMeta;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
 
   /*
    * tagValueCnt is to denote the number of tags columns for meter, not metric. and is to show the column data.
@@ -117,15 +119,15 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
    * for metric, the value of tagValueCnt must be 0, but the numOfTags is not 0
    */
 
-  int32_t numOfRows = pMeta->numOfColumns;
-  int32_t totalNumOfRows = numOfRows + pMeta->numOfTags;
+  int32_t numOfRows = tscGetNumOfColumns(pMeta);
+  int32_t totalNumOfRows = numOfRows + tscGetNumOfTags(pMeta);
 
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
-    numOfRows = pMeta->numOfColumns + pMeta->numOfTags;
+  if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
+    numOfRows = numOfRows + tscGetNumOfTags(pMeta);
   }
 
   tscInitResObjForLocalQuery(pSql, totalNumOfRows, rowLen);
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = tscGetTableSchema(pMeta);
 
   for (int32_t i = 0; i < numOfRows; ++i) {
     TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, 0);
@@ -146,13 +148,13 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
     *(int32_t *)(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 2) * totalNumOfRows + pField->bytes * i) = bytes;
 
     pField = tscFieldInfoGetField(pQueryInfo, 3);
-    if (i >= pMeta->numOfColumns && pMeta->numOfTags != 0) {
+    if (i >= tscGetNumOfColumns(pMeta) && tscGetNumOfTags(pMeta) != 0) {
       strncpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, 3) * totalNumOfRows + pField->bytes * i, "tag",
               strlen("tag") + 1);
     }
   }
 
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     return 0;
   }
 
@@ -265,7 +267,7 @@ static int32_t tscBuildMeterSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
 static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
   
-  assert(tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMeterMeta != NULL);
+  assert(tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pTableMeta != NULL);
 
   const int32_t NUM_OF_DESCRIBE_TABLE_COLUMNS = 4;
   const int32_t TYPE_COLUMN_LENGTH = 16;
@@ -290,15 +292,15 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
   SSqlRes *       pRes = &pSql->res;
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
   
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-  SSuperTableMeta *pMetricMeta = pMeterMetaInfo->pMetricMeta;
-  SSchema *    pSchema = tsGetTagSchema(pMeterMetaInfo->pMeterMeta);
+  SSuperTableMeta *pMetricMeta = pTableMetaInfo->pMetricMeta;
+  SSchema *    pSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
 
   int32_t vOffset[TSDB_MAX_COLUMNS] = {0};
 
-  for (int32_t f = 1; f < pMeterMetaInfo->numOfTags; ++f) {
-    int16_t tagColumnIndex = pMeterMetaInfo->tagColumnIndex[f - 1];
+  for (int32_t f = 1; f < pTableMetaInfo->numOfTags; ++f) {
+    int16_t tagColumnIndex = pTableMetaInfo->tagColumnIndex[f - 1];
     if (tagColumnIndex == -1) {
       vOffset[f] = vOffset[f - 1] + TSDB_TABLE_NAME_LEN;
     } else {
@@ -375,8 +377,8 @@ static int tscProcessQueryTags(SSqlObj *pSql) {
   
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
   
-  STableMeta *pMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMeterMeta;
-  if (pMeterMeta == NULL || pMeterMeta->numOfTags == 0 || pMeterMeta->numOfColumns == 0) {
+  STableMeta *pTableMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pTableMeta;
+  if (pTableMeta == NULL || tscGetNumOfTags(pTableMeta) == 0 || tscGetNumOfColumns(pTableMeta) == 0) {
     strcpy(pCmd->payload, "invalid table");
     pSql->res.code = TSDB_CODE_INVALID_TABLE;
     return pSql->res.code;

src/client/src/tscParseInsert.c

@@ -496,15 +496,17 @@ static int32_t rowDataCompar(const void *lhs, const void *rhs) {
   }
 }
 
-int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pMeterMeta, int maxRows,
+int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMeta, int maxRows,
                   SParsedDataColInfo *spd, char *error, int32_t *code, char *tmpTokenBuf) {
   int32_t   index = 0;
   SSQLToken sToken;
 
   int16_t numOfRows = 0;
 
-  SSchema *pSchema = tsGetSchema(pMeterMeta);
-  int32_t  precision = pMeterMeta->precision;
+  SSchema *pSchema = tscGetTableSchema(pTableMeta);
+  STableInfo tinfo = tscGetTableInfo(pTableMeta);
+  
+  int32_t  precision = tinfo.precision;
 
   if (spd->hasVal[0] == false) {
     strcpy(error, "primary timestamp column can not be null");
@@ -518,9 +520,9 @@ int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pMeterMe
     if (sToken.n == 0 || sToken.type != TK_LP) break;
 
     *str += index;
-    if (numOfRows >= maxRows || pDataBlock->size + pMeterMeta->rowSize >= pDataBlock->nAllocSize) {
+    if (numOfRows >= maxRows || pDataBlock->size + tinfo.rowSize >= pDataBlock->nAllocSize) {
       int32_t tSize;
-      int32_t retcode = tscAllocateMemIfNeed(pDataBlock, pMeterMeta->rowSize, &tSize);
+      int32_t retcode = tscAllocateMemIfNeed(pDataBlock, tinfo.rowSize, &tSize);
       if (retcode != TSDB_CODE_SUCCESS) {  //TODO pass the correct error code to client
         strcpy(error, "client out of memory");
         *code = retcode;
@@ -601,10 +603,10 @@ int32_t tscAllocateMemIfNeed(STableDataBlocks *pDataBlock, int32_t rowSize, int3
   return TSDB_CODE_SUCCESS;
 }
 
-static void tsSetBlockInfo(SShellSubmitBlock *pBlocks, const STableMeta *pMeterMeta, int32_t numOfRows) {
-  pBlocks->sid = pMeterMeta->sid;
-  pBlocks->uid = pMeterMeta->uid;
-  pBlocks->sversion = pMeterMeta->sversion;
+static void tsSetBlockInfo(SShellSubmitBlock *pBlocks, const STableMeta *pTableMeta, int32_t numOfRows) {
+  pBlocks->sid = pTableMeta->sid;
+  pBlocks->uid = pTableMeta->uid;
+  pBlocks->sversion = pTableMeta->sversion;
   pBlocks->numOfRows += numOfRows;
 }
 
@@ -654,19 +656,20 @@ void sortRemoveDuplicates(STableDataBlocks *dataBuf) {
 static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableHashList, char **str, SParsedDataColInfo *spd,
                                       int32_t *totalNum) {
   SSqlCmd *       pCmd = &pSql->cmd;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  STableMeta *    pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMeta *    pTableMeta = pTableMetaInfo->pTableMeta;
+  STableInfo tinfo = tscGetTableInfo(pTableMeta);
   
   STableDataBlocks *dataBuf = NULL;
-  int32_t ret = tscGetDataBlockFromList(pTableHashList, pCmd->pDataBlocks, pMeterMeta->uid, TSDB_DEFAULT_PAYLOAD_SIZE,
-                                        sizeof(SShellSubmitBlock), pMeterMeta->rowSize, pMeterMetaInfo->name,
-                                        pMeterMeta, &dataBuf);
+  int32_t ret = tscGetDataBlockFromList(pTableHashList, pCmd->pDataBlocks, pTableMeta->uid, TSDB_DEFAULT_PAYLOAD_SIZE,
+                                        sizeof(SShellSubmitBlock), tinfo.rowSize, pTableMetaInfo->name,
+                                        pTableMeta, &dataBuf);
   if (ret != TSDB_CODE_SUCCESS) {
     return ret;
   }
   
   int32_t maxNumOfRows;
-  ret = tscAllocateMemIfNeed(dataBuf, pMeterMeta->rowSize, &maxNumOfRows);
+  ret = tscAllocateMemIfNeed(dataBuf, tinfo.rowSize, &maxNumOfRows);
   if (TSDB_CODE_SUCCESS != ret) {
     return TSDB_CODE_CLI_OUT_OF_MEMORY;
   }
@@ -677,7 +680,7 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableHashList, char
     return TSDB_CODE_CLI_OUT_OF_MEMORY;
   }
 
-  int32_t numOfRows = tsParseValues(str, dataBuf, pMeterMeta, maxNumOfRows, spd, pCmd->payload, &code, tmpTokenBuf);
+  int32_t numOfRows = tsParseValues(str, dataBuf, pTableMeta, maxNumOfRows, spd, pCmd->payload, &code, tmpTokenBuf);
   free(tmpTokenBuf);
   if (numOfRows <= 0) {
     return code;
@@ -692,9 +695,9 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableHashList, char
   }
 
   SShellSubmitBlock *pBlocks = (SShellSubmitBlock *)(dataBuf->pData);
-  tsSetBlockInfo(pBlocks, pMeterMeta, numOfRows);
+  tsSetBlockInfo(pBlocks, pTableMeta, numOfRows);
 
-  dataBuf->vgid = pMeterMeta->vgid;
+  dataBuf->vgid = pTableMeta->vgid;
   dataBuf->numOfTables = 1;
 
   /*
@@ -756,7 +759,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     return TSDB_CODE_INVALID_SQL;
   }
   
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, TABLE_INDEX);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, TABLE_INDEX);
   
   if (sToken.type == TK_USING) {  // create table if not exists according to the super table
     index = 0;
@@ -767,13 +770,13 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     memset(pTag, 0, sizeof(STagData));
     
     /*
-     * the source super table is moved to the secondary position of the pMeterMetaInfo list
+     * the source super table is moved to the secondary position of the pTableMetaInfo list
      */
     if (pQueryInfo->numOfTables < 2) {
       tscAddEmptyMeterMetaInfo(pQueryInfo);
     }
 
-    SMeterMetaInfo *pSTableMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, STABLE_INDEX);
+    STableMetaInfo *pSTableMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, STABLE_INDEX);
     setMeterID(pSTableMeterMetaInfo, &sToken, pSql);
 
     strncpy(pTag->name, pSTableMeterMetaInfo->name, TSDB_TABLE_ID_LEN);
@@ -786,7 +789,8 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
       return tscInvalidSQLErrMsg(pCmd->payload, "create table only from super table is allowed", sToken.z);
     }
 
-    SSchema *pTagSchema = tsGetTagSchema(pSTableMeterMetaInfo->pMeterMeta);
+    SSchema *pTagSchema = tscGetTableTagSchema(pSTableMeterMetaInfo->pTableMeta);
+    STableInfo tinfo = tscGetTableInfo(pSTableMeterMetaInfo->pTableMeta);
     
     index = 0;
     sToken = tStrGetToken(sql, &index, false, 0, NULL);
@@ -794,7 +798,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
 
     SParsedDataColInfo spd = {0};
     
-    uint8_t numOfTags = pSTableMeterMetaInfo->pMeterMeta->numOfTags;
+    uint8_t numOfTags = tscGetNumOfTags(pSTableMeterMetaInfo->pTableMeta);
     spd.numOfCols = numOfTags;
 
     // if specify some tags column
@@ -881,8 +885,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
         sToken.n -= 2;
       }
 
-      code = tsParseOneColumnData(&pTagSchema[colIndex], &sToken, tagVal, pCmd->payload, &sql, false,
-                                  pSTableMeterMetaInfo->pMeterMeta->precision);
+      code = tsParseOneColumnData(&pTagSchema[colIndex], &sToken, tagVal, pCmd->payload, &sql, false, tinfo.precision);
       if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
@@ -917,13 +920,13 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
       return tscInvalidSQLErrMsg(pCmd->payload, "invalid table name", *sqlstr);
     }
 
-    int32_t ret = setMeterID(pMeterMetaInfo, &tableToken, pSql);
+    int32_t ret = setMeterID(pTableMetaInfo, &tableToken, pSql);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
 
     createTable = true;
-    code = tscGetMeterMetaEx(pSql, pMeterMetaInfo, true);
+    code = tscGetMeterMetaEx(pSql, pTableMetaInfo, true);
     if (TSDB_CODE_ACTION_IN_PROGRESS == code) {
       return code;
     }
@@ -934,7 +937,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     } else {
       sql = sToken.z;
     }
-    code = tscGetMeterMeta(pSql, pMeterMetaInfo);
+    code = tscGetMeterMeta(pSql, pTableMetaInfo);
   }
 
   int32_t len = cend - cstart + 1;
@@ -983,15 +986,15 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
   int32_t totalNum = 0;
   int32_t code = TSDB_CODE_SUCCESS;
 
-  SMeterMetaInfo *pMeterMetaInfo = NULL;
+  STableMetaInfo *pTableMetaInfo = NULL;
 
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
   assert(pQueryInfo != NULL);
 
   if (pQueryInfo->numOfTables == 0) {
-    pMeterMetaInfo = tscAddEmptyMeterMetaInfo(pQueryInfo);
+    pTableMetaInfo = tscAddEmptyMeterMetaInfo(pQueryInfo);
   } else {
-    pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+    pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   }
 
   if ((code = tscAllocPayload(pCmd, TSDB_PAYLOAD_SIZE)) != TSDB_CODE_SUCCESS) {
@@ -1050,7 +1053,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       goto _error_clean;
     }
 
-    if ((code = setMeterID(pMeterMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
+    if ((code = setMeterID(pTableMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
       goto _error_clean;
     }
 
@@ -1078,7 +1081,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       goto _error_clean;       // TODO: should _clean or _error_clean to async flow ????
     }
 
-    if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+    if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
       code = tscInvalidSQLErrMsg(pCmd->payload, "insert data into super table is not supported", NULL);
       goto _error_clean;
     }
@@ -1092,11 +1095,15 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       goto _error_clean;
     }
     
+    int32_t numOfCols = tscGetNumOfTags(pTableMetaInfo->pTableMeta);
+    STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+    
     if (sToken.type == TK_VALUES) {
-      SParsedDataColInfo spd = {.numOfCols = pMeterMetaInfo->pMeterMeta->numOfColumns};
-      SSchema *          pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+      SParsedDataColInfo spd = {.numOfCols = numOfCols};
       
-      tscSetAssignedColumnInfo(&spd, pSchema, pMeterMetaInfo->pMeterMeta->numOfColumns);
+      SSchema *pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
+
+      tscSetAssignedColumnInfo(&spd, pSchema, numOfCols);
 
       if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
         goto _error_clean;
@@ -1136,10 +1143,10 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       wordfree(&full_path);
 
       STableDataBlocks *pDataBlock = NULL;
-      STableMeta* pMeterMeta = pMeterMetaInfo->pMeterMeta;
+      STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
       
-      int32_t ret = tscCreateDataBlock(PATH_MAX, pMeterMeta->rowSize, sizeof(SShellSubmitBlock), pMeterMetaInfo->name,
-                                       pMeterMeta, &pDataBlock);
+      int32_t ret = tscCreateDataBlock(PATH_MAX, tinfo.rowSize, sizeof(SShellSubmitBlock), pTableMetaInfo->name,
+                                       pTableMeta, &pDataBlock);
       if (ret != TSDB_CODE_SUCCESS) {
         goto _error_clean;
       }
@@ -1148,18 +1155,18 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       strcpy(pDataBlock->filename, fname);
     } else if (sToken.type == TK_LP) {
       /* insert into tablename(col1, col2,..., coln) values(v1, v2,... vn); */
-      STableMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0)->pMeterMeta;
-      SSchema *   pSchema = tsGetSchema(pMeterMeta);
+      STableMeta *pTableMeta = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0)->pTableMeta;
+      SSchema *   pSchema = tscGetTableSchema(pTableMeta);
 
       if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
         goto _error_clean;
       }
 
       SParsedDataColInfo spd = {0};
-      spd.numOfCols = pMeterMeta->numOfColumns;
+      spd.numOfCols = tinfo.numOfColumns;
 
       int16_t offset[TSDB_MAX_COLUMNS] = {0};
-      for (int32_t t = 1; t < pMeterMeta->numOfColumns; ++t) {
+      for (int32_t t = 1; t < tinfo.numOfColumns; ++t) {
         offset[t] = offset[t - 1] + pSchema[t - 1].bytes;
       }
 
@@ -1181,7 +1188,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
         bool findColumnIndex = false;
 
         // todo speedup by using hash list
-        for (int32_t t = 0; t < pMeterMeta->numOfColumns; ++t) {
+        for (int32_t t = 0; t < tinfo.numOfColumns; ++t) {
           if (strncmp(sToken.z, pSchema[t].name, sToken.n) == 0 && strlen(pSchema[t].name) == sToken.n) {
             SParsedColElem *pElem = &spd.elems[spd.numOfAssignedCols++];
             pElem->offset = offset[t];
@@ -1204,7 +1211,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
         }
       }
 
-      if (spd.numOfAssignedCols == 0 || spd.numOfAssignedCols > pMeterMeta->numOfColumns) {
+      if (spd.numOfAssignedCols == 0 || spd.numOfAssignedCols > tinfo.numOfColumns) {
         code = tscInvalidSQLErrMsg(pCmd->payload, "column name expected", sToken.z);
         goto _error_clean;
       }
@@ -1245,10 +1252,10 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       goto _error_clean;
     }
 
-    pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+    pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
 
     // set the next sent data vnode index in data block arraylist
-    pMeterMetaInfo->vnodeIndex = 1;
+    pTableMetaInfo->vnodeIndex = 1;
   } else {
     pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
   }
@@ -1348,10 +1355,10 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
   SSqlCmd *pCmd = &pSql->cmd;
 
   assert(pCmd->numOfClause == 1);
-  STableMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0)->pMeterMeta;
+  STableMeta *pTableMeta = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0)->pTableMeta;
 
   SShellSubmitBlock *pBlocks = (SShellSubmitBlock *)(pTableDataBlocks->pData);
-  tsSetBlockInfo(pBlocks, pMeterMeta, numOfRows);
+  tsSetBlockInfo(pBlocks, pTableMeta, numOfRows);
 
   if ((code = tscMergeTableDataBlocks(pSql, pCmd->pDataBlocks)) != TSDB_CODE_SUCCESS) {
     return code;
@@ -1381,16 +1388,18 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
   int32_t         code = 0;
   int             nrows = 0;
   
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  STableMeta *    pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMeta *    pTableMeta = pTableMetaInfo->pTableMeta;
+  STableInfo tinfo = tscGetTableInfo(pTableMeta);
+  
   assert(pCmd->numOfClause == 1);
   
-  int32_t         rowSize = pMeterMeta->rowSize;
+  int32_t rowSize = tinfo.rowSize;
 
   pCmd->pDataBlocks = tscCreateBlockArrayList();
   STableDataBlocks *pTableDataBlock = NULL;
   int32_t           ret = tscCreateDataBlock(TSDB_PAYLOAD_SIZE, rowSize, sizeof(SShellSubmitBlock),
-                                   pMeterMetaInfo->name, pMeterMeta, &pTableDataBlock);
+                                   pTableMetaInfo->name, pTableMeta, &pTableDataBlock);
   if (ret != TSDB_CODE_SUCCESS) {
     return -1;
   }
@@ -1401,10 +1410,10 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
   if (TSDB_CODE_SUCCESS != code) return -1;
 
   int                count = 0;
-  SParsedDataColInfo spd = {.numOfCols = pMeterMeta->numOfColumns};
-  SSchema *          pSchema = tsGetSchema(pMeterMeta);
+  SParsedDataColInfo spd = {.numOfCols = tinfo.numOfColumns};
+  SSchema *          pSchema = tscGetTableSchema(pTableMeta);
 
-  tscSetAssignedColumnInfo(&spd, pSchema, pMeterMeta->numOfColumns);
+  tscSetAssignedColumnInfo(&spd, pSchema, tinfo.numOfColumns);
 
   while ((readLen = getline(&line, &n, fp)) != -1) {
     // line[--readLen] = '\0';
@@ -1414,7 +1423,7 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
     char *lineptr = line;
     strtolower(line, line);
     
-    len = tsParseOneRowData(&lineptr, pTableDataBlock, pSchema, &spd, pCmd->payload, pMeterMeta->precision, &code, tmpTokenBuf);
+    len = tsParseOneRowData(&lineptr, pTableDataBlock, pSchema, &spd, pCmd->payload, tinfo.precision, &code, tmpTokenBuf);
     if (len <= 0 || pTableDataBlock->numOfParams > 0) {
       pSql->res.code = code;
       return (-code);
@@ -1431,7 +1440,7 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
 
       pTableDataBlock = pCmd->pDataBlocks->pData[0];
       pTableDataBlock->size = sizeof(SShellSubmitBlock);
-      pTableDataBlock->rowSize = pMeterMeta->rowSize;
+      pTableDataBlock->rowSize = tinfo.rowSize;
 
       numOfRows += pSql->res.numOfRows;
       pSql->res.numOfRows = 0;
@@ -1473,25 +1482,25 @@ void tscProcessMultiVnodesInsert(SSqlObj *pSql) {
   }
 
   STableDataBlocks *pDataBlock = NULL;
-  SMeterMetaInfo *  pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *  pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
   assert(pCmd->numOfClause == 1);
   
   int32_t           code = TSDB_CODE_SUCCESS;
 
   /* the first block has been sent to server in processSQL function */
-  assert(pMeterMetaInfo->vnodeIndex >= 1 && pCmd->pDataBlocks != NULL);
+  assert(pTableMetaInfo->vnodeIndex >= 1 && pCmd->pDataBlocks != NULL);
 
-  if (pMeterMetaInfo->vnodeIndex < pCmd->pDataBlocks->nSize) {
+  if (pTableMetaInfo->vnodeIndex < pCmd->pDataBlocks->nSize) {
     SDataBlockList *pDataBlocks = pCmd->pDataBlocks;
 
-    for (int32_t i = pMeterMetaInfo->vnodeIndex; i < pDataBlocks->nSize; ++i) {
+    for (int32_t i = pTableMetaInfo->vnodeIndex; i < pDataBlocks->nSize; ++i) {
       pDataBlock = pDataBlocks->pData[i];
       if (pDataBlock == NULL) {
         continue;
       }
 
       if ((code = tscCopyDataBlockToPayload(pSql, pDataBlock)) != TSDB_CODE_SUCCESS) {
-        tscTrace("%p build submit data block failed, vnodeIdx:%d, total:%d", pSql, pMeterMetaInfo->vnodeIndex,
+        tscTrace("%p build submit data block failed, vnodeIdx:%d, total:%d", pSql, pTableMetaInfo->vnodeIndex,
                  pDataBlocks->nSize);
         continue;
       }
@@ -1512,7 +1521,7 @@ void tscProcessMultiVnodesInsertFromFile(SSqlObj *pSql) {
   }
 
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   STableDataBlocks *pDataBlock = NULL;
   int32_t           affected_rows = 0;
@@ -1543,10 +1552,10 @@ void tscProcessMultiVnodesInsertFromFile(SSqlObj *pSql) {
       continue;
     }
 
-    strncpy(pMeterMetaInfo->name, pDataBlock->tableId, TSDB_TABLE_ID_LEN);
+    strncpy(pTableMetaInfo->name, pDataBlock->tableId, TSDB_TABLE_ID_LEN);
     memset(pDataBlock->pData, 0, pDataBlock->nAllocSize);
 
-    int32_t ret = tscGetMeterMeta(pSql, pMeterMetaInfo);
+    int32_t ret = tscGetMeterMeta(pSql, pTableMetaInfo);
     if (ret != TSDB_CODE_SUCCESS) {
       tscError("%p get meter meta failed, abort", pSql);
       continue;

src/client/src/tscPrepare.c

@@ -407,8 +407,8 @@ static int insertStmtReset(STscStmt* pStmt) {
   }
   pCmd->batchSize = 0;
   
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  pMeterMetaInfo->vnodeIndex = 0;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  pTableMetaInfo->vnodeIndex = 0;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -421,7 +421,7 @@ static int insertStmtExecute(STscStmt* stmt) {
     ++pCmd->batchSize;
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
   assert(pCmd->numOfClause == 1);
   
   if (pCmd->pDataBlocks->nSize > 0) {
@@ -438,7 +438,7 @@ static int insertStmtExecute(STscStmt* stmt) {
     }
 
     // set the next sent data vnode index in data block arraylist
-    pMeterMetaInfo->vnodeIndex = 1;
+    pTableMetaInfo->vnodeIndex = 1;
   } else {
     pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
   }

src/client/src/tscSQLParser.c

@@ -149,10 +149,12 @@ static int setColumnFilterInfoForTimestamp(SQueryInfo* pQueryInfo, tVariant* pVa
 
   strdequote(pVar->pz);
   char*           seg = strnchr(pVar->pz, '-', pVar->nLen, false);
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   
   if (seg != NULL) {
-    if (taosParseTime(pVar->pz, &time, pVar->nLen, pMeterMetaInfo->pMeterMeta->precision) != TSDB_CODE_SUCCESS) {
+    if (taosParseTime(pVar->pz, &time, pVar->nLen, tinfo.precision) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg);
     }
   } else {
@@ -207,7 +209,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   int32_t code = tscGetQueryInfoDetailSafely(pCmd, pCmd->clauseIndex, &pQueryInfo);
   assert(pQueryInfo->numOfTables == 0);
 
-  SMeterMetaInfo* pMeterMetaInfo = tscAddEmptyMeterMetaInfo(pQueryInfo);
+  STableMetaInfo* pTableMetaInfo = tscAddEmptyMeterMetaInfo(pQueryInfo);
 
   pCmd->command = pInfo->type;
 
@@ -229,7 +231,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       if (pInfo->type == TSDB_SQL_DROP_DB) {
         assert(pInfo->pDCLInfo->nTokens == 1);
 
-        code = setObjFullName(pMeterMetaInfo->name, getAccountId(pSql), pzName, NULL, NULL);
+        code = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), pzName, NULL, NULL);
         if (code != TSDB_CODE_SUCCESS) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
         }
@@ -237,7 +239,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       } else if (pInfo->type == TSDB_SQL_DROP_TABLE) {
         assert(pInfo->pDCLInfo->nTokens == 1);
 
-        if (setMeterID(pMeterMetaInfo, pzName, pSql) != TSDB_CODE_SUCCESS) {
+        if (setMeterID(pTableMetaInfo, pzName, pSql) != TSDB_CODE_SUCCESS) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
         }
       } else if (pInfo->type == TSDB_SQL_DROP_DNODE) {
@@ -245,13 +247,13 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
         }
 
-        strncpy(pMeterMetaInfo->name, pzName->z, pzName->n);
+        strncpy(pTableMetaInfo->name, pzName->z, pzName->n);
       } else {  // drop user
         if (pzName->n > TSDB_USER_LEN) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
         }
 
-        strncpy(pMeterMetaInfo->name, pzName->z, pzName->n);
+        strncpy(pTableMetaInfo->name, pzName->z, pzName->n);
       }
 
       break;
@@ -265,7 +267,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
       }
 
-      int32_t ret = setObjFullName(pMeterMetaInfo->name, getAccountId(pSql), pToken, NULL, NULL);
+      int32_t ret = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), pToken, NULL, NULL);
       if (ret != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
       }
@@ -295,7 +297,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
-      int32_t ret = setObjFullName(pMeterMetaInfo->name, getAccountId(pSql), &(pCreateDB->dbname), NULL, NULL);
+      int32_t ret = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), &(pCreateDB->dbname), NULL, NULL);
       if (ret != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
@@ -370,11 +372,11 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
-      if (setMeterID(pMeterMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
+      if (setMeterID(pTableMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
-      return tscGetMeterMeta(pSql, pMeterMetaInfo);
+      return tscGetMeterMeta(pSql, pTableMetaInfo);
     }
 
     case TSDB_SQL_CFG_DNODE: {
@@ -585,7 +587,8 @@ int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
   const char* msg1 = "invalid query expression";
   const char* msg2 = "interval cannot be less than 10 ms";
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   
   if (pQuerySql->interval.type == 0 || pQuerySql->interval.n == 0) {
     return TSDB_CODE_SUCCESS;
@@ -598,7 +601,7 @@ int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
   }
 
   // if the unit of time window value is millisecond, change the value from microsecond
-  if (pMeterMetaInfo->pMeterMeta->precision == TSDB_TIME_PRECISION_MILLI) {
+  if (tinfo.precision == TSDB_TIME_PRECISION_MILLI) {
     pQueryInfo->intervalTime = pQueryInfo->intervalTime / 1000;
   }
 
@@ -643,8 +646,8 @@ int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
 
   int32_t tableIndex = COLUMN_INDEX_INITIAL_VAL;
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
-    pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
-    if (pMeterMetaInfo->pMeterMeta->uid == uid) {
+    pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
+    if (pTableMetaInfo->pTableMeta->uid == uid) {
       tableIndex = i;
       break;
     }
@@ -676,12 +679,13 @@ int32_t parseSlidingClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
   const char* msg0 = "sliding value too small";
   const char* msg1 = "sliding value no larger than the interval value";
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   SSQLToken*      pSliding = &pQuerySql->sliding;
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
 
   if (pSliding->n != 0) {
     getTimestampInUsFromStr(pSliding->z, pSliding->n, &pQueryInfo->slidingTime);
-    if (pMeterMetaInfo->pMeterMeta->precision == TSDB_TIME_PRECISION_MILLI) {
+    if (tinfo.precision == TSDB_TIME_PRECISION_MILLI) {
       pQueryInfo->slidingTime /= 1000;
     }
 
@@ -699,27 +703,27 @@ int32_t parseSlidingClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t setMeterID(SMeterMetaInfo* pMeterMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql) {
+int32_t setMeterID(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql) {
   const char* msg = "name too long";
 
   SSqlCmd* pCmd = &pSql->cmd;
   int32_t  code = TSDB_CODE_SUCCESS;
 
-  // backup the old name in pMeterMetaInfo
-  size_t size = strlen(pMeterMetaInfo->name);
+  // backup the old name in pTableMetaInfo
+  size_t size = strlen(pTableMetaInfo->name);
   char*  oldName = NULL;
   if (size > 0) {
-    oldName = strdup(pMeterMetaInfo->name);
+    oldName = strdup(pTableMetaInfo->name);
   }
 
   if (hasSpecifyDB(pzTableName)) {
     // db has been specified in sql string so we ignore current db path
-    code = setObjFullName(pMeterMetaInfo->name, getAccountId(pSql), NULL, pzTableName, NULL);
+    code = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), NULL, pzTableName, NULL);
   } else {  // get current DB name first, then set it into path
     SSQLToken t = {0};
     getCurrentDBName(pSql, &t);
 
-    code = setObjFullName(pMeterMetaInfo->name, NULL, &t, pzTableName, NULL);
+    code = setObjFullName(pTableMetaInfo->name, NULL, &t, pzTableName, NULL);
   }
 
   if (code != TSDB_CODE_SUCCESS) {
@@ -736,11 +740,11 @@ int32_t setMeterID(SMeterMetaInfo* pMeterMetaInfo, SSQLToken* pzTableName, SSqlO
    * that are corresponding to the old name for the new table name.
    */
   if (size > 0) {
-    if (strncasecmp(oldName, pMeterMetaInfo->name, tListLen(pMeterMetaInfo->name)) != 0) {
-      tscClearMeterMetaInfo(pMeterMetaInfo, false);
+    if (strncasecmp(oldName, pTableMetaInfo->name, tListLen(pTableMetaInfo->name)) != 0) {
+      tscClearMeterMetaInfo(pTableMetaInfo, false);
     }
   } else {
-    assert(pMeterMetaInfo->pMeterMeta == NULL && pMeterMetaInfo->pMetricMeta == NULL);
+    assert(pTableMetaInfo->pTableMeta == NULL && pTableMetaInfo->pMetricMeta == NULL);
   }
 
   tfree(oldName);
@@ -890,11 +894,14 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
 
   assert(pCmd->numOfClause == 1);
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  STableMeta*     pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
+
+  int32_t numOfTags = tscGetNumOfTags(pTableMeta);
+  int32_t numOfCols = tscGetNumOfColumns(pTableMeta);
   
   // no more than 6 tags
-  if (pMeterMeta->numOfTags == TSDB_MAX_TAGS) {
+  if (numOfTags == TSDB_MAX_TAGS) {
     char msg[128] = {0};
     sprintf(msg, "tags no more than %d", TSDB_MAX_TAGS);
 
@@ -913,10 +920,10 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
     return false;
   }
 
-  SSchema* pTagSchema = tsGetTagSchema(pMeterMetaInfo->pMeterMeta);
+  SSchema* pTagSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
   int32_t  nLen = 0;
 
-  for (int32_t i = 0; i < pMeterMeta->numOfTags; ++i) {
+  for (int32_t i = 0; i < numOfTags; ++i) {
     nLen += pTagSchema[i].bytes;
   }
 
@@ -939,9 +946,9 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
   }
 
   // field name must be unique
-  SSchema* pSchema = tsGetSchema(pMeterMeta);
+  SSchema* pSchema = tscGetTableSchema(pTableMeta);
 
-  for (int32_t i = 0; i < pMeterMeta->numOfTags + pMeterMeta->numOfColumns; ++i) {
+  for (int32_t i = 0; i < numOfTags + numOfCols; ++i) {
     if (strncasecmp(pTagField->name, pSchema[i].name, TSDB_COL_NAME_LEN) == 0) {
       invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       return false;
@@ -960,12 +967,14 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
   const char* msg6 = "invalid column length";
 
   assert(pCmd->numOfClause == 1);
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  STableMeta*     pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
+  
+  int32_t numOfTags = tscGetNumOfTags(pTableMeta);
+  int32_t numOfCols = tscGetNumOfColumns(pTableMeta);
   
   // no more max columns
-  if (pMeterMeta->numOfColumns >= TSDB_MAX_COLUMNS ||
-      pMeterMeta->numOfTags + pMeterMeta->numOfColumns >= TSDB_MAX_COLUMNS) {
+  if (numOfCols >= TSDB_MAX_COLUMNS || numOfTags + numOfCols >= TSDB_MAX_COLUMNS) {
     invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     return false;
   }
@@ -980,10 +989,10 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
     return false;
   }
 
-  SSchema* pSchema = tsGetSchema(pMeterMeta);
+  SSchema* pSchema = tscGetTableSchema(pTableMeta);
   int32_t  nLen = 0;
 
-  for (int32_t i = 0; i < pMeterMeta->numOfColumns; ++i) {
+  for (int32_t i = 0; i < numOfCols; ++i) {
     nLen += pSchema[i].bytes;
   }
 
@@ -999,7 +1008,7 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
   }
 
   // field name must be unique
-  for (int32_t i = 0; i < pMeterMeta->numOfTags + pMeterMeta->numOfColumns; ++i) {
+  for (int32_t i = 0; i < numOfTags + numOfCols; ++i) {
     if (strncasecmp(pColField->name, pSchema[i].name, TSDB_COL_NAME_LEN) == 0) {
       invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       return false;
@@ -1238,10 +1247,11 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel
 
   if (isSTable) {
     pQueryInfo->type |= TSDB_QUERY_TYPE_STABLE_QUERY;
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+    int32_t numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
     
     if (tscQueryMetricTags(pQueryInfo)) {                      // local handle the metric tag query
-      pCmd->count = pMeterMetaInfo->pMeterMeta->numOfColumns;  // the number of meter schema, tricky.
+      pCmd->count = numOfCols;  // the number of meter schema, tricky.
       pQueryInfo->command = TSDB_SQL_RETRIEVE_TAGS;
     }
 
@@ -1272,11 +1282,11 @@ int32_t insertResultField(SQueryInfo* pQueryInfo, int32_t outputIndex, SColumnLi
 }
 
 SSqlExpr* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t outputIndex, int32_t colIdx, int32_t tableIndex) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
-  STableMeta*     pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
+  STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
+  int32_t numOfCols = tscGetNumOfColumns(pTableMeta);
   
-  SSchema* pSchema = tsGetColumnSchema(pMeterMeta, colIdx);
-  int32_t  numOfCols = pMeterMeta->numOfColumns;
+  SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, colIdx);
 
   int16_t functionId = (int16_t)((colIdx >= numOfCols) ? TSDB_FUNC_TAGPRJ : TSDB_FUNC_PRJ);
 
@@ -1295,39 +1305,39 @@ SSqlExpr* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t outputIndex, int32_t c
 }
 
 void addRequiredTagColumn(SQueryInfo* pQueryInfo, int32_t tagColIndex, int32_t tableIndex) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
 
-  if (pMeterMetaInfo->numOfTags == 0 || pMeterMetaInfo->tagColumnIndex[pMeterMetaInfo->numOfTags - 1] < tagColIndex) {
-    pMeterMetaInfo->tagColumnIndex[pMeterMetaInfo->numOfTags++] = tagColIndex;
+  if (pTableMetaInfo->numOfTags == 0 || pTableMetaInfo->tagColumnIndex[pTableMetaInfo->numOfTags - 1] < tagColIndex) {
+    pTableMetaInfo->tagColumnIndex[pTableMetaInfo->numOfTags++] = tagColIndex;
   } else {  // find the appropriate position
-    for (int32_t i = 0; i < pMeterMetaInfo->numOfTags; ++i) {
-      if (tagColIndex > pMeterMetaInfo->tagColumnIndex[i]) {
+    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
+      if (tagColIndex > pTableMetaInfo->tagColumnIndex[i]) {
         continue;
-      } else if (tagColIndex == pMeterMetaInfo->tagColumnIndex[i]) {
+      } else if (tagColIndex == pTableMetaInfo->tagColumnIndex[i]) {
         break;
       } else {
-        memmove(&pMeterMetaInfo->tagColumnIndex[i + 1], &pMeterMetaInfo->tagColumnIndex[i],
-                sizeof(pMeterMetaInfo->tagColumnIndex[0]) * (pMeterMetaInfo->numOfTags - i));
+        memmove(&pTableMetaInfo->tagColumnIndex[i + 1], &pTableMetaInfo->tagColumnIndex[i],
+                sizeof(pTableMetaInfo->tagColumnIndex[0]) * (pTableMetaInfo->numOfTags - i));
 
-        pMeterMetaInfo->tagColumnIndex[i] = tagColIndex;
+        pTableMetaInfo->tagColumnIndex[i] = tagColIndex;
 
-        pMeterMetaInfo->numOfTags++;
+        pTableMetaInfo->numOfTags++;
         break;
       }
     }
   }
 
   // plus one means tbname
-  assert(tagColIndex >= -1 && tagColIndex < TSDB_MAX_TAGS && pMeterMetaInfo->numOfTags <= TSDB_MAX_TAGS + 1);
+  assert(tagColIndex >= -1 && tagColIndex < TSDB_MAX_TAGS && pTableMetaInfo->numOfTags <= TSDB_MAX_TAGS + 1);
 }
 
 static void addProjectQueryCol(SQueryInfo* pQueryInfo, int32_t startPos, SColumnIndex* pIndex, tSQLExprItem* pItem) {
   SSqlExpr* pExpr = doAddProjectCol(pQueryInfo, startPos, pIndex->columnIndex, pIndex->tableIndex);
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pIndex->tableIndex);
-  STableMeta*     pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pIndex->tableIndex);
+  STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
   
-  SSchema* pSchema = tsGetColumnSchema(pMeterMeta, pIndex->columnIndex);
+  SSchema* pSchema = tscGetTableColumnSchema(pTableMeta, pIndex->columnIndex);
 
   char* colName = (pItem->aliasName == NULL) ? pSchema->name : pItem->aliasName;
   strncpy(pExpr->aliasName, colName, tListLen(pExpr->aliasName));
@@ -1336,7 +1346,7 @@ static void addProjectQueryCol(SQueryInfo* pQueryInfo, int32_t startPos, SColumn
   ids.num = 1;
   ids.ids[0] = *pIndex;
 
-  if (pIndex->columnIndex >= pMeterMeta->numOfColumns || pIndex->columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
+  if (pIndex->columnIndex >= tscGetNumOfColumns(pTableMeta) || pIndex->columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
     ids.num = 0;
   }
 
@@ -1362,16 +1372,16 @@ void tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex
 }
 
 static int32_t doAddProjectionExprAndResultFields(SQueryInfo* pQueryInfo, SColumnIndex* pIndex, int32_t startPos) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pIndex->tableIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pIndex->tableIndex);
 
   int32_t     numOfTotalColumns = 0;
-  STableMeta* pMeterMeta = pMeterMetaInfo->pMeterMeta;
-  SSchema*    pSchema = tsGetSchema(pMeterMeta);
+  STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+  SSchema*    pSchema = tscGetTableSchema(pTableMeta);
 
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
-    numOfTotalColumns = pMeterMeta->numOfColumns + pMeterMeta->numOfTags;
+  if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
+    numOfTotalColumns = tscGetNumOfColumns(pTableMeta) + tscGetNumOfTags(pTableMeta);
   } else {
-    numOfTotalColumns = pMeterMeta->numOfColumns;
+    numOfTotalColumns = tscGetNumOfColumns(pTableMeta);
   }
 
   for (int32_t j = 0; j < numOfTotalColumns; ++j) {
@@ -1383,7 +1393,7 @@ static int32_t doAddProjectionExprAndResultFields(SQueryInfo* pQueryInfo, SColum
     ids.ids[0] = *pIndex;
 
     // tag columns do not add to source list
-    ids.num = (j >= pMeterMeta->numOfColumns) ? 0 : 1;
+    ids.num = (j >= tscGetNumOfColumns(pTableMeta)) ? 0 : 1;
 
     insertResultField(pQueryInfo, startPos + j, &ids, pSchema[j].bytes, pSchema[j].type, pSchema[j].name, pExpr);
   }
@@ -1427,10 +1437,10 @@ int32_t addProjectionExprAndResultField(SQueryInfo* pQueryInfo, tSQLExprItem* pI
       pQueryInfo->type = TSDB_QUERY_TYPE_STABLE_QUERY;
       tscAddSpecialColumnForSelect(pQueryInfo, startPos, TSDB_FUNC_TAGPRJ, &index, &colSchema, true);
     } else {
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-      STableMeta*     pMeterMeta = pMeterMetaInfo->pMeterMeta;
+      STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+      STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
 
-      if (index.columnIndex >= pMeterMeta->numOfColumns && UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
+      if (index.columnIndex >= tscGetNumOfColumns(pTableMeta) && UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
         return invalidSqlErrMsg(pQueryInfo->msg, msg1);
       }
 
@@ -1488,7 +1498,7 @@ static int32_t setExprInfoForFunctions(SQueryInfo* pQueryInfo, SSchema* pSchema,
 }
 
 int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprItem* pItem, bool finalResult) {
-  SMeterMetaInfo* pMeterMetaInfo = NULL;
+  STableMetaInfo* pTableMetaInfo = NULL;
   int32_t         optr = pItem->pNode->nSQLOptr;
 
   const char* msg1 = "not support column types";
@@ -1538,10 +1548,10 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprIt
             return invalidSqlErrMsg(pQueryInfo->msg, msg3);
           }
 
-          pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+          pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
 
           // count tag is equalled to count(tbname)
-          if (index.columnIndex >= pMeterMetaInfo->pMeterMeta->numOfColumns) {
+          if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
             index.columnIndex = TSDB_TBNAME_COLUMN_INDEX;
           }
 
@@ -1603,8 +1613,8 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprIt
       }
 
       // 2. check if sql function can be applied on this column data type
-      pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-      SSchema* pSchema = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, index.columnIndex);
+      pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+      SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, index.columnIndex);
       int16_t  colType = pSchema->type;
 
       if (colType <= TSDB_DATA_TYPE_BOOL || colType >= TSDB_DATA_TYPE_BINARY) {
@@ -1637,7 +1647,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprIt
       }
 
       // functions can not be applied to tags
-      if (index.columnIndex >= pMeterMetaInfo->pMeterMeta->numOfColumns) {
+      if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
         return invalidSqlErrMsg(pQueryInfo->msg, msg6);
       }
 
@@ -1711,10 +1721,10 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprIt
               return invalidSqlErrMsg(pQueryInfo->msg, msg4);
             }
 
-            pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-            SSchema* pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+            pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+            SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
-            for (int32_t j = 0; j < pMeterMetaInfo->pMeterMeta->numOfColumns; ++j) {
+            for (int32_t j = 0; j < tscGetNumOfColumns(pTableMetaInfo->pTableMeta); ++j) {
               index.columnIndex = j;
               if (setExprInfoForFunctions(pQueryInfo, pSchema, functionID, pItem->aliasName, colIdx++, &index) != 0) {
                 return TSDB_CODE_INVALID_SQL;
@@ -1726,11 +1736,11 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprIt
               return invalidSqlErrMsg(pQueryInfo->msg, msg3);
             }
 
-            pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-            SSchema* pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+            pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+            SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
             // functions can not be applied to tags
-            if ((index.columnIndex >= pMeterMetaInfo->pMeterMeta->numOfColumns) || (index.columnIndex < 0)) {
+            if ((index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) || (index.columnIndex < 0)) {
               return invalidSqlErrMsg(pQueryInfo->msg, msg6);
             }
 
@@ -1745,10 +1755,10 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprIt
         int32_t numOfFields = 0;
 
         for (int32_t j = 0; j < pQueryInfo->numOfTables; ++j) {
-          pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, j);
-          SSchema* pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+          pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, j);
+          SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
-          for (int32_t i = 0; i < pMeterMetaInfo->pMeterMeta->numOfColumns; ++i) {
+          for (int32_t i = 0; i < tscGetNumOfColumns(pTableMetaInfo->pTableMeta); ++i) {
             SColumnIndex index = {.tableIndex = j, .columnIndex = i};
             if (setExprInfoForFunctions(pQueryInfo, pSchema, functionID, pItem->aliasName, colIdx + i + j, &index) !=
                 0) {
@@ -1756,7 +1766,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprIt
             }
           }
 
-          numOfFields += pMeterMetaInfo->pMeterMeta->numOfColumns;
+          numOfFields += tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
         }
 
         return TSDB_CODE_SUCCESS;
@@ -1782,11 +1792,11 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIdx, tSQLExprIt
         return invalidSqlErrMsg(pQueryInfo->msg, msg3);
       }
 
-      pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-      SSchema* pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+      pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+      SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
       // functions can not be applied to tags
-      if (index.columnIndex >= pMeterMetaInfo->pMeterMeta->numOfColumns) {
+      if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
         return invalidSqlErrMsg(pQueryInfo->msg, msg6);
       }
 
@@ -1916,10 +1926,10 @@ static bool isTablenameToken(SSQLToken* token) {
 }
 
 static int16_t doGetColumnIndex(SQueryInfo* pQueryInfo, int32_t index, SSQLToken* pToken) {
-  STableMeta* pMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index)->pMeterMeta;
+  STableMeta* pTableMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index)->pTableMeta;
 
-  int32_t  numOfCols = pMeterMeta->numOfColumns + pMeterMeta->numOfTags;
-  SSchema* pSchema = tsGetSchema(pMeterMeta);
+  int32_t  numOfCols = tscGetNumOfColumns(pTableMeta) + tscGetNumOfTags(pTableMeta);
+  SSchema* pSchema = tscGetTableSchema(pTableMeta);
 
   int16_t columnIndex = COLUMN_INDEX_INITIAL_VAL;
 
@@ -1991,8 +2001,8 @@ int32_t getMeterIndex(SSQLToken* pTableToken, SQueryInfo* pQueryInfo, SColumnInd
   char tableName[TSDB_TABLE_ID_LEN + 1] = {0};
 
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
-    extractTableName(pMeterMetaInfo->name, tableName);
+    STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
+    extractTableName(pTableMetaInfo->name, tableName);
 
     if (strncasecmp(tableName, pTableToken->z, pTableToken->n) == 0 && strlen(tableName) == pTableToken->n) {
       pIndex->tableIndex = i;
@@ -2115,7 +2125,7 @@ int32_t changeFunctionID(int32_t optr, int16_t* functionId) {
 
 int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   SSqlCmd*        pCmd = &pSql->cmd;
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
   assert(pCmd->numOfClause == 1);
 
   pCmd->command = TSDB_SQL_SHOW;
@@ -2151,7 +2161,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
-      int32_t ret = setObjFullName(pMeterMetaInfo->name, getAccountId(pSql), pDbPrefixToken, NULL, NULL);
+      int32_t ret = setObjFullName(pTableMetaInfo->name, getAccountId(pSql), pDbPrefixToken, NULL, NULL);
       if (ret != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
@@ -2235,13 +2245,13 @@ bool validateIpAddress(const char* ip, size_t size) {
 }
 
 int32_t tscTansformSQLFunctionForSTableQuery(SQueryInfo* pQueryInfo) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-  if (pMeterMetaInfo->pMeterMeta == NULL || !UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  if (pTableMetaInfo->pTableMeta == NULL || !UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     return TSDB_CODE_INVALID_SQL;
   }
 
-  assert(pMeterMetaInfo->pMeterMeta->numOfTags >= 0);
+  assert(tscGetNumOfTags(pTableMetaInfo->pTableMeta) >= 0);
 
   int16_t bytes = 0;
   int16_t type = 0;
@@ -2252,7 +2262,7 @@ int32_t tscTansformSQLFunctionForSTableQuery(SQueryInfo* pQueryInfo) {
     int16_t functionId = aAggs[pExpr->functionId].stableFuncId;
 
     int32_t colIndex = pExpr->colInfo.colIdx;
-    SSchema* pSrcSchema = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, colIndex);
+    SSchema* pSrcSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, colIndex);
     
     if ((functionId >= TSDB_FUNC_SUM && functionId <= TSDB_FUNC_TWA) ||
         (functionId >= TSDB_FUNC_FIRST_DST && functionId <= TSDB_FUNC_LAST_DST) ||
@@ -2274,14 +2284,14 @@ int32_t tscTansformSQLFunctionForSTableQuery(SQueryInfo* pQueryInfo) {
 
 /* transfer the field-info back to original input format */
 void tscRestoreSQLFunctionForMetricQuery(SQueryInfo* pQueryInfo) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  if (!UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  if (!UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     return;
   }
 
   for (int32_t i = 0; i < pQueryInfo->exprsInfo.numOfExprs; ++i) {
     SSqlExpr*   pExpr = tscSqlExprGet(pQueryInfo, i);
-    SSchema* pSchema = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, pExpr->colInfo.colIdx);
+    SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pExpr->colInfo.colIdx);
     
 //    if (/*(pExpr->functionId >= TSDB_FUNC_FIRST_DST && pExpr->functionId <= TSDB_FUNC_LAST_DST) ||
 //        (pExpr->functionId >= TSDB_FUNC_SUM && pExpr->functionId <= TSDB_FUNC_MAX) ||
@@ -2371,7 +2381,7 @@ static bool functionCompatibleCheck(SQueryInfo* pQueryInfo) {
 }
 
 void updateTagColumnIndex(SQueryInfo* pQueryInfo, int32_t tableIndex) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
 
   /*
    * update tags column index for group by tags
@@ -2381,8 +2391,8 @@ void updateTagColumnIndex(SQueryInfo* pQueryInfo, int32_t tableIndex) {
     for (int32_t i = 0; i < pQueryInfo->groupbyExpr.numOfGroupCols; ++i) {
       int32_t index = pQueryInfo->groupbyExpr.columnInfo[i].colIdx;
 
-      for (int32_t j = 0; j < pMeterMetaInfo->numOfTags; ++j) {
-        int32_t tagColIndex = pMeterMetaInfo->tagColumnIndex[j];
+      for (int32_t j = 0; j < pTableMetaInfo->numOfTags; ++j) {
+        int32_t tagColIndex = pTableMetaInfo->tagColumnIndex[j];
         if (tagColIndex == index) {
           pQueryInfo->groupbyExpr.columnInfo[i].colIdx = j;
           break;
@@ -2400,12 +2410,12 @@ void updateTagColumnIndex(SQueryInfo* pQueryInfo, int32_t tableIndex) {
     }
 
     // not belongs to this table
-    if (pExpr->uid != pMeterMetaInfo->pMeterMeta->uid) {
+    if (pExpr->uid != pTableMetaInfo->pTableMeta->uid) {
       continue;
     }
 
-    for (int32_t j = 0; j < pMeterMetaInfo->numOfTags; ++j) {
-      if (pExpr->colInfo.colIdx == pMeterMetaInfo->tagColumnIndex[j]) {
+    for (int32_t j = 0; j < pTableMetaInfo->numOfTags; ++j) {
+      if (pExpr->colInfo.colIdx == pTableMetaInfo->tagColumnIndex[j]) {
         pExpr->colInfo.colIdx = j;
         break;
       }
@@ -2421,17 +2431,17 @@ void updateTagColumnIndex(SQueryInfo* pQueryInfo, int32_t tableIndex) {
   assert(pJoinInfo->left.uid != pJoinInfo->right.uid);
 
   // the join condition expression node belongs to this table(super table)
-  if (pMeterMetaInfo->pMeterMeta->uid == pJoinInfo->left.uid) {
-    for (int32_t i = 0; i < pMeterMetaInfo->numOfTags; ++i) {
-      if (pJoinInfo->left.tagCol == pMeterMetaInfo->tagColumnIndex[i]) {
+  if (pTableMetaInfo->pTableMeta->uid == pJoinInfo->left.uid) {
+    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
+      if (pJoinInfo->left.tagCol == pTableMetaInfo->tagColumnIndex[i]) {
         pJoinInfo->left.tagCol = i;
       }
     }
   }
 
-  if (pMeterMetaInfo->pMeterMeta->uid == pJoinInfo->right.uid) {
-    for (int32_t i = 0; i < pMeterMetaInfo->numOfTags; ++i) {
-      if (pJoinInfo->right.tagCol == pMeterMetaInfo->tagColumnIndex[i]) {
+  if (pTableMetaInfo->pTableMeta->uid == pJoinInfo->right.uid) {
+    for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
+      if (pJoinInfo->right.tagCol == pTableMetaInfo->tagColumnIndex[i]) {
         pJoinInfo->right.tagCol = i;
       }
     }
@@ -2447,7 +2457,7 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd*
   const char* msg9 = "tags not allowed for table query";
 
   // todo : handle two meter situation
-  SMeterMetaInfo* pMeterMetaInfo = NULL;
+  STableMetaInfo* pTableMetaInfo = NULL;
 
   if (pList == NULL) {
     return TSDB_CODE_SUCCESS;
@@ -2458,7 +2468,7 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd*
     return invalidSqlErrMsg(pQueryInfo->msg, msg1);
   }
 
-  STableMeta* pMeterMeta = NULL;
+  STableMeta* pTableMeta = NULL;
   SSchema*    pSchema = NULL;
   SSchema     s = tsGetTbnameColumnSchema();
 
@@ -2480,28 +2490,28 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, tVariantList* pList, SSqlCmd*
 
     tableIndex = index.tableIndex;
 
-    pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-    pMeterMeta = pMeterMetaInfo->pMeterMeta;
+    pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+    pTableMeta = pTableMetaInfo->pTableMeta;
 
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
       pSchema = &s;
     } else {
-      pSchema = tsGetColumnSchema(pMeterMeta, index.columnIndex);
+      pSchema = tscGetTableColumnSchema(pTableMeta, index.columnIndex);
     }
 
     bool groupTag = false;
-    if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX || index.columnIndex >= pMeterMeta->numOfColumns) {
+    if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX || index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
       groupTag = true;
     }
 
     if (groupTag) {
-      if (!UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+      if (!UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
         return invalidSqlErrMsg(pQueryInfo->msg, msg9);
       }
 
       int32_t relIndex = index.columnIndex;
       if (index.columnIndex != TSDB_TBNAME_COLUMN_INDEX) {
-        relIndex -= pMeterMeta->numOfColumns;
+        relIndex -= tscGetNumOfColumns(pTableMeta);
       }
 
       pQueryInfo->groupbyExpr.columnInfo[i] =
@@ -2561,9 +2571,9 @@ static int32_t doExtractColumnFilterInfo(SQueryInfo* pQueryInfo, SColumnFilterIn
   const char* msg = "not supported filter condition";
 
   tSQLExpr*       pRight = pExpr->pRight;
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, columnIndex->tableIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, columnIndex->tableIndex);
 
-  SSchema* pSchema = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, columnIndex->columnIndex);
+  SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex->columnIndex);
 
   int16_t colType = pSchema->type;
   if (colType >= TSDB_DATA_TYPE_TINYINT && colType <= TSDB_DATA_TYPE_BIGINT) {
@@ -2806,10 +2816,10 @@ enum {
 };
 
 static int32_t extractColumnFilterInfo(SQueryInfo* pQueryInfo, SColumnIndex* pIndex, tSQLExpr* pExpr, int32_t sqlOptr) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pIndex->tableIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pIndex->tableIndex);
 
-  STableMeta* pMeterMeta = pMeterMetaInfo->pMeterMeta;
-  SSchema*    pSchema = tsGetColumnSchema(pMeterMeta, pIndex->columnIndex);
+  STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+  SSchema*    pSchema = tscGetTableColumnSchema(pTableMeta, pIndex->columnIndex);
 
   const char* msg1 = "non binary column not support like operator";
   const char* msg2 = "binary column not support this operator";
@@ -2966,24 +2976,24 @@ static int32_t getJoinCondInfo(SQueryInfo* pQueryInfo, tSQLExpr* pExpr) {
     return TSDB_CODE_INVALID_SQL;
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-  int16_t         tagColIndex = index.columnIndex - pMeterMetaInfo->pMeterMeta->numOfColumns;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+  int16_t         tagColIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
 
-  pLeft->uid = pMeterMetaInfo->pMeterMeta->uid;
+  pLeft->uid = pTableMetaInfo->pTableMeta->uid;
   pLeft->tagCol = tagColIndex;
-  strcpy(pLeft->tableId, pMeterMetaInfo->name);
+  strcpy(pLeft->tableId, pTableMetaInfo->name);
 
   index = (SColumnIndex)COLUMN_INDEX_INITIALIZER;
   if (getColumnIndexByName(&pExpr->pRight->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_INVALID_SQL;
   }
 
-  pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-  tagColIndex = index.columnIndex - pMeterMetaInfo->pMeterMeta->numOfColumns;
+  pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+  tagColIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
 
-  pRight->uid = pMeterMetaInfo->pMeterMeta->uid;
+  pRight->uid = pTableMetaInfo->pTableMeta->uid;
   pRight->tagCol = tagColIndex;
-  strcpy(pRight->tableId, pMeterMetaInfo->name);
+  strcpy(pRight->tableId, pTableMetaInfo->name);
 
   pTagCond->joinInfo.hasJoin = true;
   return TSDB_CODE_SUCCESS;
@@ -3035,8 +3045,9 @@ static int32_t validateSQLExpr(tSQLExpr* pExpr, SQueryInfo* pQueryInfo, SColumnL
     }
 
     // if column is timestamp, bool, binary, nchar, not support arithmetic, so return invalid sql
-    STableMeta* pMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex)->pMeterMeta;
-    SSchema*    pSchema = tsGetSchema(pMeterMeta) + index.columnIndex;
+    STableMeta* pTableMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex)->pTableMeta;
+    SSchema*    pSchema = tscGetTableSchema(pTableMeta) + index.columnIndex;
+    
     if ((pSchema->type == TSDB_DATA_TYPE_TIMESTAMP) || (pSchema->type == TSDB_DATA_TYPE_BOOL) ||
         (pSchema->type == TSDB_DATA_TYPE_BINARY) || (pSchema->type == TSDB_DATA_TYPE_NCHAR)) {
       return TSDB_CODE_INVALID_SQL;
@@ -3183,12 +3194,12 @@ static bool validateJoinExprNode(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, SColum
   }
 
   // todo extract function
-  SMeterMetaInfo* pLeftMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pLeftIndex->tableIndex);
-  SSchema*        pLeftSchema = tsGetSchema(pLeftMeterMeta->pMeterMeta);
+  STableMetaInfo* pLeftMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pLeftIndex->tableIndex);
+  SSchema*        pLeftSchema = tscGetTableSchema(pLeftMeterMeta->pTableMeta);
   int16_t         leftType = pLeftSchema[pLeftIndex->columnIndex].type;
 
-  SMeterMetaInfo* pRightMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, rightIndex.tableIndex);
-  SSchema*        pRightSchema = tsGetSchema(pRightMeterMeta->pMeterMeta);
+  STableMetaInfo* pRightMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, rightIndex.tableIndex);
+  SSchema*        pRightSchema = tscGetTableSchema(pRightMeterMeta->pTableMeta);
   int16_t         rightType = pRightSchema[rightIndex.columnIndex].type;
 
   if (leftType != rightType) {
@@ -3259,8 +3270,8 @@ static int32_t handleExprInQueryCond(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, S
 
   assert(isExprDirectParentOfLeaftNode(*pExpr));
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-  STableMeta*     pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+  STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
 
   if (index.columnIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX) {  // query on time range
     if (!validateJoinExprNode(pQueryInfo, *pExpr, &index)) {
@@ -3283,10 +3294,10 @@ static int32_t handleExprInQueryCond(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, S
 
     *pExpr = NULL;  // remove this expression
     *type = TSQL_EXPR_TS;
-  } else if (index.columnIndex >= pMeterMeta->numOfColumns ||
+  } else if (index.columnIndex >= tscGetNumOfColumns(pTableMeta) ||
              index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {  // query on tags
     // check for tag query condition
-    if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
+    if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg1);
     }
 
@@ -3296,7 +3307,7 @@ static int32_t handleExprInQueryCond(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, S
         return TSDB_CODE_INVALID_SQL;
       }
 
-      SSchema* pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+      SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
       if ((!isTablenameToken(&pLeft->colInfo)) && pSchema[index.columnIndex].type != TSDB_DATA_TYPE_BINARY &&
           pSchema[index.columnIndex].type != TSDB_DATA_TYPE_NCHAR) {
@@ -3494,10 +3505,10 @@ static int32_t setTableCondForMetricQuery(SQueryInfo* pQueryInfo, const char* ac
     return TSDB_CODE_SUCCESS;
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableCondIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableCondIndex);
 
   STagCond* pTagCond = &pQueryInfo->tagCond;
-  pTagCond->tbnameCond.uid = pMeterMetaInfo->pMeterMeta->uid;
+  pTagCond->tbnameCond.uid = pTableMetaInfo->pTableMeta->uid;
 
   assert(pExpr->nSQLOptr == TK_LIKE || pExpr->nSQLOptr == TK_IN);
 
@@ -3527,7 +3538,7 @@ static int32_t setTableCondForMetricQuery(SQueryInfo* pQueryInfo, const char* ac
   }
   num = j;
 
-  SSQLToken dbToken = extractDBName(pMeterMetaInfo->name, db);
+  SSQLToken dbToken = extractDBName(pTableMetaInfo->name, db);
 
   for (int32_t i = 0; i < num; ++i) {
     if (i >= 1) {
@@ -3604,15 +3615,15 @@ static int32_t getTimeRangeFromExpr(SQueryInfo* pQueryInfo, tSQLExpr* pExpr) {
       return TSDB_CODE_INVALID_SQL;
     }
 
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
-    STableMeta*     pMeterMeta = pMeterMetaInfo->pMeterMeta;
+    STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+    STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
     
     tSQLExpr* pRight = pExpr->pRight;
 
     TSKEY stime = 0;
     TSKEY etime = INT64_MAX;
 
-    if (getTimeRange(&stime, &etime, pRight, pExpr->nSQLOptr, pMeterMeta->precision) != TSDB_CODE_SUCCESS) {
+    if (getTimeRange(&stime, &etime, pRight, pExpr->nSQLOptr, tinfo.precision) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg0);
     }
 
@@ -3642,8 +3653,8 @@ static int32_t validateJoinExpr(SQueryInfo* pQueryInfo, SCondExpr* pCondExpr) {
     }
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {  // for stable join, tag columns
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {  // for stable join, tag columns
                                                    // must be present for join
     if (pCondExpr->pJoinExpr == NULL) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg1);
@@ -3680,20 +3691,20 @@ static void cleanQueryExpr(SCondExpr* pCondExpr) {
 }
 
 static void doAddJoinTagsColumnsIntoTagList(SQueryInfo* pQueryInfo, SCondExpr* pCondExpr) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  if (QUERY_IS_JOIN_QUERY(pQueryInfo->type) && UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  if (QUERY_IS_JOIN_QUERY(pQueryInfo->type) && UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     SColumnIndex index = {0};
 
     getColumnIndexByName(&pCondExpr->pJoinExpr->pLeft->colInfo, pQueryInfo, &index);
-    pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+    pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
 
-    int32_t columnInfo = index.columnIndex - pMeterMetaInfo->pMeterMeta->numOfColumns;
+    int32_t columnInfo = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
     addRequiredTagColumn(pQueryInfo, columnInfo, index.tableIndex);
 
     getColumnIndexByName(&pCondExpr->pJoinExpr->pRight->colInfo, pQueryInfo, &index);
-    pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
+    pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index.tableIndex);
 
-    columnInfo = index.columnIndex - pMeterMetaInfo->pMeterMeta->numOfColumns;
+    columnInfo = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
     addRequiredTagColumn(pQueryInfo, columnInfo, index.tableIndex);
   }
 }
@@ -3705,7 +3716,7 @@ static int32_t getTagQueryCondExpr(SQueryInfo* pQueryInfo, SCondExpr* pCondExpr,
     for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
       tSQLExpr* p1 = extractExprForSTable(pExpr, pQueryInfo, i);
 
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
+      STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
 
       char  c[TSDB_MAX_TAGS_LEN] = {0};
       char* str = c;
@@ -3714,7 +3725,7 @@ static int32_t getTagQueryCondExpr(SQueryInfo* pQueryInfo, SCondExpr* pCondExpr,
         return ret;
       }
 
-      tsSetMetricQueryCond(&pQueryInfo->tagCond, pMeterMetaInfo->pMeterMeta->uid, c);
+      tsSetMetricQueryCond(&pQueryInfo->tagCond, pTableMetaInfo->pTableMeta->uid, c);
 
       doCompactQueryExpr(pExpr);
       tSQLExprDestroy(p1);
@@ -4019,7 +4030,7 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) {
 static void setDefaultOrderInfo(SQueryInfo* pQueryInfo) {
   /* set default timestamp order information for all queries */
   pQueryInfo->order.order = TSQL_SO_ASC;
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   if (isTopBottomQuery(pQueryInfo)) {
     pQueryInfo->order.order = TSQL_SO_ASC;
@@ -4029,7 +4040,7 @@ static void setDefaultOrderInfo(SQueryInfo* pQueryInfo) {
   }
 
   /* for metric query, set default ascending order for group output */
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     pQueryInfo->groupbyExpr.orderType = TSQL_SO_ASC;
   }
 }
@@ -4041,7 +4052,7 @@ int32_t parseOrderbyClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema
   const char* msg3 = "only support order by primary timestamp and first tag in groupby clause";
 
   setDefaultOrderInfo(pQueryInfo);
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   if (pQuerySql->pSortOrder == NULL) {
     return TSDB_CODE_SUCCESS;
@@ -4055,7 +4066,7 @@ int32_t parseOrderbyClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema
    *
    * for super table query, the order option must be less than 3.
    */
-  if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
     if (pSortorder->nExpr > 1) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg0);
     }
@@ -4076,7 +4087,7 @@ int32_t parseOrderbyClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema
   SSQLToken    columnName = {pVar->nLen, pVar->nType, pVar->pz};
   SColumnIndex index = {0};
 
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {  // metric query
+  if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {  // metric query
     if (getColumnIndexByName(&columnName, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg1);
     }
@@ -4084,8 +4095,8 @@ int32_t parseOrderbyClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema
     bool orderByTags = false;
     bool orderByTS = false;
 
-    if (index.columnIndex >= pMeterMetaInfo->pMeterMeta->numOfColumns) {
-      int32_t relTagIndex = index.columnIndex - pMeterMetaInfo->pMeterMeta->numOfColumns;
+    if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
+      int32_t relTagIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
       if (relTagIndex == pQueryInfo->groupbyExpr.columnInfo[0].colIdx) {
         orderByTags = true;
       }
@@ -4105,7 +4116,7 @@ int32_t parseOrderbyClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema
 
     if (pSortorder->nExpr == 1) {
       if (orderByTags) {
-        pQueryInfo->groupbyExpr.orderIndex = index.columnIndex - pMeterMetaInfo->pMeterMeta->numOfColumns;
+        pQueryInfo->groupbyExpr.orderIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
         pQueryInfo->groupbyExpr.orderType = pQuerySql->pSortOrder->a[0].sortOrder;
       } else if (isTopBottomQuery(pQueryInfo)) {
         /* order of top/bottom query in interval is not valid  */
@@ -4128,7 +4139,7 @@ int32_t parseOrderbyClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema
 
     if (pSortorder->nExpr == 2) {
       if (orderByTags) {
-        pQueryInfo->groupbyExpr.orderIndex = index.columnIndex - pMeterMetaInfo->pMeterMeta->numOfColumns;
+        pQueryInfo->groupbyExpr.orderIndex = index.columnIndex - tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
         pQueryInfo->groupbyExpr.orderType = pQuerySql->pSortOrder->a[0].sortOrder;
       } else {
         pQueryInfo->order.order = pSortorder->a[0].sortOrder;
@@ -4193,32 +4204,32 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   SAlterTableSQL* pAlterSQL = pInfo->pAlterInfo;
   SQueryInfo*     pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, DEFAULT_TABLE_INDEX);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, DEFAULT_TABLE_INDEX);
 
   if (tscValidateName(&(pAlterSQL->name)) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg1);
   }
 
-  if (setMeterID(pMeterMetaInfo, &(pAlterSQL->name), pSql) != TSDB_CODE_SUCCESS) {
+  if (setMeterID(pTableMetaInfo, &(pAlterSQL->name), pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg2);
   }
 
-  int32_t ret = tscGetMeterMeta(pSql, pMeterMetaInfo);
+  int32_t ret = tscGetMeterMeta(pSql, pTableMetaInfo);
   if (ret != TSDB_CODE_SUCCESS) {
     return ret;
   }
 
-  STableMeta* pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
 
   if (pAlterSQL->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN ||
       pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) {
-    if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
+    if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg3);
     }
-  } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) && (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo))) {
+  } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) && (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo))) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg4);
   } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_ADD_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_DROP_COLUMN) &&
-             UTIL_METER_IS_CREATE_FROM_METRIC(pMeterMetaInfo)) {
+             UTIL_METER_IS_CREATE_FROM_METRIC(pTableMetaInfo)) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg6);
   }
 
@@ -4240,7 +4251,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     const char* msg4 = "illegal tag name";
     const char* msg5 = "primary tag cannot be dropped";
 
-    if (pMeterMeta->numOfTags == 1) {
+    if (tscGetNumOfTags(pTableMeta) == 1) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg1);
     }
 
@@ -4261,7 +4272,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       return TSDB_CODE_INVALID_SQL;
     }
 
-    if (index.columnIndex < pMeterMeta->numOfColumns) {
+    if (index.columnIndex < tscGetNumOfColumns(pTableMeta)) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg4);
     } else if (index.columnIndex == 0) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg5);
@@ -4327,11 +4338,11 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       return TSDB_CODE_INVALID_SQL;
     }
 
-    if (columnIndex.columnIndex < pMeterMeta->numOfColumns) {
+    if (columnIndex.columnIndex < tscGetNumOfColumns(pTableMeta)) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg2);
     }
 
-    SSchema* pTagsSchema = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, columnIndex.columnIndex);
+    SSchema* pTagsSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex.columnIndex);
     if (tVariantDump(&pVarList->a[1].pVar, pAlterSQL->tagData.data /*pCmd->payload*/, pTagsSchema->type) !=
         TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg1);
@@ -4366,7 +4377,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     const char* msg4 = "illegal column name";
     const char* msg3 = "primary timestamp column cannot be dropped";
 
-    if (pMeterMeta->numOfColumns == TSDB_MIN_COLUMNS) {  //
+    if (tscGetNumOfColumns(pTableMeta) == TSDB_MIN_COLUMNS) {  //
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
@@ -4586,7 +4597,7 @@ bool hasTimestampForPointInterpQuery(SQueryInfo* pQueryInfo) {
 }
 
 int32_t parseLimitClause(SQueryInfo* pQueryInfo, int32_t clauseIndex, SQuerySQL* pQuerySql, SSqlObj* pSql) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   const char* msg0 = "soffset/offset can not be less than 0";
   const char* msg1 = "slimit/soffset only available for STable query";
@@ -4611,7 +4622,7 @@ int32_t parseLimitClause(SQueryInfo* pQueryInfo, int32_t clauseIndex, SQuerySQL*
     return TSDB_CODE_SUCCESS;
   }
 
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     bool queryOnTags = false;
     if (tscQueryOnlyMetricTags(pQueryInfo, &queryOnTags) != TSDB_CODE_SUCCESS) {
       return TSDB_CODE_INVALID_SQL;
@@ -4650,8 +4661,8 @@ int32_t parseLimitClause(SQueryInfo* pQueryInfo, int32_t clauseIndex, SQuerySQL*
     }
 
     // No tables included. No results generated. Query results are empty.
-    SSuperTableMeta* pMetricMeta = pMeterMetaInfo->pMetricMeta;
-    if (pMeterMetaInfo->pMeterMeta == NULL || pMetricMeta == NULL || pMetricMeta->numOfTables == 0) {
+    SSuperTableMeta* pMetricMeta = pTableMetaInfo->pMetricMeta;
+    if (pTableMetaInfo->pTableMeta == NULL || pMetricMeta == NULL || pMetricMeta->numOfTables == 0) {
       tscTrace("%p no table in metricmeta, no output result", pSql);
       pQueryInfo->command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
     }
@@ -4807,10 +4818,10 @@ void addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClau
     SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, num - 1);
 
     if (pExpr->functionId != TSDB_FUNC_TAG) {
-      SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
-      int16_t         columnInfo = tscGetJoinTagColIndexByUid(&pQueryInfo->tagCond, pMeterMetaInfo->pMeterMeta->uid);
+      STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
+      int16_t         columnInfo = tscGetJoinTagColIndexByUid(&pQueryInfo->tagCond, pTableMetaInfo->pTableMeta->uid);
       SColumnIndex    index = {.tableIndex = 0, .columnIndex = columnInfo};
-      SSchema*        pSchema = tsGetTagSchema(pMeterMetaInfo->pMeterMeta);
+      SSchema*        pSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
 
       int16_t type = pSchema[index.columnIndex].type;
       int16_t bytes = pSchema[index.columnIndex].bytes;
@@ -4844,9 +4855,9 @@ static void doLimitOutputNormalColOfGroupby(SSqlExpr* pExpr) {
 void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex) {
   int32_t index = pQueryInfo->groupbyExpr.columnInfo[tagIndex].colIdx;
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-  SSchema*     pSchema = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, index);
+  SSchema*     pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, index);
   SColumnIndex colIndex = {.tableIndex = 0, .columnIndex = index};
 
   SSqlExpr* pExpr = tscSqlExprInsert(pQueryInfo, pQueryInfo->exprsInfo.numOfExprs, TSDB_FUNC_PRJ, &colIndex,
@@ -4878,8 +4889,8 @@ static void doUpdateSqlFunctionForTagPrj(SQueryInfo* pQueryInfo) {
     }
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  SSchema*        pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  SSchema*        pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
   for (int32_t i = 0; i < pQueryInfo->exprsInfo.numOfExprs; ++i) {
     SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
@@ -5054,9 +5065,9 @@ static int32_t checkUpdateTagPrjFunctions(SQueryInfo* pQueryInfo) {
 static int32_t doAddGroupbyColumnsOnDemand(SQueryInfo* pQueryInfo) {
   const char* msg2 = "interval not allowed in group by normal column";
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-  SSchema* pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+  SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
   int16_t  bytes = 0;
   int16_t  type = 0;
   char*    name = NULL;
@@ -5070,7 +5081,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SQueryInfo* pQueryInfo) {
       bytes = TSDB_TABLE_NAME_LEN;
       name = TSQL_TBNAME_L;
     } else {
-      colIndex = (TSDB_COL_IS_TAG(pColIndex->flag)) ? pMeterMetaInfo->pMeterMeta->numOfColumns + pColIndex->colIdx
+      colIndex = (TSDB_COL_IS_TAG(pColIndex->flag)) ? tscGetNumOfColumns(pTableMetaInfo->pTableMeta) + pColIndex->colIdx
                                                     : pColIndex->colIdx;
 
       type = pSchema[colIndex].type;
@@ -5364,7 +5375,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
 
   SSqlCmd*        pCmd = &pSql->cmd;
   SQueryInfo*     pQueryInfo = tscGetQueryInfoDetail(pCmd, subClauseIndex);
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   SCreateTableSQL* pCreateTable = pInfo->pCreateTableInfo;
 
@@ -5380,7 +5391,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  if (setMeterID(pMeterMetaInfo, pzTableName, pSql) != TSDB_CODE_SUCCESS) {
+  if (setMeterID(pTableMetaInfo, pzTableName, pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
@@ -5425,7 +5436,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
   const int32_t TABLE_INDEX = 0;
   const int32_t STABLE_INDEX = 1;
 
-  SMeterMetaInfo* pStableMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, STABLE_INDEX);
+  STableMetaInfo* pStableMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, STABLE_INDEX);
 
   // super table name, create table by using dst
   SSQLToken* pToken = &(pCreateTable->usingInfo.stableName);
@@ -5447,12 +5458,12 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     return code;
   }
 
-  if (pStableMeterMetaInfo->pMeterMeta->numOfTags != pList->nExpr) {
+  if (tscGetNumOfTags(pStableMeterMetaInfo->pTableMeta) != pList->nExpr) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
   }
 
   // too long tag values will return invalid sql, not be truncated automatically
-  SSchema* pTagSchema = tsGetTagSchema(pStableMeterMetaInfo->pMeterMeta);
+  SSchema* pTagSchema = tscGetTableTagSchema(pStableMeterMetaInfo->pTableMeta);
 
   char* tagVal = pCreateTable->usingInfo.tagdata.data;
   for (int32_t i = 0; i < pList->nExpr; ++i) {
@@ -5475,7 +5486,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  SMeterMetaInfo* pTableMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, TABLE_INDEX);
+  STableMetaInfo* pTableMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, TABLE_INDEX);
   int32_t         ret = setMeterID(pTableMeterMetaInfo, &pInfo->pCreateTableInfo->name, pSql);
   if (ret != TSDB_CODE_SUCCESS) {
     return ret;
@@ -5496,7 +5507,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   assert(pQueryInfo->numOfTables == 1);
 
   SCreateTableSQL* pCreateTable = pInfo->pCreateTableInfo;
-  SMeterMetaInfo*  pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo*  pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   // if sql specifies db, use it, otherwise use default db
   SSQLToken* pzTableName = &(pCreateTable->name);
@@ -5514,16 +5525,16 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg1);
   }
 
-  if (setMeterID(pMeterMetaInfo, &srcToken, pSql) != TSDB_CODE_SUCCESS) {
+  if (setMeterID(pTableMetaInfo, &srcToken, pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg2);
   }
 
-  int32_t code = tscGetMeterMeta(pSql, pMeterMetaInfo);
+  int32_t code = tscGetMeterMeta(pSql, pTableMetaInfo);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
 
-  bool isSTable = UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo);
+  bool isSTable = UTIL_METER_IS_SUPERTABLE(pTableMetaInfo);
   if (parseSelectClause(&pSql->cmd, 0, pQuerySql->pSelection, isSTable) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_INVALID_SQL;
   }
@@ -5545,7 +5556,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   }
 
   // set the created table[stream] name
-  if (setMeterID(pMeterMetaInfo, pzTableName, pSql) != TSDB_CODE_SUCCESS) {
+  if (setMeterID(pTableMetaInfo, pzTableName, pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg1);
   }
 
@@ -5603,9 +5614,9 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
   SSqlCmd* pCmd = &pSql->cmd;
 
   SQueryInfo*     pQueryInfo = tscGetQueryInfoDetail(pCmd, index);
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  if (pMeterMetaInfo == NULL) {
-    pMeterMetaInfo = tscAddEmptyMeterMetaInfo(pQueryInfo);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  if (pTableMetaInfo == NULL) {
+    pTableMetaInfo = tscAddEmptyMeterMetaInfo(pQueryInfo);
   }
 
   // too many result columns not support order by in query
@@ -5651,7 +5662,7 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
       tscAddEmptyMeterMetaInfo(pQueryInfo);
     }
 
-    SMeterMetaInfo* pMeterInfo1 = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
+    STableMetaInfo* pMeterInfo1 = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
 
     SSQLToken t = {.type = TSDB_DATA_TYPE_BINARY, .n = pTableItem->nLen, .z = pTableItem->pz};
     if (setMeterID(pMeterInfo1, &t, pSql) != TSDB_CODE_SUCCESS) {
@@ -5671,7 +5682,7 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
     return TSDB_CODE_INVALID_SQL;
   }
 
-  bool isSTable = UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo);
+  bool isSTable = UTIL_METER_IS_SUPERTABLE(pTableMetaInfo);
   if (parseSelectClause(pCmd, index, pQuerySql->pSelection, isSTable) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_INVALID_SQL;
   }
@@ -5687,19 +5698,20 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
   }
 
   // set order by info
-  if (parseOrderbyClause(pQueryInfo, pQuerySql, tsGetSchema(pMeterMetaInfo->pMeterMeta)) != TSDB_CODE_SUCCESS) {
+  if (parseOrderbyClause(pQueryInfo, pQuerySql, tscGetTableSchema(pTableMetaInfo->pTableMeta)) != TSDB_CODE_SUCCESS) {
     return TSDB_CODE_INVALID_SQL;
   }
 
   // set where info
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+  
   if (pQuerySql->pWhere != NULL) {
     if (parseWhereClause(pQueryInfo, &pQuerySql->pWhere, pSql) != TSDB_CODE_SUCCESS) {
       return TSDB_CODE_INVALID_SQL;
     }
 
     pQuerySql->pWhere = NULL;
-
-    if (pMeterMetaInfo->pMeterMeta->precision == TSDB_TIME_PRECISION_MILLI) {
+    if (tinfo.precision == TSDB_TIME_PRECISION_MILLI) {
       pQueryInfo->stime = pQueryInfo->stime / 1000;
       pQueryInfo->etime = pQueryInfo->etime / 1000;
     }
@@ -5710,8 +5722,7 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
 
   // user does not specified the query time window, twa is not allowed in such case.
   if ((pQueryInfo->stime == 0 || pQueryInfo->etime == INT64_MAX ||
-       (pQueryInfo->etime == INT64_MAX / 1000 && pMeterMetaInfo->pMeterMeta->precision == TSDB_TIME_PRECISION_MILLI)) &&
-      tscIsTWAQuery(pQueryInfo)) {
+       (pQueryInfo->etime == INT64_MAX / 1000 && tinfo.precision == TSDB_TIME_PRECISION_MILLI)) && tscIsTWAQuery(pQueryInfo)) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
   }
 

src/client/src/tscSchemaUtil.c

@@ -19,6 +19,70 @@
 #include "ttokendef.h"
 #include "taosdef.h"
 #include "tutil.h"
+#include "tsclient.h"
+
+int32_t tscGetNumOfTags(const STableMeta* pTableMeta) {
+  assert(pTableMeta != NULL);
+  
+  STableInfo tinfo = tscGetTableInfo(pTableMeta);
+  
+  if (pTableMeta->tableType == TSDB_NORMAL_TABLE) {
+    assert(tinfo.numOfTags == 0);
+    return 0;
+  }
+  
+  if (pTableMeta->tableType == TSDB_SUPER_TABLE || pTableMeta->tableType == TSDB_CHILD_TABLE) {
+    assert(tinfo.numOfTags > 0);
+    return tinfo.numOfTags;
+  }
+  
+  assert(tinfo.numOfTags == 0);
+  return 0;
+}
+
+int32_t tscGetNumOfColumns(const STableMeta* pTableMeta) {
+  assert(pTableMeta != NULL);
+  
+  // table created according to super table, use data from super table
+  STableInfo tinfo = tscGetTableInfo(pTableMeta);
+  assert(tinfo.numOfColumns >= 2);
+  
+  return tinfo.numOfColumns;
+}
+
+SSchema *tscGetTableSchema(const STableMeta *pTableMeta) {
+  assert(pTableMeta != NULL);
+  
+  if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
+    STableMeta* pSTableMeta = pTableMeta->pSTable;
+    assert (pSTableMeta != NULL);
+    
+    return pSTableMeta->schema;
+  }
+  
+  return pTableMeta->schema;
+}
+
+SSchema* tscGetTableTagSchema(const STableMeta* pTableMeta) {
+  assert(pTableMeta != NULL && (pTableMeta->tableType == TSDB_SUPER_TABLE || pTableMeta->tableType == TSDB_CHILD_TABLE));
+  
+  STableInfo tinfo = tscGetTableInfo(pTableMeta);
+  assert(tinfo.numOfTags > 0);
+  
+  return tscGetTableColumnSchema(pTableMeta, tinfo.numOfColumns);
+}
+
+STableInfo tscGetTableInfo(const STableMeta* pTableMeta) {
+  assert(pTableMeta != NULL);
+  
+  if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
+    assert (pTableMeta->pSTable != NULL);
+    return pTableMeta->pSTable->tableInfo;
+  }
+  
+  return pTableMeta->tableInfo;
+}
+
 
 bool isValidSchema(struct SSchema* pSchema, int32_t numOfCols) {
   if (!VALIDNUMOFCOLS(numOfCols)) {
@@ -64,34 +128,32 @@ bool isValidSchema(struct SSchema* pSchema, int32_t numOfCols) {
   return (rowLen <= TSDB_MAX_BYTES_PER_ROW);
 }
 
-struct SSchema* tsGetSchema(STableMeta* pMeta) {
-  if (pMeta == NULL) {
-    return NULL;
-  }
-  return tsGetColumnSchema(pMeta, 0);
-}
+SSchema* tscGetTableColumnSchema(const STableMeta* pTableMeta, int32_t startCol) {
+  assert(pTableMeta != NULL);
   
-struct SSchema* tsGetTagSchema(STableMeta* pMeta) {
-  if (pMeta == NULL || pMeta->numOfTags == 0) {
-    return NULL;
-  }
+  SSchema* pSchema = pTableMeta->schema;
   
-  return tsGetColumnSchema(pMeta, pMeta->numOfColumns);
-}
+  if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
+    assert (pTableMeta->pSTable != NULL);
+    pSchema = pTableMeta->pSTable->schema;
+  }
   
-struct SSchema* tsGetColumnSchema(STableMeta* pMeta, int32_t startCol) {
-  return (SSchema*)(((char*)pMeta + sizeof(STableMeta)) + startCol * sizeof(SSchema));
+  return &pSchema[startCol];
 }
 
 struct SSchema tsGetTbnameColumnSchema() {
-  struct SSchema s = {.colId = TSDB_TBNAME_COLUMN_INDEX, .type = TSDB_DATA_TYPE_BINARY, .bytes = TSDB_TABLE_NAME_LEN};
-  strcpy(s.name, TSQL_TBNAME_L);
+  struct SSchema s = {
+      .colId = TSDB_TBNAME_COLUMN_INDEX,
+      .type  = TSDB_DATA_TYPE_BINARY,
+      .bytes = TSDB_TABLE_NAME_LEN
+  };
   
+  strcpy(s.name, TSQL_TBNAME_L);
   return s;
 }
 
 /**
- * the MeterMeta data format in memory is as follows:
+ * the TableMeta data format in memory is as follows:
  *
  * +--------------------+
  * |STableMeta Body data|  sizeof(STableMeta)
@@ -101,33 +163,35 @@ struct SSchema tsGetTbnameColumnSchema() {
  * |Tags data           |  tag_col_1.bytes + tag_col_2.bytes + ....
  * +--------------------+
  *
- * @param pMeta
+ * @param pTableMeta
  * @return
  */
-char* tsGetTagsValue(STableMeta* pMeta) {
-  int32_t  numOfTotalCols = pMeta->numOfColumns + pMeta->numOfTags;
-  uint32_t offset = sizeof(STableMeta) + numOfTotalCols * sizeof(SSchema);
+char* tsGetTagsValue(STableMeta* pTableMeta) {
+  int32_t offset = 0;
+//  int32_t  numOfTotalCols = pTableMeta->numOfColumns + pTableMeta->numOfTags;
+//  uint32_t offset = sizeof(STableMeta) + numOfTotalCols * sizeof(SSchema);
 
-  return ((char*)pMeta + offset);
+  return ((char*)pTableMeta + offset);
 }
 
 bool tsMeterMetaIdentical(STableMeta* p1, STableMeta* p2) {
   if (p1 == NULL || p2 == NULL || p1->uid != p2->uid || p1->sversion != p2->sversion) {
     return false;
   }
-
-  if (p1 == p2) {
+//
+//  if (p1 == p2) {
+//    return true;
+//  }
+//
+//  size_t size = sizeof(STableMeta) + p1->numOfColumns * sizeof(SSchema);
+//
+//  for (int32_t i = 0; i < p1->numOfTags; ++i) {
+//    SSchema* pColSchema = tscGetTableColumnSchema(p1, i + p1->numOfColumns);
+//    size += pColSchema->bytes;
+//  }
+
+//  return memcmp(p1, p2, size) == 0;
  return true;
-  }
-
-  size_t size = sizeof(STableMeta) + p1->numOfColumns * sizeof(SSchema);
-
-  for (int32_t i = 0; i < p1->numOfTags; ++i) {
-    SSchema* pColSchema = tsGetColumnSchema(p1, i + p1->numOfColumns);
-    size += pColSchema->bytes;
-  }
-
-  return memcmp(p1, p2, size) == 0;
 }
 
 // todo refactor

src/client/src/tscSecondaryMerge.c

@@ -319,9 +319,10 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
   pRes->pLocalReducer = pReducer;
   pRes->numOfGroups = 0;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  int16_t         prec = pMeterMetaInfo->pMeterMeta->precision;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   
+  int16_t prec = tinfo.precision;
   int64_t stime = (pQueryInfo->stime < pQueryInfo->etime) ? pQueryInfo->stime : pQueryInfo->etime;
   int64_t revisedSTime =
       taosGetIntervalStartTimestamp(stime, pQueryInfo->intervalTime, pQueryInfo->intervalTimeUnit, prec);
@@ -602,9 +603,9 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
   *pFinalModel = NULL;
 
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-  (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * pMeterMetaInfo->pMetricMeta->numOfVnodes);
+  (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * pTableMetaInfo->pMetricMeta->numOfVnodes);
   if (*pMemBuffer == NULL) {
     tscError("%p failed to allocate memory", pSql);
     pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY;
@@ -635,7 +636,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
 
   pModel = createColumnModel(pSchema, pQueryInfo->exprsInfo.numOfExprs, capacity);
 
-  for (int32_t i = 0; i < pMeterMetaInfo->pMetricMeta->numOfVnodes; ++i) {
+  for (int32_t i = 0; i < pTableMetaInfo->pMetricMeta->numOfVnodes; ++i) {
     (*pMemBuffer)[i] = createExtMemBuffer(nBufferSizes, rlen, pModel);
     (*pMemBuffer)[i]->flushModel = MULTIPLE_APPEND_MODEL;
   }
@@ -650,7 +651,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
   for (int32_t i = 0; i < pQueryInfo->exprsInfo.numOfExprs; ++i) {
     SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
 
-    SSchema *p1 = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, pExpr->colInfo.colIdx);
+    SSchema *p1 = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pExpr->colInfo.colIdx);
 
     int16_t inter = 0;
     int16_t type = -1;
@@ -774,9 +775,11 @@ void adjustLoserTreeFromNewData(SLocalReducer *pLocalReducer, SLocalDataSource *
 void savePrevRecordAndSetupInterpoInfo(SLocalReducer *pLocalReducer, SQueryInfo *pQueryInfo,
                                        SInterpolationInfo *pInterpoInfo) {
   // discard following dataset in the same group and reset the interpolation information
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  int16_t         prec = pMeterMetaInfo->pMeterMeta->precision;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+  
+  int16_t prec = tinfo.precision;
   int64_t stime = (pQueryInfo->stime < pQueryInfo->etime) ? pQueryInfo->stime : pQueryInfo->etime;
   int64_t revisedSTime =
       taosGetIntervalStartTimestamp(stime, pQueryInfo->intervalTime, pQueryInfo->intervalTimeUnit, prec);
@@ -917,8 +920,10 @@ static void doInterpolateResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, boo
     functions[i] = tscSqlExprGet(pQueryInfo, i)->functionId;
   }
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  int8_t          precision = pMeterMetaInfo->pMeterMeta->precision;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+  
+  int8_t precision = tinfo.precision;
 
   while (1) {
     int32_t remains = taosNumOfRemainPoints(pInterpoInfo);
@@ -1268,8 +1273,10 @@ static void resetEnvForNewResultset(SSqlRes *pRes, SSqlCmd *pCmd, SLocalReducer
 
   pQueryInfo->limit.offset = pLocalReducer->offset;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  int16_t         precision = pMeterMetaInfo->pMeterMeta->precision;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+  
+  int8_t precision = tinfo.precision;
 
   // for group result interpolation, do not return if not data is generated
   if (pQueryInfo->interpoType != TSDB_INTERPO_NONE) {
@@ -1294,8 +1301,10 @@ static bool doInterpolationForCurrentGroup(SSqlObj *pSql) {
   SLocalReducer *     pLocalReducer = pRes->pLocalReducer;
   SInterpolationInfo *pInterpoInfo = &pLocalReducer->interpolationInfo;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  int8_t          p = pMeterMetaInfo->pMeterMeta->precision;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+  
+  int8_t p = tinfo.precision;
 
   if (taosHasRemainsDataForInterpolation(pInterpoInfo)) {
     assert(pQueryInfo->interpoType != TSDB_INTERPO_NONE);
@@ -1328,8 +1337,10 @@ static bool doHandleLastRemainData(SSqlObj *pSql) {
   bool prevGroupCompleted = (!pLocalReducer->discard) && pLocalReducer->hasUnprocessedRow;
 
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  int8_t          precision = pMeterMetaInfo->pMeterMeta->precision;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+  int8_t precision = tinfo.precision;
 
   if ((isAllSourcesCompleted(pLocalReducer) && !pLocalReducer->hasPrevRow) || pLocalReducer->pLocalDataSrc[0] == NULL ||
       prevGroupCompleted) {

src/client/src/tscServer.c

@@ -236,7 +236,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg) {
   if (rpcMsg->pCont == NULL) {
     rpcMsg->code = TSDB_CODE_NETWORK_UNAVAIL;
   } else {
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+    STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
     if (rpcMsg->code == TSDB_CODE_NOT_ACTIVE_TABLE || rpcMsg->code == TSDB_CODE_INVALID_TABLE_ID ||
         rpcMsg->code == TSDB_CODE_INVALID_VNODE_ID || rpcMsg->code == TSDB_CODE_NOT_ACTIVE_VNODE ||
         rpcMsg->code == TSDB_CODE_NETWORK_UNAVAIL || rpcMsg->code == TSDB_CODE_NOT_ACTIVE_SESSION ||
@@ -265,9 +265,9 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg) {
         pSql->maxRetry = TSDB_VNODES_SUPPORT * 2;
         pSql->res.code = rpcMsg->code;  // keep the previous error code
 
-        rpcMsg->code = tscRenewMeterMeta(pSql, pMeterMetaInfo->name);
+        rpcMsg->code = tscRenewMeterMeta(pSql, pTableMetaInfo->name);
 
-        if (pMeterMetaInfo->pMeterMeta) {
+        if (pTableMetaInfo->pTableMeta) {
           tscSendMsgToServer(pSql);
           rpcFreeCont(rpcMsg->pCont);
           return;
@@ -436,8 +436,8 @@ int32_t tscLaunchJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSubquerySu
     // set the tags value for ts_comp function
     SSqlExpr *pExpr = tscSqlExprGet(pNewQueryInfo, 0);
 
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pNewQueryInfo, 0);
-    int16_t         tagColIndex = tscGetJoinTagColIndexByUid(&pSupporter->tagCond, pMeterMetaInfo->pMeterMeta->uid);
+    STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pNewQueryInfo, 0);
+    int16_t         tagColIndex = tscGetJoinTagColIndexByUid(&pSupporter->tagCond, pTableMetaInfo->pTableMeta->uid);
 
     pExpr->param->i64Key = tagColIndex;
     pExpr->numOfParams = 1;
@@ -453,14 +453,14 @@ int32_t tscLaunchJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSubquerySu
   
     tscTrace("%p subquery:%p tableIndex:%d, vnodeIdx:%d, type:%d, transfer to ts_comp query to retrieve timestamps, "
              "exprInfo:%d, colList:%d, fieldsInfo:%d, name:%s",
-             pSql, pNew, tableIndex, pMeterMetaInfo->vnodeIndex, pNewQueryInfo->type,
+             pSql, pNew, tableIndex, pTableMetaInfo->vnodeIndex, pNewQueryInfo->type,
              pNewQueryInfo->exprsInfo.numOfExprs, pNewQueryInfo->colList.numOfCols,
              pNewQueryInfo->fieldsInfo.numOfOutputCols, pNewQueryInfo->pMeterInfo[0]->name);
     tscPrintSelectClause(pNew, 0);
   
     tscTrace("%p subquery:%p tableIndex:%d, vnodeIdx:%d, type:%d, transfer to ts_comp query to retrieve timestamps, "
              "exprInfo:%d, colList:%d, fieldsInfo:%d, name:%s",
-             pSql, pNew, tableIndex, pMeterMetaInfo->vnodeIndex, pNewQueryInfo->type,
+             pSql, pNew, tableIndex, pTableMetaInfo->vnodeIndex, pNewQueryInfo->type,
              pNewQueryInfo->exprsInfo.numOfExprs, pNewQueryInfo->colList.numOfCols,
              pNewQueryInfo->fieldsInfo.numOfOutputCols, pNewQueryInfo->pMeterInfo[0]->name);
     tscPrintSelectClause(pNew, 0);
@@ -517,13 +517,13 @@ int tscProcessSql(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
   
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
-  SMeterMetaInfo *pMeterMetaInfo = NULL;
+  STableMetaInfo *pTableMetaInfo = NULL;
   int16_t         type = 0;
 
   if (pQueryInfo != NULL) {
-    pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-    if (pMeterMetaInfo != NULL) {
-      name = pMeterMetaInfo->name;
+    pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+    if (pTableMetaInfo != NULL) {
+      name = pTableMetaInfo->name;
     }
 
     type = pQueryInfo->type;
@@ -534,21 +534,21 @@ int tscProcessSql(SSqlObj *pSql) {
 
   tscTrace("%p SQL cmd:%d will be processed, name:%s, type:%d", pSql, pCmd->command, name, type);
   if (pSql->cmd.command < TSDB_SQL_MGMT) {
-    // the pMeterMetaInfo cannot be NULL
-    if (pMeterMetaInfo == NULL) {
+    // the pTableMetaInfo cannot be NULL
+    if (pTableMetaInfo == NULL) {
       pSql->res.code = TSDB_CODE_OTHERS;
       return pSql->res.code;
     }
 
     // temp
     pSql->ipList = &tscMgmtIpList;
-//    if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
-//      pSql->index = pMeterMetaInfo->pMeterMeta->index;
+//    if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
+//      pSql->index = pTableMetaInfo->pTableMeta->index;
 //    } else {  // it must be the parent SSqlObj for super table query
 //      if ((pQueryInfo->type & TSDB_QUERY_TYPE_SUBQUERY) != 0) {
-//        int32_t idx = pMeterMetaInfo->vnodeIndex;
+//        int32_t idx = pTableMetaInfo->vnodeIndex;
 //
-//        SVnodeSidList *pSidList = tscGetVnodeSidList(pMeterMetaInfo->pMetricMeta, idx);
+//        SVnodeSidList *pSidList = tscGetVnodeSidList(pTableMetaInfo->pMetricMeta, idx);
 //        pSql->index = pSidList->index;
 //      }
 //    }
@@ -668,8 +668,8 @@ int tscLaunchSTableSubqueries(SSqlObj *pSql) {
   const uint32_t nBufferSize = (1 << 16);  // 64KB
 
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  int32_t         numOfSubQueries = pMeterMetaInfo->pMetricMeta->numOfVnodes;
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  int32_t         numOfSubQueries = pTableMetaInfo->pMetricMeta->numOfVnodes;
   assert(numOfSubQueries > 0);
 
   int32_t ret = tscLocalReducerEnvCreate(pSql, &pMemoryBuf, &pDesc, &pModel, nBufferSize);
@@ -929,9 +929,9 @@ void tscRetrieveFromVnodeCallBack(void *param, TAOS_RES *tres, int numOfRows) {
   SSqlRes *   pRes = &pSql->res;
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-  SVnodeSidList *vnodeInfo = tscGetVnodeSidList(pMeterMetaInfo->pMetricMeta, idx);
+  SVnodeSidList *vnodeInfo = tscGetVnodeSidList(pTableMetaInfo->pMetricMeta, idx);
   SVnodeDesc *   pSvd = &vnodeInfo->vpeerDesc[vnodeInfo->index];
 
   if (numOfRows > 0) {
@@ -1110,8 +1110,8 @@ static SSqlObj *tscCreateSqlObjForSubquery(SSqlObj *pSql, SRetrieveSupport *trsu
     assert(pQueryInfo->numOfTables == 1 && pNew->cmd.numOfClause == 1);
 
     // launch subquery for each vnode, so the subquery index equals to the vnodeIndex.
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, table_index);
-    pMeterMetaInfo->vnodeIndex = trsupport->subqueryIndex;
+    STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, table_index);
+    pTableMetaInfo->vnodeIndex = trsupport->subqueryIndex;
 
     pSql->pSubs[trsupport->subqueryIndex] = pNew;
   }
@@ -1125,15 +1125,15 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
   SSqlObj*  pParentSql = trsupport->pParentSqlObj;
   SSqlObj*  pSql = (SSqlObj *)tres;
   
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
   assert(pSql->cmd.numOfClause == 1 && pSql->cmd.pQueryInfo[0]->numOfTables == 1);
   
-  int32_t idx = pMeterMetaInfo->vnodeIndex;
+  int32_t idx = pTableMetaInfo->vnodeIndex;
 
   SVnodeSidList *vnodeInfo = NULL;
   SVnodeDesc *   pSvd = NULL;
-  if (pMeterMetaInfo->pMetricMeta != NULL) {
-    vnodeInfo = tscGetVnodeSidList(pMeterMetaInfo->pMetricMeta, idx);
+  if (pTableMetaInfo->pMetricMeta != NULL) {
+    vnodeInfo = tscGetVnodeSidList(pTableMetaInfo->pMetricMeta, idx);
     pSvd = &vnodeInfo->vpeerDesc[vnodeInfo->index];
   }
 
@@ -1176,7 +1176,7 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
         trsupport->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY;
       } else {
         SQueryInfo *pNewQueryInfo = tscGetQueryInfoDetail(&pNew->cmd, 0);
-        assert(pNewQueryInfo->pMeterInfo[0]->pMeterMeta != NULL && pNewQueryInfo->pMeterInfo[0]->pMetricMeta != NULL);
+        assert(pNewQueryInfo->pMeterInfo[0]->pTableMeta != NULL && pNewQueryInfo->pMeterInfo[0]->pMetricMeta != NULL);
         tscProcessSql(pNew);
         return;
       }
@@ -1231,16 +1231,16 @@ int tscBuildRetrieveMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 void tscUpdateVnodeInSubmitMsg(SSqlObj *pSql, char *buf) {
   //SShellSubmitMsg *pShellMsg;
   //char *           pMsg;
-  //SMeterMetaInfo * pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, 0);
+  //STableMetaInfo * pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, 0);
 
-  //STableMeta *pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  //STableMeta *pTableMeta = pTableMetaInfo->pTableMeta;
 
   //pMsg = buf + tsRpcHeadSize;
 
   //TODO set iplist
   //pShellMsg = (SShellSubmitMsg *)pMsg;
-  //pShellMsg->vnode = htons(pMeterMeta->vpeerDesc[pSql->index].vnode);
-  //tscTrace("%p update submit msg vnode:%s:%d", pSql, taosIpStr(pMeterMeta->vpeerDesc[pSql->index].ip),
+  //pShellMsg->vnode = htons(pTableMeta->vpeerDesc[pSql->index].vnode);
+  //tscTrace("%p update submit msg vnode:%s:%d", pSql, taosIpStr(pTableMeta->vpeerDesc[pSql->index].ip),
   //         htons(pShellMsg->vnode));
 }
 
@@ -1248,10 +1248,7 @@ int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SShellSubmitMsg *pShellMsg;
   char *           pMsg, *pStart;
 
-  SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-
-  STableMeta *pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
   
   pStart = pSql->cmd.payload + tsRpcHeadSize;
   pMsg = pStart;
@@ -1259,13 +1256,13 @@ int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pShellMsg = (SShellSubmitMsg *)pMsg;
 
   pShellMsg->import = htons(TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT) ? 0 : 1);
-  pShellMsg->vnode = 0; //htons(pMeterMeta->vpeerDesc[pMeterMeta->index].vnode);
+  pShellMsg->vnode = 0; //htons(pTableMeta->vpeerDesc[pTableMeta->index].vnode);
   pShellMsg->numOfSid = htonl(pSql->cmd.numOfTablesInSubmit);  // number of meters to be inserted
 
   // pSql->cmd.payloadLen is set during parse sql routine, so we do not use it here
   pSql->cmd.msgType = TSDB_MSG_TYPE_SUBMIT;
-  tscTrace("%p update submit msg vnode:%s:%d", pSql, taosIpStr(pMeterMeta->vpeerDesc[pMeterMeta->index].ip),
-           htons(pShellMsg->vnode));
+//  tscTrace("%p update submit msg vnode:%s:%d", pSql, taosIpStr(pTableMeta->vpeerDesc[pTableMeta->index].ip),
+//           htons(pShellMsg->vnode));
 
   pSql->cmd.payloadLen = sizeof(SShellSubmitMsg);
 
@@ -1275,17 +1272,17 @@ int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 void tscUpdateVnodeInQueryMsg(SSqlObj *pSql, char *buf) {
   //TODO
 //  SSqlCmd *       pCmd = &pSql->cmd;
-//  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+//  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
 //
 //  char *          pStart = buf + tsRpcHeadSize;
 //  SQueryTableMsg *pQueryMsg = (SQueryTableMsg *)pStart;
 //
-//  if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {  // pColumnModel == NULL, query on meter
-//    STableMeta *pMeterMeta = pMeterMetaInfo->pMeterMeta;
-//    pQueryMsg->vnode = htons(pMeterMeta->vpeerDesc[pSql->index].vnode);
+//  if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {  // pColumnModel == NULL, query on meter
+//    STableMeta *pTableMeta = pTableMetaInfo->pTableMeta;
+//    pQueryMsg->vnode = htons(pTableMeta->vpeerDesc[pSql->index].vnode);
 //  } else {  // query on metric
-//    SSuperTableMeta *  pMetricMeta = pMeterMetaInfo->pMetricMeta;
-//    SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pMeterMetaInfo->vnodeIndex);
+//    SSuperTableMeta *  pMetricMeta = pTableMetaInfo->pMetricMeta;
+//    SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pTableMetaInfo->vnodeIndex);
 //    pQueryMsg->vnode = htons(pVnodeSidList->vpeerDesc[pSql->index].vnode);
 //  }
 }
@@ -1301,15 +1298,15 @@ static int32_t tscEstimateQueryMsgSize(SSqlCmd *pCmd, int32_t clauseIndex) {
   int32_t srcColListSize = pQueryInfo->colList.numOfCols * sizeof(SColumnInfo);
 
   int32_t         exprSize = sizeof(SSqlFuncExprMsg) * pQueryInfo->exprsInfo.numOfExprs;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   // meter query without tags values
-  if (!UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  if (!UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     return MIN_QUERY_MSG_PKT_SIZE + minMsgSize() + sizeof(SQueryTableMsg) + srcColListSize + exprSize;
   }
 
-  SSuperTableMeta *pMetricMeta = pMeterMetaInfo->pMetricMeta;
-  SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pMeterMetaInfo->vnodeIndex);
+  SSuperTableMeta *pMetricMeta = pTableMetaInfo->pMetricMeta;
+  SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pTableMetaInfo->vnodeIndex);
 
   int32_t meterInfoSize = (pMetricMeta->tagLen + sizeof(STableSidExtInfo)) * pVnodeSidList->numOfSids;
   int32_t outputColumnSize = pQueryInfo->exprsInfo.numOfExprs * sizeof(SSqlFuncExprMsg);
@@ -1323,23 +1320,23 @@ static int32_t tscEstimateQueryMsgSize(SSqlCmd *pCmd, int32_t clauseIndex) {
 }
 
 static char *doSerializeTableInfo(SSqlObj *pSql, int32_t numOfTables, int32_t vnodeId, char *pMsg) {
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, 0);
 
-  STableMeta * pMeterMeta = pMeterMetaInfo->pMeterMeta;
-  SSuperTableMeta *pMetricMeta = pMeterMetaInfo->pMetricMeta;
+  STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
+  SSuperTableMeta *pMetricMeta = pTableMetaInfo->pMetricMeta;
 
   tscTrace("%p vid:%d, query on %d meters", pSql, vnodeId, numOfTables);
-  if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
 #ifdef _DEBUG_VIEW
-    tscTrace("%p sid:%d, uid:%" PRIu64, pSql, pMeterMetaInfo->pMeterMeta->sid, pMeterMetaInfo->pMeterMeta->uid);
+    tscTrace("%p sid:%d, uid:%" PRIu64, pSql, pTableMetaInfo->pTableMeta->sid, pTableMetaInfo->pTableMeta->uid);
 #endif
     STableSidExtInfo *pMeterInfo = (STableSidExtInfo *)pMsg;
-    pMeterInfo->sid = htonl(pMeterMeta->sid);
-    pMeterInfo->uid = htobe64(pMeterMeta->uid);
-    pMeterInfo->key = htobe64(tscGetSubscriptionProgress(pSql->pSubscription, pMeterMeta->uid));
+    pMeterInfo->sid = htonl(pTableMeta->sid);
+    pMeterInfo->uid = htobe64(pTableMeta->uid);
+    pMeterInfo->key = htobe64(tscGetSubscriptionProgress(pSql->pSubscription, pTableMeta->uid));
     pMsg += sizeof(STableSidExtInfo);
   } else {
-    SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pMeterMetaInfo->vnodeIndex);
+    SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pTableMetaInfo->vnodeIndex);
 
     for (int32_t i = 0; i < numOfTables; ++i) {
       STableSidExtInfo *pMeterInfo = (STableSidExtInfo *)pMsg;
@@ -1374,34 +1371,34 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   
   char *          pStart = pCmd->payload + tsRpcHeadSize;
 
-  STableMeta * pMeterMeta = pMeterMetaInfo->pMeterMeta;
-  SSuperTableMeta *pMetricMeta = pMeterMetaInfo->pMetricMeta;
+  STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
+  SSuperTableMeta *pMetricMeta = pTableMetaInfo->pMetricMeta;
 
   SQueryTableMsg *pQueryMsg = (SQueryTableMsg *)pStart;
 
   int32_t msgLen = 0;
   int32_t numOfTables = 0;
 
-  if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
     numOfTables = 1;
 
-    tscTrace("%p query on vnode: %d, number of sid:%d, meter id: %s", pSql,
-             pMeterMeta->vpeerDesc[pMeterMeta->index].vnode, 1, pMeterMetaInfo->name);
+//    tscTrace("%p query on vnode: %d, number of sid:%d, meter id: %s", pSql,
+//             pTableMeta->vpeerDesc[pTableMeta->index].vnode, 1, pTableMetaInfo->name);
 
-    pQueryMsg->vnode = htons(pMeterMeta->vpeerDesc[pMeterMeta->index].vnode);
-    pQueryMsg->uid = pMeterMeta->uid;
+//    pQueryMsg->vnode = htons(pTableMeta->vpeerDesc[pTableMeta->index].vnode);
+    pQueryMsg->uid = pTableMeta->uid;
     pQueryMsg->numOfTagsCols = 0;
   } else {  // query on super table
-    if (pMeterMetaInfo->vnodeIndex < 0) {
-      tscError("%p error vnodeIdx:%d", pSql, pMeterMetaInfo->vnodeIndex);
+    if (pTableMetaInfo->vnodeIndex < 0) {
+      tscError("%p error vnodeIdx:%d", pSql, pTableMetaInfo->vnodeIndex);
       return -1;
     }
 
-    SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pMeterMetaInfo->vnodeIndex);
+    SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, pTableMetaInfo->vnodeIndex);
     uint32_t       vnodeId = pVnodeSidList->vpeerDesc[pVnodeSidList->index].vnode;
 
     numOfTables = pVnodeSidList->numOfSids;
@@ -1415,7 +1412,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   pQueryMsg->numOfSids = htonl(numOfTables);
-  pQueryMsg->numOfTagsCols = htons(pMeterMetaInfo->numOfTags);
+  pQueryMsg->numOfTagsCols = htons(pTableMetaInfo->numOfTags);
 
   if (pQueryInfo->order.order == TSQL_SO_ASC) {
     pQueryMsg->skey = htobe64(pQueryInfo->stime);
@@ -1436,12 +1433,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pQueryMsg->numOfCols = htons(pQueryInfo->colList.numOfCols);
 
   if (pQueryInfo->colList.numOfCols <= 0) {
-    tscError("%p illegal value of numOfCols in query msg: %d", pSql, pMeterMeta->numOfColumns);
-    return -1;
-  }
-
-  if (pMeterMeta->numOfTags < 0) {
-    tscError("%p illegal value of numOfTagsCols in query msg: %d", pSql, pMeterMeta->numOfTags);
+    tscError("%p illegal value of numOfCols in query msg: %d", pSql, tscGetNumOfColumns(pTableMeta));
     return -1;
   }
 
@@ -1461,7 +1453,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   pQueryMsg->numOfGroupCols = htons(pQueryInfo->groupbyExpr.numOfGroupCols);
 
-  if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {  // query on meter
+  if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {  // query on meter
     pQueryMsg->tagLength = 0;
   } else {  // query on metric
     pQueryMsg->tagLength = htons(pMetricMeta->tagLen);
@@ -1478,16 +1470,16 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   // set column list ids
   char *   pMsg = (char *)(pQueryMsg->colList) + pQueryInfo->colList.numOfCols * sizeof(SColumnInfo);
-  SSchema *pSchema = tsGetSchema(pMeterMeta);
+  SSchema *pSchema = tscGetTableSchema(pTableMeta);
 
   for (int32_t i = 0; i < pQueryInfo->colList.numOfCols; ++i) {
     SColumnBase *pCol = tscColumnBaseInfoGet(&pQueryInfo->colList, i);
     SSchema *    pColSchema = &pSchema[pCol->colIndex.columnIndex];
 
-    if (pCol->colIndex.columnIndex >= pMeterMeta->numOfColumns || pColSchema->type < TSDB_DATA_TYPE_BOOL ||
+    if (pCol->colIndex.columnIndex >= tscGetNumOfColumns(pTableMeta) || pColSchema->type < TSDB_DATA_TYPE_BOOL ||
         pColSchema->type > TSDB_DATA_TYPE_NCHAR) {
       tscError("%p vid:%d sid:%d id:%s, column index out of range, numOfColumns:%d, index:%d, column name:%s", pSql,
-               htons(pQueryMsg->vnode), pMeterMeta->sid, pMeterMetaInfo->name, pMeterMeta->numOfColumns, pCol->colIndex,
+               htons(pQueryMsg->vnode), pTableMeta->sid, pTableMetaInfo->name, tscGetNumOfColumns(pTableMeta), pCol->colIndex,
                pColSchema->name);
 
       return -1;  // 0 means build msg failed
@@ -1537,7 +1529,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       hasArithmeticFunction = true;
     }
 
-    if (!tscValidateColumnId(pMeterMetaInfo, pExpr->colInfo.colId)) {
+    if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId)) {
       /* column id is not valid according to the cached metermeta, the meter meta is expired */
       tscError("%p table schema is not matched with parsed sql", pSql);
       return -1;
@@ -1588,17 +1580,17 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pMsg = doSerializeTableInfo(pSql, numOfTables, htons(pQueryMsg->vnode), pMsg);
 
   // only include the required tag column schema. If a tag is not required, it won't be sent to vnode
-  if (pMeterMetaInfo->numOfTags > 0) {
+  if (pTableMetaInfo->numOfTags > 0) {
     // always transfer tag schema to vnode if exists
-    SSchema *pTagSchema = tsGetTagSchema(pMeterMeta);
+    SSchema *pTagSchema = tscGetTableTagSchema(pTableMeta);
 
-    for (int32_t j = 0; j < pMeterMetaInfo->numOfTags; ++j) {
-      if (pMeterMetaInfo->tagColumnIndex[j] == TSDB_TBNAME_COLUMN_INDEX) {
+    for (int32_t j = 0; j < pTableMetaInfo->numOfTags; ++j) {
+      if (pTableMetaInfo->tagColumnIndex[j] == TSDB_TBNAME_COLUMN_INDEX) {
         SSchema tbSchema = {
             .bytes = TSDB_TABLE_NAME_LEN, .colId = TSDB_TBNAME_COLUMN_INDEX, .type = TSDB_DATA_TYPE_BINARY};
         memcpy(pMsg, &tbSchema, sizeof(SSchema));
       } else {
-        memcpy(pMsg, &pTagSchema[pMeterMetaInfo->tagColumnIndex[j]], sizeof(SSchema));
+        memcpy(pMsg, &pTagSchema[pTableMetaInfo->tagColumnIndex[j]], sizeof(SSchema));
       }
 
       pMsg += sizeof(SSchema);
@@ -1643,7 +1635,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   int32_t numOfBlocks = 0;
 
   if (pQueryInfo->tsBuf != NULL) {
-    STSVnodeBlockInfo *pBlockInfo = tsBufGetVnodeBlockInfo(pQueryInfo->tsBuf, pMeterMetaInfo->vnodeIndex);
+    STSVnodeBlockInfo *pBlockInfo = tsBufGetVnodeBlockInfo(pQueryInfo->tsBuf, pTableMetaInfo->vnodeIndex);
     assert(QUERY_IS_JOIN_QUERY(pQueryInfo->type) && pBlockInfo != NULL);  // this query should not be sent
 
     // todo refactor
@@ -1685,8 +1677,8 @@ int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SCMCreateDbMsg *pCreateDbMsg = (SCMCreateDbMsg*)pCmd->payload;
 
   assert(pCmd->numOfClause == 1);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  strncpy(pCreateDbMsg->db, pMeterMetaInfo->name, tListLen(pCreateDbMsg->db));
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  strncpy(pCreateDbMsg->db, pTableMetaInfo->name, tListLen(pCreateDbMsg->db));
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1807,8 +1799,8 @@ int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   SCMDropDbMsg *pDropDbMsg = (SCMDropDbMsg*)pCmd->payload;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  strncpy(pDropDbMsg->db, pMeterMetaInfo->name, tListLen(pDropDbMsg->db));
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  strncpy(pDropDbMsg->db, pTableMetaInfo->name, tListLen(pDropDbMsg->db));
   pDropDbMsg->ignoreNotExists = pInfo->pDCLInfo->existsCheck ? 1 : 0;
 
   pCmd->msgType = TSDB_MSG_TYPE_CM_DROP_DB;
@@ -1825,8 +1817,8 @@ int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   SCMDropTableMsg *pDropTableMsg = (SCMDropTableMsg*)pCmd->payload;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  strcpy(pDropTableMsg->tableId, pMeterMetaInfo->name);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  strcpy(pDropTableMsg->tableId, pTableMetaInfo->name);
   pDropTableMsg->igNotExists = pInfo->pDCLInfo->existsCheck ? 1 : 0;
 
   pCmd->msgType = TSDB_MSG_TYPE_CM_DROP_TABLE;
@@ -1842,8 +1834,8 @@ int32_t tscBuildDropDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   SCMDropDnodeMsg *pDrop = (SCMDropDnodeMsg *)pCmd->payload;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  strcpy(pDrop->ip, pMeterMetaInfo->name);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  strcpy(pDrop->ip, pTableMetaInfo->name);
   pCmd->msgType = TSDB_MSG_TYPE_CM_DROP_DNODE;
 
   return TSDB_CODE_SUCCESS;
@@ -1860,8 +1852,8 @@ int32_t tscBuildDropAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   SCMDropUserMsg *pDropMsg = (SCMDropUserMsg*)pCmd->payload;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  strcpy(pDropMsg->user, pMeterMetaInfo->name);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  strcpy(pDropMsg->user, pTableMetaInfo->name);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1876,8 +1868,8 @@ int32_t tscBuildUseDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   SCMUseDbMsg *pUseDbMsg = (SCMUseDbMsg*)pCmd->payload;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  strcpy(pUseDbMsg->db, pMeterMetaInfo->name);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  strcpy(pUseDbMsg->db, pTableMetaInfo->name);
   pCmd->msgType = TSDB_MSG_TYPE_CM_USE_DB;
 
   return TSDB_CODE_SUCCESS;
@@ -1896,10 +1888,10 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   SCMShowMsg *pShowMsg = (SCMShowMsg*)pCmd->payload;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  size_t nameLen = strlen(pMeterMetaInfo->name);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  size_t nameLen = strlen(pTableMetaInfo->name);
   if (nameLen > 0) {
-    strcpy(pShowMsg->db, pMeterMetaInfo->name);  // prefix is set here
+    strcpy(pShowMsg->db, pTableMetaInfo->name);  // prefix is set here
   } else {
     strcpy(pShowMsg->db, pObj->db);
   }
@@ -1976,7 +1968,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
 
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   // Reallocate the payload size
   size = tscEstimateCreateTableMsgLength(pSql, pInfo);
@@ -1987,10 +1979,10 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
 
   SCMCreateTableMsg *pCreateTableMsg = (SCMCreateTableMsg *)pCmd->payload;
-  strcpy(pCreateTableMsg->tableId, pMeterMetaInfo->name);
+  strcpy(pCreateTableMsg->tableId, pTableMetaInfo->name);
 
   // use dbinfo from table id without modifying current db info
-  tscGetDBInfoFromMeterId(pMeterMetaInfo->name, pCreateTableMsg->db);
+  tscGetDBInfoFromMeterId(pTableMetaInfo->name, pCreateTableMsg->db);
 
   SCreateTableSQL *pCreateTable = pInfo->pCreateTableInfo;
 
@@ -2055,7 +2047,7 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *   pCmd = &pSql->cmd;
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   size = tscEstimateAlterTableMsgLength(pCmd);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
@@ -2065,11 +2057,11 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   pAlterTableMsg = (SCMAlterTableMsg *)pCmd->payload;
 
-  tscGetDBInfoFromMeterId(pMeterMetaInfo->name, pAlterTableMsg->db);
+  tscGetDBInfoFromMeterId(pTableMetaInfo->name, pAlterTableMsg->db);
 
   SAlterTableSQL *pAlterInfo = pInfo->pAlterInfo;
 
-  strcpy(pAlterTableMsg->tableId, pMeterMetaInfo->name);
+  strcpy(pAlterTableMsg->tableId, pTableMetaInfo->name);
   pAlterTableMsg->type = htons(pAlterInfo->type);
 
   pAlterTableMsg->numOfCols = htons(tscNumOfFields(pQueryInfo));
@@ -2107,8 +2099,8 @@ int tscAlterDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   SCMAlterDbMsg *pAlterDbMsg = (SCMAlterDbMsg*)pCmd->payload;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  strcpy(pAlterDbMsg->db, pMeterMetaInfo->name);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  strcpy(pAlterDbMsg->db, pTableMetaInfo->name);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -2182,10 +2174,11 @@ static int tscLocalResultCommonBuilder(SSqlObj *pSql, int32_t numOfRes) {
 
 int tscProcessDescribeTableRsp(SSqlObj *pSql) {
   SSqlCmd *       pCmd = &pSql->cmd;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
 
-  int32_t numOfRes = pMeterMetaInfo->pMeterMeta->numOfColumns + pMeterMetaInfo->pMeterMeta->numOfTags;
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   
+  int32_t numOfRes = tinfo.numOfColumns + tinfo.numOfTags;
   return tscLocalResultCommonBuilder(pSql, numOfRes);
 }
 
@@ -2193,11 +2186,11 @@ int tscProcessTagRetrieveRsp(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
 
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   int32_t numOfRes = 0;
   if (tscSqlExprGet(pQueryInfo, 0)->functionId == TSDB_FUNC_TAGPRJ) {
-    numOfRes = pMeterMetaInfo->pMetricMeta->numOfTables;
+    numOfRes = pTableMetaInfo->pMetricMeta->numOfTables;
   } else {
     numOfRes = 1;  // for count function, there is only one output.
   }
@@ -2273,10 +2266,10 @@ int tscBuildMeterMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *   pCmd = &pSql->cmd;
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   pInfoMsg = (SCMTableInfoMsg *)pCmd->payload;
-  strcpy(pInfoMsg->tableId, pMeterMetaInfo->name);
+  strcpy(pInfoMsg->tableId, pTableMetaInfo->name);
   pInfoMsg->createFlag = htons(pSql->cmd.createOnDemand ? 1 : 0);
 
   pMsg = (char*)pInfoMsg + sizeof(SCMTableInfoMsg);
@@ -2372,7 +2365,7 @@ int tscBuildMetricMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   STagCond *pTagCond = &pQueryInfo->tagCond;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
 
   int32_t size = tscEstimateMetricMetaMsgSize(pCmd);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
@@ -2384,7 +2377,7 @@ int tscBuildMetricMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pMsg = pStart;
 
   SMgmtHead *pMgmt = (SMgmtHead *)pMsg;
-  tscGetDBInfoFromMeterId(pMeterMetaInfo->name, pMgmt->db);
+  tscGetDBInfoFromMeterId(pTableMetaInfo->name, pMgmt->db);
 
   pMsg += sizeof(SMgmtHead);
 
@@ -2412,8 +2405,8 @@ int tscBuildMetricMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pMsg += sizeof(int16_t);
 
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
-    pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, i);
-    uint64_t uid = pMeterMetaInfo->pMeterMeta->uid;
+    pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, i);
+    uint64_t uid = pTableMetaInfo->pTableMeta->uid;
 
     offset = pMsg - (char *)pMetaMsg;
     pMetaMsg->metaElem[i] = htonl(offset);
@@ -2466,8 +2459,8 @@ int tscBuildMetricMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       pElem->numOfGroupCols = 0;
     } else {
       pElem->numOfGroupCols = htons(pGroupby->numOfGroupCols);
-      for (int32_t j = 0; j < pMeterMetaInfo->numOfTags; ++j) {
-        pElem->tagCols[j] = htons(pMeterMetaInfo->tagColumnIndex[j]);
+      for (int32_t j = 0; j < pTableMetaInfo->numOfTags; ++j) {
+        pElem->tagCols[j] = htons(pTableMetaInfo->tagColumnIndex[j]);
       }
 
       if (pGroupby->numOfGroupCols != 0) {
@@ -2491,8 +2484,8 @@ int tscBuildMetricMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       }
     }
 
-    strcpy(pElem->tableId, pMeterMetaInfo->name);
-    pElem->numOfTags = htons(pMeterMetaInfo->numOfTags);
+    strcpy(pElem->tableId, pTableMetaInfo->name);
+    pElem->numOfTags = htons(pTableMetaInfo->numOfTags);
 
     int16_t len = pMsg - (char *)pElem;
     pElem->elemLen = htons(len);  // redundant data for integrate check
@@ -2564,10 +2557,10 @@ int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 }
 
 int tscProcessMeterMetaRsp(SSqlObj *pSql) {
-  STableMeta *pMeta;
+  STableMetaMsg *pMeta;
   SSchema *   pSchema;
 
-  pMeta = (STableMeta *)pSql->res.pRsp;
+  pMeta = (STableMetaMsg *)pSql->res.pRsp;
 
   pMeta->sid = htonl(pMeta->sid);
   pMeta->sversion = htons(pMeta->sversion);
@@ -2596,7 +2589,7 @@ int tscProcessMeterMetaRsp(SSqlObj *pSql) {
     pMeta->vpeerDesc[i].vnode = htonl(pMeta->vpeerDesc[i].vnode);
   }
 
-  pMeta->rowSize = 0;
+  int32_t rowSize = 0;
   pSchema = (SSchema *)(pSql->res.pRsp + sizeof(STableMeta));
 
   int32_t numOfTotalCols = pMeta->numOfColumns + pMeta->numOfTags;
@@ -2606,7 +2599,7 @@ int tscProcessMeterMetaRsp(SSqlObj *pSql) {
 
     // ignore the tags length
     if (i < pMeta->numOfColumns) {
-      pMeta->rowSize += pSchema->bytes;
+      rowSize += pSchema->bytes;
     }
     pSchema++;
   }
@@ -2614,7 +2607,7 @@ int tscProcessMeterMetaRsp(SSqlObj *pSql) {
 //  rsp += numOfTotalCols * sizeof(SSchema);
 //
 //  int32_t  tagLen = 0;
-//  SSchema *pTagsSchema = tsGetTagSchema(pMeta);
+//  SSchema *pTagsSchema = tscGetTableTagSchema(pMeta);
 //
 //  if (pMeta->tableType == TSDB_CHILD_TABLE) {
 //    for (int32_t i = 0; i < pMeta->numOfTags; ++i) {
@@ -2629,13 +2622,13 @@ int tscProcessMeterMetaRsp(SSqlObj *pSql) {
 //  pMeta->index = 0;
 
   // todo add one more function: taosAddDataIfNotExists();
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
-  assert(pMeterMetaInfo->pMeterMeta == NULL);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+  assert(pTableMetaInfo->pTableMeta == NULL);
 
-  pMeterMetaInfo->pMeterMeta = (STableMeta *)taosCachePut(tscCacheHandle, pMeterMetaInfo->name, (char *)pMeta,
+  pTableMetaInfo->pTableMeta = (STableMeta *)taosCachePut(tscCacheHandle, pTableMetaInfo->name, (char *)pMeta,
                                                                   pMeta->contLen, tsMeterMetaKeepTimer);
   // todo handle out of memory case
-  if (pMeterMetaInfo->pMeterMeta == NULL) return 0;
+  if (pTableMetaInfo->pTableMeta == NULL) return 0;
 
   return TSDB_CODE_OTHERS;
 }
@@ -2646,7 +2639,6 @@ int tscProcessMeterMetaRsp(SSqlObj *pSql) {
  *  |...... 1B        1B            4B
  **/
 int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) {
-  SSchema *pSchema;
   uint8_t  ieType;
   int32_t  totalNum;
   int32_t  i;
@@ -2683,65 +2675,66 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) {
       return TSDB_CODE_OTHERS;
     }
 
-    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-
-    if (pMeta->numOfTags > TSDB_MAX_TAGS || pMeta->numOfTags < 0) {
-      tscError("invalid tag value count:%d", pMeta->numOfTags);
-      pSql->res.code = TSDB_CODE_INVALID_VALUE;
-      pSql->res.numOfTotal = i;
-      return TSDB_CODE_OTHERS;
-    }
-
-    if (pMeta->numOfTags > TSDB_MAX_TAGS || pMeta->numOfTags < 0) {
-      tscError("invalid numOfTags:%d", pMeta->numOfTags);
-      pSql->res.code = TSDB_CODE_INVALID_VALUE;
-      pSql->res.numOfTotal = i;
-      return TSDB_CODE_OTHERS;
-    }
-
-    if (pMeta->numOfColumns > TSDB_MAX_COLUMNS || pMeta->numOfColumns < 0) {
-      tscError("invalid numOfColumns:%d", pMeta->numOfColumns);
-      pSql->res.code = TSDB_CODE_INVALID_VALUE;
-      pSql->res.numOfTotal = i;
-      return TSDB_CODE_OTHERS;
-    }
-
-    for (int j = 0; j < TSDB_VNODES_SUPPORT; ++j) {
-      pMeta->vpeerDesc[j].vnode = htonl(pMeta->vpeerDesc[j].vnode);
-    }
-
-    pMeta->rowSize = 0;
-    rsp += sizeof(SMultiTableMeta);
-    pSchema = (SSchema *)rsp;
-
-    int32_t numOfTotalCols = pMeta->numOfColumns + pMeta->numOfTags;
-    for (int j = 0; j < numOfTotalCols; ++j) {
-      pSchema->bytes = htons(pSchema->bytes);
-      pSchema->colId = htons(pSchema->colId);
-
-      // ignore the tags length
-      if (j < pMeta->numOfColumns) {
-        pMeta->rowSize += pSchema->bytes;
-      }
-      pSchema++;
-    }
-
-    rsp += numOfTotalCols * sizeof(SSchema);
-
-    int32_t  tagLen = 0;
-    SSchema *pTagsSchema = tsGetTagSchema(pMeta);
-
-    if (pMeta->tableType == TSDB_CHILD_TABLE) {
-      for (int32_t j = 0; j < pMeta->numOfTags; ++j) {
-        tagLen += pTagsSchema[j].bytes;
-      }
-    }
-
-    rsp += tagLen;
-    int32_t size = (int32_t)(rsp - ((char *)pMeta));  // Consistent with STableMeta in cache
-
-    pMeta->index = 0;
-    (void)taosCachePut(tscCacheHandle, pMeta->tableId, (char *)pMeta, size, tsMeterMetaKeepTimer);
+    //    pMeta->numOfColumns = htons(pMeta->numOfColumns);
+    //
+    //    if (pMeta->numOfTags > TSDB_MAX_TAGS || pMeta->numOfTags < 0) {
+    //      tscError("invalid tag value count:%d", pMeta->numOfTags);
+    //      pSql->res.code = TSDB_CODE_INVALID_VALUE;
+    //      pSql->res.numOfTotal = i;
+    //      return TSDB_CODE_OTHERS;
+    //    }
+    //
+    //    if (pMeta->numOfTags > TSDB_MAX_TAGS || pMeta->numOfTags < 0) {
+    //      tscError("invalid numOfTags:%d", pMeta->numOfTags);
+    //      pSql->res.code = TSDB_CODE_INVALID_VALUE;
+    //      pSql->res.numOfTotal = i;
+    //      return TSDB_CODE_OTHERS;
+    //    }
+    //
+    //    if (pMeta->numOfColumns > TSDB_MAX_COLUMNS || pMeta->numOfColumns < 0) {
+    //      tscError("invalid numOfColumns:%d", pMeta->numOfColumns);
+    //      pSql->res.code = TSDB_CODE_INVALID_VALUE;
+    //      pSql->res.numOfTotal = i;
+    //      return TSDB_CODE_OTHERS;
+    //    }
+    //
+    //    for (int j = 0; j < TSDB_VNODES_SUPPORT; ++j) {
+    //      pMeta->vpeerDesc[j].vnode = htonl(pMeta->vpeerDesc[j].vnode);
+    //    }
+    //
+    //    pMeta->rowSize = 0;
+    //    rsp += sizeof(SMultiTableMeta);
+    //    pSchema = (SSchema *)rsp;
+    //
+    //    int32_t numOfTotalCols = pMeta->numOfColumns + pMeta->numOfTags;
+    //    for (int j = 0; j < numOfTotalCols; ++j) {
+    //      pSchema->bytes = htons(pSchema->bytes);
+    //      pSchema->colId = htons(pSchema->colId);
+    //
+    //      // ignore the tags length
+    //      if (j < pMeta->numOfColumns) {
+    //        pMeta->rowSize += pSchema->bytes;
+    //      }
+    //      pSchema++;
+    //    }
+    //
+    //    rsp += numOfTotalCols * sizeof(SSchema);
+    //
+    //    int32_t  tagLen = 0;
+    //    SSchema *pTagsSchema = tscGetTableTagSchema(pMeta);
+    //
+    //    if (pMeta->tableType == TSDB_CHILD_TABLE) {
+    //      for (int32_t j = 0; j < pMeta->numOfTags; ++j) {
+    //        tagLen += pTagsSchema[j].bytes;
+    //      }
+    //    }
+    //
+    //    rsp += tagLen;
+    //    int32_t size = (int32_t)(rsp - ((char *)pMeta));  // Consistent with STableMeta in cache
+    //
+    //    pMeta->index = 0;
+    //    (void)taosCachePut(tscCacheHandle, pMeta->tableId, (char *)pMeta, size, tsMeterMetaKeepTimer);
+    //  }
   }
   
   pSql->res.code = TSDB_CODE_SUCCESS;
@@ -2840,22 +2833,22 @@ int tscProcessMetricMetaRsp(SSqlObj *pSql) {
   for (int32_t i = 0; i < num; ++i) {
     char name[TSDB_MAX_TAGS_LEN + 1] = {0};
 
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
-    tscGetMetricMetaCacheKey(pQueryInfo, name, pMeterMetaInfo->pMeterMeta->uid);
+    STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
+    tscGetMetricMetaCacheKey(pQueryInfo, name, pTableMetaInfo->pTableMeta->uid);
 
 #ifdef _DEBUG_VIEW
     printf("generate the metric key:%s, index:%d\n", name, i);
 #endif
 
     // release the used metricmeta
-    taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMetricMeta), false);
+    taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pMetricMeta), false);
 
-    pMeterMetaInfo->pMetricMeta = (SSuperTableMeta *)taosCachePut(tscCacheHandle, name, (char *)metricMetaList[i],
+    pTableMetaInfo->pMetricMeta = (SSuperTableMeta *)taosCachePut(tscCacheHandle, name, (char *)metricMetaList[i],
                                                                       sizes[i], tsMetricMetaKeepTimer);
     tfree(metricMetaList[i]);
 
     // failed to put into cache
-    if (pMeterMetaInfo->pMetricMeta == NULL) {
+    if (pTableMetaInfo->pMetricMeta == NULL) {
       pSql->res.code = TSDB_CODE_CLI_OUT_OF_MEMORY;
       goto _error_clean;
     }
@@ -2877,7 +2870,7 @@ _error_clean:
  * current process do not use the cache at all
  */
 int tscProcessShowRsp(SSqlObj *pSql) {
-  STableMeta * pMeta;
+  STableMetaMsg * pMetaMsg;
   SCMShowRsp *pShow;
   SSchema *    pSchema;
   char         key[20];
@@ -2887,20 +2880,20 @@ int tscProcessShowRsp(SSqlObj *pSql) {
 
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);  //?
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   pShow = (SCMShowRsp *)pRes->pRsp;
   pShow->qhandle = htobe64(pShow->qhandle);
   pRes->qhandle = pShow->qhandle;
 
   tscResetForNextRetrieve(pRes);
-  pMeta = &(pShow->tableMeta);
+  pMetaMsg = &(pShow->tableMeta);
 
-  pMeta->numOfColumns = ntohs(pMeta->numOfColumns);
+  pMetaMsg->numOfColumns = ntohs(pMetaMsg->numOfColumns);
 
-  pSchema = (SSchema *)((char *)pMeta + sizeof(STableMeta));
-  pMeta->sid = ntohs(pMeta->sid);
-  for (int i = 0; i < pMeta->numOfColumns; ++i) {
+  pSchema = (SSchema *)((char *)pMetaMsg + sizeof(STableMeta));
+  pMetaMsg->sid = ntohs(pMetaMsg->sid);
+  for (int i = 0; i < pMetaMsg->numOfColumns; ++i) {
     pSchema->bytes = htons(pSchema->bytes);
     pSchema++;
   }
@@ -2908,18 +2901,18 @@ int tscProcessShowRsp(SSqlObj *pSql) {
   key[0] = pCmd->msgType + 'a';
   strcpy(key + 1, "showlist");
 
-  taosCacheRelease(tscCacheHandle, (void *)&(pMeterMetaInfo->pMeterMeta), false);
+  taosCacheRelease(tscCacheHandle, (void *)&(pTableMetaInfo->pTableMeta), false);
 
-  int32_t size = pMeta->numOfColumns * sizeof(SSchema) + sizeof(STableMeta);
-  pMeterMetaInfo->pMeterMeta =
-      (STableMeta *)taosCachePut(tscCacheHandle, key, (char *)pMeta, size, tsMeterMetaKeepTimer);
+  int32_t size = pMetaMsg->numOfColumns * sizeof(SSchema) + sizeof(STableMeta);
+  pTableMetaInfo->pTableMeta =
+      (STableMeta *)taosCachePut(tscCacheHandle, key, (char *)pMetaMsg, size, tsMeterMetaKeepTimer);
   pCmd->numOfCols = pQueryInfo->fieldsInfo.numOfOutputCols;
-  SSchema *pMeterSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+  SSchema *pMeterSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
-  tscColumnBaseInfoReserve(&pQueryInfo->colList, pMeta->numOfColumns);
+  tscColumnBaseInfoReserve(&pQueryInfo->colList, pMetaMsg->numOfColumns);
   SColumnIndex index = {0};
 
-  for (int16_t i = 0; i < pMeta->numOfColumns; ++i) {
+  for (int16_t i = 0; i < pMetaMsg->numOfColumns; ++i) {
     index.columnIndex = i;
     tscColumnBaseInfoInsert(pQueryInfo, &index);
     tscFieldInfoSetValFromSchema(&pQueryInfo->fieldsInfo, i, &pMeterSchema[i]);
@@ -2959,9 +2952,9 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
 
 int tscProcessUseDbRsp(SSqlObj *pSql) {
   STscObj *       pObj = pSql->pTscObj;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
 
-  strcpy(pObj->db, pMeterMetaInfo->name);
+  strcpy(pObj->db, pTableMetaInfo->name);
   return 0;
 }
 
@@ -2971,10 +2964,10 @@ int tscProcessDropDbRsp(SSqlObj *UNUSED_PARAM(pSql)) {
 }
 
 int tscProcessDropTableRsp(SSqlObj *pSql) {
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
 
-  STableMeta *pMeterMeta = taosCacheAcquireByName(tscCacheHandle, pMeterMetaInfo->name);
-  if (pMeterMeta == NULL) {
+  STableMeta *pTableMeta = taosCacheAcquireByName(tscCacheHandle, pTableMetaInfo->name);
+  if (pTableMeta == NULL) {
     /* not in cache, abort */
     return 0;
   }
@@ -2986,36 +2979,36 @@ int tscProcessDropTableRsp(SSqlObj *pSql) {
    * The cached information is expired, however, we may have lost the ref of original meter. So, clear whole cache
    * instead.
    */
-  tscTrace("%p force release metermeta after drop table:%s", pSql, pMeterMetaInfo->name);
-  taosCacheRelease(tscCacheHandle, (void **)&pMeterMeta, true);
+  tscTrace("%p force release metermeta after drop table:%s", pSql, pTableMetaInfo->name);
+  taosCacheRelease(tscCacheHandle, (void **)&pTableMeta, true);
 
-  if (pMeterMetaInfo->pMeterMeta) {
-    taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMeterMeta), true);
-    taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMetricMeta), true);
+  if (pTableMetaInfo->pTableMeta) {
+    taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pTableMeta), true);
+    taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pMetricMeta), true);
   }
 
   return 0;
 }
 
 int tscProcessAlterTableMsgRsp(SSqlObj *pSql) {
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
 
-  STableMeta *pMeterMeta = taosCacheAcquireByName(tscCacheHandle, pMeterMetaInfo->name);
-  if (pMeterMeta == NULL) { /* not in cache, abort */
+  STableMeta *pTableMeta = taosCacheAcquireByName(tscCacheHandle, pTableMetaInfo->name);
+  if (pTableMeta == NULL) { /* not in cache, abort */
     return 0;
   }
 
-  tscTrace("%p force release metermeta in cache after alter-table: %s", pSql, pMeterMetaInfo->name);
-  taosCacheRelease(tscCacheHandle, (void **)&pMeterMeta, true);
+  tscTrace("%p force release metermeta in cache after alter-table: %s", pSql, pTableMetaInfo->name);
+  taosCacheRelease(tscCacheHandle, (void **)&pTableMeta, true);
 
-  if (pMeterMetaInfo->pMeterMeta) {
-    bool isSuperTable = UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo);
+  if (pTableMetaInfo->pTableMeta) {
+    bool isSuperTable = UTIL_METER_IS_SUPERTABLE(pTableMetaInfo);
 
-    taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMeterMeta), true);
-    taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMetricMeta), true);
+    taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pTableMeta), true);
+    taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pMetricMeta), true);
 
     if (isSuperTable) {  // if it is a super table, reset whole query cache
-      tscTrace("%p reset query cache since table:%s is stable", pSql, pMeterMetaInfo->name);
+      tscTrace("%p reset query cache since table:%s is stable", pSql, pTableMetaInfo->name);
       taosCacheEmpty(tscCacheHandle);
     }
   }
@@ -3098,7 +3091,7 @@ int tscProcessRetrieveRspFromLocal(SSqlObj *pSql) {
 
 void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code);
 
-static int32_t doGetMeterMetaFromServer(SSqlObj *pSql, SMeterMetaInfo *pMeterMetaInfo) {
+static int32_t doGetMeterMetaFromServer(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
   int32_t code = TSDB_CODE_SUCCESS;
 
   SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
@@ -3124,10 +3117,10 @@ static int32_t doGetMeterMetaFromServer(SSqlObj *pSql, SMeterMetaInfo *pMeterMet
     return TSDB_CODE_CLI_OUT_OF_MEMORY;
   }
 
-  SMeterMetaInfo *pNewMeterMetaInfo = tscAddEmptyMeterMetaInfo(pNewQueryInfo);
+  STableMetaInfo *pNewMeterMetaInfo = tscAddEmptyMeterMetaInfo(pNewQueryInfo);
   assert(pNew->cmd.numOfClause == 1 && pNewQueryInfo->numOfTables == 1);
 
-  strcpy(pNewMeterMetaInfo->name, pMeterMetaInfo->name);
+  strcpy(pNewMeterMetaInfo->name, pTableMetaInfo->name);
   memcpy(pNew->cmd.payload, pSql->cmd.payload, TSDB_DEFAULT_PAYLOAD_SIZE);  // tag information if table does not exists.
   tscTrace("%p new pSqlObj:%p to get tableMeta", pSql, pNew);
 
@@ -3142,11 +3135,11 @@ static int32_t doGetMeterMetaFromServer(SSqlObj *pSql, SMeterMetaInfo *pMeterMet
      * Transfer the ownership of metermeta to the new object, instead of invoking the release/acquire routine
      */
     if (code == TSDB_CODE_SUCCESS) {
-      pMeterMetaInfo->pMeterMeta = taosCacheTransfer(tscCacheHandle, (void**) &pNewMeterMetaInfo->pMeterMeta);
-      assert(pMeterMetaInfo->pMeterMeta != NULL);
+      pTableMetaInfo->pTableMeta = taosCacheTransfer(tscCacheHandle, (void**) &pNewMeterMetaInfo->pTableMeta);
+      assert(pTableMetaInfo->pTableMeta != NULL);
     }
 
-    tscTrace("%p get meter meta complete, code:%d, pMeterMeta:%p", pSql, code, pMeterMetaInfo->pMeterMeta);
+    tscTrace("%p get meter meta complete, code:%d, pTableMeta:%p", pSql, code, pTableMetaInfo->pTableMeta);
     tscFreeSqlObj(pNew);
 
   } else {
@@ -3163,20 +3156,19 @@ static int32_t doGetMeterMetaFromServer(SSqlObj *pSql, SMeterMetaInfo *pMeterMet
   return code;
 }
 
-int tscGetMeterMeta(SSqlObj *pSql, SMeterMetaInfo *pMeterMetaInfo) {
-  assert(strlen(pMeterMetaInfo->name) != 0);
+int tscGetMeterMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
+  assert(strlen(pTableMetaInfo->name) != 0);
 
-  // If this SMeterMetaInfo owns a metermeta, release it first
-  if (pMeterMetaInfo->pMeterMeta != NULL) {
-    taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMeterMeta), false);
+  // If this STableMetaInfo owns a metermeta, release it first
+  if (pTableMetaInfo->pTableMeta != NULL) {
+    taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pTableMeta), false);
   }
   
-  pMeterMetaInfo->pMeterMeta = (STableMeta *)taosCacheAcquireByName(tscCacheHandle, pMeterMetaInfo->name);
-  if (pMeterMetaInfo->pMeterMeta != NULL) {
-    STableMeta *pMeterMeta = pMeterMetaInfo->pMeterMeta;
-
-    tscTrace("%p retrieve tableMeta from cache, the number of columns:%d, numOfTags:%d", pSql, pMeterMeta->numOfColumns,
-             pMeterMeta->numOfTags);
+  pTableMetaInfo->pTableMeta = (STableMeta *)taosCacheAcquireByName(tscCacheHandle, pTableMetaInfo->name);
+  if (pTableMetaInfo->pTableMeta != NULL) {
+    STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+    tscTrace("%p retrieve tableMeta from cache, the number of columns:%d, numOfTags:%d", pSql, tinfo.numOfColumns,
+             tinfo.numOfTags);
 
     return TSDB_CODE_SUCCESS;
   }
@@ -3185,12 +3177,12 @@ int tscGetMeterMeta(SSqlObj *pSql, SMeterMetaInfo *pMeterMetaInfo) {
    * for async insert operation, release data block buffer before issue new object to get metermeta
    * because in metermeta callback function, the tscParse function will generate the submit data blocks
    */
-  return doGetMeterMetaFromServer(pSql, pMeterMetaInfo);
+  return doGetMeterMetaFromServer(pSql, pTableMetaInfo);
 }
 
-int tscGetMeterMetaEx(SSqlObj *pSql, SMeterMetaInfo *pMeterMetaInfo, bool createIfNotExists) {
+int tscGetMeterMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists) {
   pSql->cmd.createOnDemand = createIfNotExists;
-  return tscGetMeterMeta(pSql, pMeterMetaInfo);
+  return tscGetMeterMeta(pSql, pTableMetaInfo);
 }
 
 /*
@@ -3219,7 +3211,7 @@ int tscRenewMeterMeta(SSqlObj *pSql, char *tableId) {
   SSqlCmd *pCmd = &pSql->cmd;
 
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   // enforce the renew metermeta operation in async model
   if (pSql->fp == NULL) pSql->fp = (void *)0x1;
@@ -3228,20 +3220,20 @@ int tscRenewMeterMeta(SSqlObj *pSql, char *tableId) {
    * 1. only update the metermeta in force model metricmeta is not updated
    * 2. if get metermeta failed, still get the metermeta
    */
-  if (pMeterMetaInfo->pMeterMeta == NULL || !tscQueryOnMetric(pCmd)) {
-    if (pMeterMetaInfo->pMeterMeta) {
+  if (pTableMetaInfo->pTableMeta == NULL || !tscQueryOnMetric(pCmd)) {
+    if (pTableMetaInfo->pTableMeta) {
       tscTrace("%p update meter meta, old: numOfTags:%d, numOfCols:%d, uid:%" PRId64 ", addr:%p", pSql,
-               pMeterMetaInfo->numOfTags, pCmd->numOfCols, pMeterMetaInfo->pMeterMeta->uid, pMeterMetaInfo->pMeterMeta);
+               pTableMetaInfo->numOfTags, pCmd->numOfCols, pTableMetaInfo->pTableMeta->uid, pTableMetaInfo->pTableMeta);
     }
 
     tscWaitingForCreateTable(pCmd);
-    taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMeterMeta), true);
+    taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pTableMeta), true);
 
-    code = doGetMeterMetaFromServer(pSql, pMeterMetaInfo);  // todo ??
+    code = doGetMeterMetaFromServer(pSql, pTableMetaInfo);  // todo ??
   } else {
     tscTrace("%p metric query not update metric meta, numOfTags:%d, numOfCols:%d, uid:%" PRId64 ", addr:%p", pSql,
-             pMeterMetaInfo->pMeterMeta->numOfTags, pCmd->numOfCols, pMeterMetaInfo->pMeterMeta->uid,
-             pMeterMetaInfo->pMeterMeta);
+             tscGetNumOfTags(pTableMetaInfo->pTableMeta), pCmd->numOfCols, pTableMetaInfo->pTableMeta->uid,
+             pTableMetaInfo->pTableMeta);
   }
 
   if (code != TSDB_CODE_ACTION_IN_PROGRESS) {
@@ -3266,17 +3258,17 @@ int tscGetMetricMeta(SSqlObj *pSql, int32_t clauseIndex) {
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
     char tagstr[TSDB_MAX_TAGS_LEN + 1] = {0};
 
-    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
-    tscGetMetricMetaCacheKey(pQueryInfo, tagstr, pMeterMetaInfo->pMeterMeta->uid);
+    STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
+    tscGetMetricMetaCacheKey(pQueryInfo, tagstr, pTableMetaInfo->pTableMeta->uid);
 
-    taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMetricMeta), false);
+    taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pMetricMeta), false);
 
     SSuperTableMeta *ppMeta = (SSuperTableMeta *)taosCacheAcquireByName(tscCacheHandle, tagstr);
     if (ppMeta == NULL) {
       required = true;
       break;
     } else {
-      pMeterMetaInfo->pMetricMeta = ppMeta;
+      pTableMetaInfo->pMetricMeta = ppMeta;
     }
   }
 
@@ -3297,10 +3289,10 @@ int tscGetMetricMeta(SSqlObj *pSql, int32_t clauseIndex) {
   }
   
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
-    SMeterMetaInfo *pMMInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
+    STableMetaInfo *pMMInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
 
-    STableMeta *pMeterMeta = taosCacheAcquireByName(tscCacheHandle, pMMInfo->name);
-    tscAddMeterMetaInfo(pNewQueryInfo, pMMInfo->name, pMeterMeta, NULL, pMMInfo->numOfTags, pMMInfo->tagColumnIndex);
+    STableMeta *pTableMeta = taosCacheAcquireByName(tscCacheHandle, pMMInfo->name);
+    tscAddMeterMetaInfo(pNewQueryInfo, pMMInfo->name, pTableMeta, NULL, pMMInfo->numOfTags, pMMInfo->tagColumnIndex);
   }
 
   if ((code = tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE)) != TSDB_CODE_SUCCESS) {
@@ -3337,15 +3329,15 @@ int tscGetMetricMeta(SSqlObj *pSql, int32_t clauseIndex) {
       for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
         char tagstr[TSDB_MAX_TAGS_LEN] = {0};
     
-        SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
-        tscGetMetricMetaCacheKey(pQueryInfo, tagstr, pMeterMetaInfo->pMeterMeta->uid);
+        STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i);
+        tscGetMetricMetaCacheKey(pQueryInfo, tagstr, pTableMetaInfo->pTableMeta->uid);
 
 #ifdef _DEBUG_VIEW
         printf("create metric key:%s, index:%d\n", tagstr, i);
 #endif
     
-        taosCacheRelease(tscCacheHandle, (void **)&(pMeterMetaInfo->pMetricMeta), false);
-        pMeterMetaInfo->pMetricMeta = (SSuperTableMeta *) taosCacheAcquireByName(tscCacheHandle, tagstr);
+        taosCacheRelease(tscCacheHandle, (void **)&(pTableMetaInfo->pMetricMeta), false);
+        pTableMetaInfo->pMetricMeta = (SSuperTableMeta *) taosCacheAcquireByName(tscCacheHandle, tagstr);
       }
     }
 

src/client/src/tscSql.c

@@ -509,7 +509,7 @@ static bool tscHashRemainDataInSubqueryResultSet(SSqlObj *pSql) {
       SSqlCmd *pCmd1 = &pSql->pSubs[i]->cmd;
 
       SQueryInfo *    pQueryInfo1 = tscGetQueryInfoDetail(pCmd1, pCmd1->clauseIndex);
-      SMeterMetaInfo *pMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo1, 0);
+      STableMetaInfo *pMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo1, 0);
 
       assert(pQueryInfo1->numOfTables == 1);
 
@@ -810,7 +810,7 @@ void taos_free_result_imp(TAOS_RES *res, int keepCmd) {
 
   pQueryInfo->type = TSDB_QUERY_TYPE_FREE_RESOURCE;
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
   /*
    * case 1. Partial data have been retrieved from vnodes, but not all data has been retrieved yet.
@@ -825,7 +825,7 @@ void taos_free_result_imp(TAOS_RES *res, int keepCmd) {
   if (pRes->code != TSDB_CODE_QUERY_CANCELLED &&
       ((pRes->numOfRows > 0 && pCmd->command < TSDB_SQL_LOCAL) ||
        (pRes->code == TSDB_CODE_SUCCESS && pRes->numOfRows == 0 && pCmd->command == TSDB_SQL_SELECT &&
-        pSql->pStream == NULL && pMeterMetaInfo->pMeterMeta != NULL))) {
+        pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL))) {
     pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
 
     tscTrace("%p code:%d, numOfRows:%d, command:%d", pSql, pRes->code, pRes->numOfRows, pCmd->command);
@@ -1109,7 +1109,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
   SQueryInfo *pQueryInfo = NULL;
   tscGetQueryInfoDetailSafely(pCmd, pCmd->clauseIndex, &pQueryInfo);
 
-  SMeterMetaInfo *pMeterMetaInfo = tscAddEmptyMeterMetaInfo(pQueryInfo);
+  STableMetaInfo *pTableMetaInfo = tscAddEmptyMeterMetaInfo(pQueryInfo);
 
   if ((code = tscAllocPayload(pCmd, tblListLen + 16)) != TSDB_CODE_SUCCESS) {
     return code;
@@ -1144,7 +1144,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
       return code;
     }
 
-    if ((code = setMeterID(pMeterMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
+    if ((code = setMeterID(pTableMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
       return code;
     }
 
@@ -1154,7 +1154,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
       return code;
     }
 
-    if (payloadLen + strlen(pMeterMetaInfo->name) + 128 >= pCmd->allocSize) {
+    if (payloadLen + strlen(pTableMetaInfo->name) + 128 >= pCmd->allocSize) {
       char *pNewMem = realloc(pCmd->payload, pCmd->allocSize + tblListLen);
       if (pNewMem == NULL) {
         code = TSDB_CODE_CLI_OUT_OF_MEMORY;
@@ -1167,7 +1167,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
       pMsg = pCmd->payload;
     }
 
-    payloadLen += sprintf(pMsg + payloadLen, "%s,", pMeterMetaInfo->name);
+    payloadLen += sprintf(pMsg + payloadLen, "%s,", pTableMetaInfo->name);
   }
 
   *(pMsg + payloadLen) = '\0';

src/client/src/tscStream.c

@@ -13,15 +13,16 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <tschemautil.h>
 #include "os.h"
+#include "taosmsg.h"
 #include "tlog.h"
+#include "tscUtil.h"
+#include "tsched.h"
+#include "tsclient.h"
 #include "ttime.h"
 #include "ttimer.h"
 #include "tutil.h"
-#include "tsched.h"
-#include "taosmsg.h"
-#include "tscUtil.h"
-#include "tsclient.h"
 
 #include "tscProfile.h"
 
@@ -71,14 +72,14 @@ static void tscProcessStreamLaunchQuery(SSchedMsg *pMsg) {
   pSql->param = pStream;
   
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-  int code = tscGetMeterMeta(pSql, pMeterMetaInfo);
+  int code = tscGetMeterMeta(pSql, pTableMetaInfo);
   pSql->res.code = code;
 
   if (code == TSDB_CODE_ACTION_IN_PROGRESS) return;
 
-  if (code == 0 && UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  if (code == 0 && UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     code = tscGetMetricMeta(pSql, 0);
     pSql->res.code = code;
 
@@ -96,7 +97,7 @@ static void tscProcessStreamLaunchQuery(SSchedMsg *pMsg) {
     return;
   }
 
-  tscTrace("%p stream:%p start stream query on:%s", pSql, pStream, pMeterMetaInfo->name);
+  tscTrace("%p stream:%p start stream query on:%s", pSql, pStream, pTableMetaInfo->name);
   tscProcessSql(pStream->pSql);
 
   tscIncStreamExecutionCount(pStream);
@@ -145,8 +146,8 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
     tscError("%p stream:%p, query data failed, code:%d, retry in %" PRId64 "ms", pStream->pSql, pStream, numOfRows,
              retryDelay);
 
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pStream->pSql->cmd, 0, 0);
-    tscClearMeterMetaInfo(pMeterMetaInfo, true);
+    STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(&pStream->pSql->cmd, 0, 0);
+    tscClearMeterMetaInfo(pTableMetaInfo, true);
   
     tscSetRetryTimer(pStream, pStream->pSql, retryDelay);
     return;
@@ -171,12 +172,12 @@ static void tscSetTimestampForRes(SSqlStream *pStream, SSqlObj *pSql) {
 static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOfRows) {
   SSqlStream *    pStream = (SSqlStream *)param;
   SSqlObj *       pSql = (SSqlObj *)res;
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0, 0);
 
   if (pSql == NULL || numOfRows < 0) {
     int64_t retryDelayTime = tscGetRetryDelayTime(pStream->slidingTime, pStream->precision);
     tscError("%p stream:%p, retrieve data failed, code:%d, retry in %" PRId64 "ms", pSql, pStream, numOfRows, retryDelayTime);
-    tscClearMeterMetaInfo(pMeterMetaInfo, true);
+    tscClearMeterMetaInfo(pTableMetaInfo, true);
   
     tscSetRetryTimer(pStream, pStream->pSql, retryDelayTime);
     return;
@@ -254,11 +255,11 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
       }
     }
 
-    tscTrace("%p stream:%p, query on:%s, fetch result completed, fetched rows:%d", pSql, pStream, pMeterMetaInfo->name,
+    tscTrace("%p stream:%p, query on:%s, fetch result completed, fetched rows:%d", pSql, pStream, pTableMetaInfo->name,
              pStream->numOfRes);
 
     // release the metric/meter meta information reference, so data in cache can be updated
-    tscClearMeterMetaInfo(pMeterMetaInfo, false);
+    tscClearMeterMetaInfo(pTableMetaInfo, false);
     tscSetNextLaunchTimer(pStream, pSql);
   }
 }
@@ -539,13 +540,14 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   }
 
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   
   pStream->fp = fp;
   pStream->callback = callback;
   pStream->param = param;
   pStream->pSql = pSql;
-  pStream->precision = pMeterMetaInfo->pMeterMeta->precision;
+  pStream->precision = tinfo.precision;
 
   pStream->ctime = taosGetTimestamp(pStream->precision);
   pStream->etime = pQueryInfo->etime;
@@ -560,7 +562,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   taosTmrReset(tscProcessStreamTimer, starttime, pStream, tscTmr, &pStream->pTimer);
 
   tscTrace("%p stream:%p is opened, query on:%s, interval:%" PRId64 ", sliding:%" PRId64 ", first launched in:%" PRId64 ", sql:%s", pSql,
-           pStream, pMeterMetaInfo->name, pStream->interval, pStream->slidingTime, starttime, sqlstr);
+           pStream, pTableMetaInfo->name, pStream->interval, pStream->slidingTime, starttime, sqlstr);
 
   return pStream;
 }

src/client/src/tscSub.c

@@ -175,10 +175,10 @@ int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
     return 0;
   }
 
-  SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMeterMetaInfo(pCmd, 0, 0);
   int numOfTables = 0;
-  if (!UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
-    SSuperTableMeta* pMetricMeta = pMeterMetaInfo->pMetricMeta;
+  if (!UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
+    SSuperTableMeta* pMetricMeta = pTableMetaInfo->pMetricMeta;
     for (int32_t i = 0; i < pMetricMeta->numOfVnodes; i++) {
       SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, i);
       numOfTables += pVnodeSidList->numOfSids;
@@ -191,13 +191,13 @@ int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
     return 0;
   }
 
-  if (UTIL_METER_IS_NOMRAL_METER(pMeterMetaInfo)) {
+  if (UTIL_METER_IS_NOMRAL_METER(pTableMetaInfo)) {
     numOfTables = 1;
-    int64_t uid = pMeterMetaInfo->pMeterMeta->uid;
+    int64_t uid = pTableMetaInfo->pTableMeta->uid;
     progress[0].uid = uid;
     progress[0].key = tscGetSubscriptionProgress(pSub, uid);
   } else {
-    SSuperTableMeta* pMetricMeta = pMeterMetaInfo->pMetricMeta;
+    SSuperTableMeta* pMetricMeta = pTableMetaInfo->pMetricMeta;
     numOfTables = 0;
     for (int32_t i = 0; i < pMetricMeta->numOfVnodes; i++) {
       SVnodeSidList *pVnodeSidList = tscGetVnodeSidList(pMetricMeta, i);

src/client/src/tscUtil.c

@@ -40,12 +40,12 @@
  */
 void tscGetMetricMetaCacheKey(SQueryInfo* pQueryInfo, char* str, uint64_t uid) {
   int32_t         index = -1;
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoByUid(pQueryInfo, uid, &index);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoByUid(pQueryInfo, uid, &index);
 
   int32_t len = 0;
   char    tagIdBuf[128] = {0};
-  for (int32_t i = 0; i < pMeterMetaInfo->numOfTags; ++i) {
-    len += sprintf(&tagIdBuf[len], "%d,", pMeterMetaInfo->tagColumnIndex[i]);
+  for (int32_t i = 0; i < pTableMetaInfo->numOfTags; ++i) {
+    len += sprintf(&tagIdBuf[len], "%d,", pTableMetaInfo->tagColumnIndex[i]);
   }
 
   STagCond* pTagCond = &pQueryInfo->tagCond;
@@ -64,7 +64,7 @@ void tscGetMetricMetaCacheKey(SQueryInfo* pQueryInfo, char* str, uint64_t uid) {
   size_t tbnameCondLen = pTagCond->tbnameCond.cond != NULL ? strlen(pTagCond->tbnameCond.cond) : 0;
   size_t redundantLen = 20;
 
-  size_t bufSize = strlen(pMeterMetaInfo->name) + tbnameCondLen + strlen(join) + strlen(tagIdBuf);
+  size_t bufSize = strlen(pTableMetaInfo->name) + tbnameCondLen + strlen(join) + strlen(tagIdBuf);
   if (cond != NULL && cond->cond != NULL) {
     bufSize += strlen(cond->cond);
   }
@@ -72,7 +72,7 @@ void tscGetMetricMetaCacheKey(SQueryInfo* pQueryInfo, char* str, uint64_t uid) {
   bufSize = (size_t)((bufSize + redundantLen) * 1.5);
   char* tmp = calloc(1, bufSize);
 
-  int32_t keyLen = snprintf(tmp, bufSize, "%s,%s,%s,%d,%s,[%s],%d", pMeterMetaInfo->name,
+  int32_t keyLen = snprintf(tmp, bufSize, "%s,%s,%s,%d,%s,[%s],%d", pTableMetaInfo->name,
                             ((cond != NULL && cond->cond != NULL) ? cond->cond : NULL), (tbnameCondLen > 0 ? pTagCond->tbnameCond.cond : NULL),
                             pTagCond->relType, join, tagIdBuf, pQueryInfo->groupbyExpr.orderType);
 
@@ -214,17 +214,17 @@ bool tscIsTwoStageMergeMetricQuery(SQueryInfo* pQueryInfo, int32_t tableIndex) {
     return false;
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
-  if (pMeterMetaInfo == NULL) {
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
+  if (pTableMetaInfo == NULL) {
     return false;
   }
   
   // for select query super table, the metricmeta can not be null in any cases.
-  if (pQueryInfo->command == TSDB_SQL_SELECT && UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
-    assert(pMeterMetaInfo->pMetricMeta != NULL);
+  if (pQueryInfo->command == TSDB_SQL_SELECT && UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
+    assert(pTableMetaInfo->pMetricMeta != NULL);
   }
   
-  if (pMeterMetaInfo->pMetricMeta == NULL) {
+  if (pTableMetaInfo->pMetricMeta == NULL) {
     return false;
   }
   
@@ -239,21 +239,21 @@ bool tscIsTwoStageMergeMetricQuery(SQueryInfo* pQueryInfo, int32_t tableIndex) {
 
   if (((pQueryInfo->type & TSDB_QUERY_TYPE_STABLE_SUBQUERY) != TSDB_QUERY_TYPE_STABLE_SUBQUERY) &&
       pQueryInfo->command == TSDB_SQL_SELECT) {
-    return UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo);
+    return UTIL_METER_IS_SUPERTABLE(pTableMetaInfo);
   }
 
   return false;
 }
 
 bool tscIsProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
   
   /*
    * In following cases, return false for non ordered project query on super table
    * 1. failed to get metermeta from server; 2. not a super table; 3. limitation is 0;
    * 4. show queries, instead of a select query
    */
-  if (pMeterMetaInfo == NULL || !UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo) ||
+  if (pTableMetaInfo == NULL || !UTIL_METER_IS_SUPERTABLE(pTableMetaInfo) ||
       pQueryInfo->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pQueryInfo->exprsInfo.numOfExprs == 0) {
     return false;
   }
@@ -505,7 +505,7 @@ void tscDestroyDataBlock(STableDataBlocks* pDataBlock) {
   tfree(pDataBlock->params);
 
   // free the refcount for metermeta
-  taosCacheRelease(tscCacheHandle, (void**)&(pDataBlock->pMeterMeta), false);
+  taosCacheRelease(tscCacheHandle, (void**)&(pDataBlock->pTableMeta), false);
   tfree(pDataBlock);
 }
 
@@ -579,21 +579,21 @@ void* tscDestroyBlockArrayList(SDataBlockList* pList) {
 
 int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
   SSqlCmd* pCmd = &pSql->cmd;
-  assert(pDataBlock->pMeterMeta != NULL);
+  assert(pDataBlock->pTableMeta != NULL);
 
   pCmd->numOfTablesInSubmit = pDataBlock->numOfTables;
 
   assert(pCmd->numOfClause == 1);
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
 
   // set the correct metermeta object, the metermeta has been locked in pDataBlocks, so it must be in the cache
-  if (pMeterMetaInfo->pMeterMeta != pDataBlock->pMeterMeta) {
-    strcpy(pMeterMetaInfo->name, pDataBlock->tableId);
-    taosCacheRelease(tscCacheHandle, (void**)&(pMeterMetaInfo->pMeterMeta), false);
+  if (pTableMetaInfo->pTableMeta != pDataBlock->pTableMeta) {
+    strcpy(pTableMetaInfo->name, pDataBlock->tableId);
+    taosCacheRelease(tscCacheHandle, (void**)&(pTableMetaInfo->pTableMeta), false);
 
-    pMeterMetaInfo->pMeterMeta = taosCacheTransfer(tscCacheHandle, (void**)&pDataBlock->pMeterMeta);
+    pTableMetaInfo->pTableMeta = taosCacheTransfer(tscCacheHandle, (void**)&pDataBlock->pTableMeta);
   } else {
-    assert(strncmp(pMeterMetaInfo->name, pDataBlock->tableId, tListLen(pDataBlock->tableId)) == 0);
+    assert(strncmp(pTableMetaInfo->name, pDataBlock->tableId, tListLen(pDataBlock->tableId)) == 0);
   }
 
   /*
@@ -637,7 +637,7 @@ void tscFreeUnusedDataBlocks(SDataBlockList* pList) {
  * @return
  */
 int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOffset, const char* name,
-                           STableMeta* pMeterMeta, STableDataBlocks** dataBlocks) {
+                           STableMeta* pTableMeta, STableDataBlocks** dataBlocks) {
   STableDataBlocks* dataBuf = (STableDataBlocks*)calloc(1, sizeof(STableDataBlocks));
   if (dataBuf == NULL) {
     tscError("failed to allocated memory, reason:%s", strerror(errno));
@@ -665,15 +665,15 @@ int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOff
    * due to operation such as drop database. So here we add the reference count directly instead of invoke
    * taosGetDataFromCache, which may return NULL value.
    */
-  dataBuf->pMeterMeta = taosCacheAcquireByData(tscCacheHandle, pMeterMeta);
-  assert(initialSize > 0 && pMeterMeta != NULL && dataBuf->pMeterMeta != NULL);
+  dataBuf->pTableMeta = taosCacheAcquireByData(tscCacheHandle, pTableMeta);
+  assert(initialSize > 0 && pTableMeta != NULL && dataBuf->pTableMeta != NULL);
 
   *dataBlocks = dataBuf;
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t tscGetDataBlockFromList(void* pHashList, SDataBlockList* pDataBlockList, int64_t id, int32_t size,
-                                int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pMeterMeta,
+                                int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pTableMeta,
                                 STableDataBlocks** dataBlocks) {
   *dataBlocks = NULL;
 
@@ -683,7 +683,7 @@ int32_t tscGetDataBlockFromList(void* pHashList, SDataBlockList* pDataBlockList,
   }
 
   if (*dataBlocks == NULL) {
-    int32_t ret = tscCreateDataBlock((size_t)size, rowSize, startOffset, tableId, pMeterMeta, dataBlocks);
+    int32_t ret = tscCreateDataBlock((size_t)size, rowSize, startOffset, tableId, pTableMeta, dataBlocks);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
@@ -707,7 +707,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SDataBlockList* pTableDataBlockLi
     STableDataBlocks* dataBuf = NULL;
     int32_t           ret =
         tscGetDataBlockFromList(pVnodeDataBlockHashList, pVnodeDataBlockList, pOneTableBlock->vgid, TSDB_PAYLOAD_SIZE,
-                                tsInsertHeadSize, 0, pOneTableBlock->tableId, pOneTableBlock->pMeterMeta, &dataBuf);
+                                tsInsertHeadSize, 0, pOneTableBlock->tableId, pOneTableBlock->pTableMeta, &dataBuf);
     if (ret != TSDB_CODE_SUCCESS) {
       tscError("%p failed to prepare the data block buffer for merging table data, code:%d", pSql, ret);
       taosHashCleanup(pVnodeDataBlockHashList);
@@ -1116,7 +1116,7 @@ SSqlExpr* tscSqlExprInsertEmpty(SQueryInfo* pQueryInfo, int32_t index, int16_t f
 
 SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex,
                            int16_t type, int16_t size, int16_t interSize) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pColIndex->tableIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, pColIndex->tableIndex);
 
   SSqlExprInfo* pExprInfo = &pQueryInfo->exprsInfo;
 
@@ -1127,13 +1127,13 @@ SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functi
   pExprInfo->pExprs[index] = pExpr;
   
   pExpr->functionId = functionId;
-  int16_t numOfCols = pMeterMetaInfo->pMeterMeta->numOfColumns;
+  int16_t numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
 
   // set the correct column index
   if (pColIndex->columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
     pExpr->colInfo.colId = TSDB_TBNAME_COLUMN_INDEX;
   } else {
-    SSchema* pSchema = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, pColIndex->columnIndex);
+    SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pColIndex->columnIndex);
     pExpr->colInfo.colId = pSchema->colId;
   }
 
@@ -1153,7 +1153,7 @@ SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functi
   pExpr->resType = type;
   pExpr->resBytes = size;
   pExpr->interResBytes = interSize;
-  pExpr->uid = pMeterMetaInfo->pMeterMeta->uid;
+  pExpr->uid = pTableMetaInfo->pTableMeta->uid;
 
   pExprInfo->numOfExprs++;
   return pExpr;
@@ -1161,7 +1161,7 @@ SSqlExpr* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functi
 
 SSqlExpr* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex,
                            int16_t type, int16_t size) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
   SSqlExprInfo*   pExprInfo = &pQueryInfo->exprsInfo;
   if (index > pExprInfo->numOfExprs) {
     return NULL;
@@ -1172,7 +1172,7 @@ SSqlExpr* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functi
   pExpr->functionId = functionId;
 
   pExpr->colInfo.colIdx = srcColumnIndex;
-  pExpr->colInfo.colId = tsGetColumnSchema(pMeterMetaInfo->pMeterMeta, srcColumnIndex)->colId;
+  pExpr->colInfo.colId = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, srcColumnIndex)->colId;
 
   pExpr->resType = type;
   pExpr->resBytes = size;
@@ -1573,17 +1573,19 @@ void tscIncStreamExecutionCount(void* pStream) {
   ps->num += 1;
 }
 
-bool tscValidateColumnId(SMeterMetaInfo* pMeterMetaInfo, int32_t colId) {
-  if (pMeterMetaInfo->pMeterMeta == NULL) {
+bool tscValidateColumnId(STableMetaInfo* pTableMetaInfo, int32_t colId) {
+  if (pTableMetaInfo->pTableMeta == NULL) {
     return false;
   }
 
-  if (colId == -1 && UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  if (colId == -1 && UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     return true;
   }
 
-  SSchema* pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
-  int32_t  numOfTotal = pMeterMetaInfo->pMeterMeta->numOfTags + pMeterMetaInfo->pMeterMeta->numOfColumns;
+  SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
+  STableInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
+  
+  int32_t  numOfTotal = tinfo.numOfTags + tinfo.numOfColumns;
 
   for (int32_t i = 0; i < numOfTotal; ++i) {
     if (pSchema[i].colId == colId) {
@@ -1627,16 +1629,16 @@ void tscTagCondRelease(STagCond* pCond) {
 }
 
 void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SQueryInfo* pQueryInfo) {
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  SSchema*        pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  SSchema*        pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
   for (int32_t i = 0; i < pQueryInfo->exprsInfo.numOfExprs; ++i) {
     SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
     pColInfo[i].functionId = pExpr->functionId;
 
     if (TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {
-      SSchema* pTagSchema = tsGetTagSchema(pMeterMetaInfo->pMeterMeta);
-      int16_t  actualTagIndex = pMeterMetaInfo->tagColumnIndex[pExpr->colInfo.colIdx];
+      SSchema* pTagSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
+      int16_t  actualTagIndex = pTableMetaInfo->tagColumnIndex[pExpr->colInfo.colIdx];
 
       pColInfo[i].type = (actualTagIndex != -1) ? pTagSchema[actualTagIndex].type : TSDB_DATA_TYPE_BINARY;
     } else {
@@ -1723,10 +1725,10 @@ bool tscShouldFreeAsyncSqlObj(SSqlObj* pSql) {
     SDataBlockList* pDataBlocks = pCmd->pDataBlocks;
     SQueryInfo*     pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
 
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
     assert(pQueryInfo->numOfTables == 1 || pQueryInfo->numOfTables == 2);
 
-    if (pDataBlocks == NULL || pMeterMetaInfo->vnodeIndex >= pDataBlocks->nSize) {
+    if (pDataBlocks == NULL || pTableMetaInfo->vnodeIndex >= pDataBlocks->nSize) {
       tscTrace("%p object should be release since all data blocks have been submit", pSql);
       return true;
     } else {
@@ -1745,7 +1747,7 @@ bool tscShouldFreeAsyncSqlObj(SSqlObj* pSql) {
  * @param tableIndex  denote the table index for join query, where more than one table exists
  * @return
  */
-SMeterMetaInfo* tscGetMeterMetaInfo(SSqlCmd* pCmd, int32_t clauseIndex, int32_t tableIndex) {
+STableMetaInfo* tscGetMeterMetaInfo(SSqlCmd* pCmd, int32_t clauseIndex, int32_t tableIndex) {
   if (pCmd == NULL || pCmd->numOfClause == 0) {
     return NULL;
   }
@@ -1756,7 +1758,7 @@ SMeterMetaInfo* tscGetMeterMetaInfo(SSqlCmd* pCmd, int32_t clauseIndex, int32_t
   return tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, tableIndex);
 }
 
-SMeterMetaInfo* tscGetMeterMetaInfoFromQueryInfo(SQueryInfo* pQueryInfo, int32_t tableIndex) {
+STableMetaInfo* tscGetMeterMetaInfoFromQueryInfo(SQueryInfo* pQueryInfo, int32_t tableIndex) {
   assert(pQueryInfo != NULL);
 
   if (pQueryInfo->pMeterInfo == NULL) {
@@ -1795,11 +1797,11 @@ int32_t tscGetQueryInfoDetailSafely(SSqlCmd* pCmd, int32_t subClauseIndex, SQuer
   return TSDB_CODE_SUCCESS;
 }
 
-SMeterMetaInfo* tscGetMeterMetaInfoByUid(SQueryInfo* pQueryInfo, uint64_t uid, int32_t* index) {
+STableMetaInfo* tscGetMeterMetaInfoByUid(SQueryInfo* pQueryInfo, uint64_t uid, int32_t* index) {
   int32_t k = -1;
 
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
-    if (pQueryInfo->pMeterInfo[i]->pMeterMeta->uid == uid) {
+    if (pQueryInfo->pMeterInfo[i]->pTableMeta->uid == uid) {
       k = i;
       break;
     }
@@ -1872,7 +1874,7 @@ void tscFreeSubqueryInfo(SSqlCmd* pCmd) {
   tfree(pCmd->pQueryInfo);
 }
 
-SMeterMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pMeterMeta,
+STableMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pTableMeta,
                                     SSuperTableMeta* pMetricMeta, int16_t numOfTags, int16_t* tags) {
   void* pAlloc = realloc(pQueryInfo->pMeterInfo, (pQueryInfo->numOfTables + 1) * POINTER_BYTES);
   if (pAlloc == NULL) {
@@ -1880,29 +1882,29 @@ SMeterMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, ST
   }
 
   pQueryInfo->pMeterInfo = pAlloc;
-  pQueryInfo->pMeterInfo[pQueryInfo->numOfTables] = calloc(1, sizeof(SMeterMetaInfo));
+  pQueryInfo->pMeterInfo[pQueryInfo->numOfTables] = calloc(1, sizeof(STableMetaInfo));
 
-  SMeterMetaInfo* pMeterMetaInfo = pQueryInfo->pMeterInfo[pQueryInfo->numOfTables];
-  assert(pMeterMetaInfo != NULL);
+  STableMetaInfo* pTableMetaInfo = pQueryInfo->pMeterInfo[pQueryInfo->numOfTables];
+  assert(pTableMetaInfo != NULL);
 
   if (name != NULL) {
     assert(strlen(name) <= TSDB_TABLE_ID_LEN);
-    strcpy(pMeterMetaInfo->name, name);
+    strcpy(pTableMetaInfo->name, name);
   }
 
-  pMeterMetaInfo->pMeterMeta = pMeterMeta;
-  pMeterMetaInfo->pMetricMeta = pMetricMeta;
-  pMeterMetaInfo->numOfTags = numOfTags;
+  pTableMetaInfo->pTableMeta = pTableMeta;
+  pTableMetaInfo->pMetricMeta = pMetricMeta;
+  pTableMetaInfo->numOfTags = numOfTags;
 
   if (tags != NULL) {
-    memcpy(pMeterMetaInfo->tagColumnIndex, tags, sizeof(pMeterMetaInfo->tagColumnIndex[0]) * numOfTags);
+    memcpy(pTableMetaInfo->tagColumnIndex, tags, sizeof(pTableMetaInfo->tagColumnIndex[0]) * numOfTags);
   }
 
   pQueryInfo->numOfTables += 1;
-  return pMeterMetaInfo;
+  return pTableMetaInfo;
 }
 
-SMeterMetaInfo* tscAddEmptyMeterMetaInfo(SQueryInfo* pQueryInfo) {
+STableMetaInfo* tscAddEmptyMeterMetaInfo(SQueryInfo* pQueryInfo) {
   return tscAddMeterMetaInfo(pQueryInfo, NULL, NULL, NULL, 0, NULL);
 }
 
@@ -1911,10 +1913,10 @@ void doRemoveMeterMetaInfo(SQueryInfo* pQueryInfo, int32_t index, bool removeFro
     return;
   }
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, index);
 
-  tscClearMeterMetaInfo(pMeterMetaInfo, removeFromCache);
-  free(pMeterMetaInfo);
+  tscClearMeterMetaInfo(pTableMetaInfo, removeFromCache);
+  free(pTableMetaInfo);
 
   int32_t after = pQueryInfo->numOfTables - index - 1;
   if (after > 0) {
@@ -1935,13 +1937,13 @@ void tscRemoveAllMeterMetaInfo(SQueryInfo* pQueryInfo, const char* address, bool
   tfree(pQueryInfo->pMeterInfo);
 }
 
-void tscClearMeterMetaInfo(SMeterMetaInfo* pMeterMetaInfo, bool removeFromCache) {
-  if (pMeterMetaInfo == NULL) {
+void tscClearMeterMetaInfo(STableMetaInfo* pTableMetaInfo, bool removeFromCache) {
+  if (pTableMetaInfo == NULL) {
     return;
   }
 
-  taosCacheRelease(tscCacheHandle, (void**)&(pMeterMetaInfo->pMeterMeta), removeFromCache);
-  taosCacheRelease(tscCacheHandle, (void**)&(pMeterMetaInfo->pMetricMeta), removeFromCache);
+  taosCacheRelease(tscCacheHandle, (void**)&(pTableMetaInfo->pTableMeta), removeFromCache);
+  taosCacheRelease(tscCacheHandle, (void**)&(pTableMetaInfo->pMetricMeta), removeFromCache);
 }
 
 void tscResetForNextRetrieve(SSqlRes* pRes) {
@@ -1955,11 +1957,11 @@ void tscResetForNextRetrieve(SSqlRes* pRes) {
 
 SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void* param, SSqlObj* pPrevSql) {
   SSqlCmd*        pCmd = &pSql->cmd;
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, tableIndex);
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, tableIndex);
 
   SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
   if (pNew == NULL) {
-    tscError("%p new subquery failed, tableIndex:%d, vnodeIndex:%d", pSql, tableIndex, pMeterMetaInfo->vnodeIndex);
+    tscError("%p new subquery failed, tableIndex:%d, vnodeIndex:%d", pSql, tableIndex, pTableMetaInfo->vnodeIndex);
     return NULL;
   }
 
@@ -1968,7 +1970,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
 
   pNew->sqlstr = strdup(pSql->sqlstr);
   if (pNew->sqlstr == NULL) {
-    tscError("%p new subquery failed, tableIndex:%d, vnodeIndex:%d", pSql, tableIndex, pMeterMetaInfo->vnodeIndex);
+    tscError("%p new subquery failed, tableIndex:%d, vnodeIndex:%d", pSql, tableIndex, pTableMetaInfo->vnodeIndex);
 
     free(pNew);
     return NULL;
@@ -2010,7 +2012,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
   }
 
   if (tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE) != TSDB_CODE_SUCCESS) {
-    tscError("%p new subquery failed, tableIndex:%d, vnodeIndex:%d", pSql, tableIndex, pMeterMetaInfo->vnodeIndex);
+    tscError("%p new subquery failed, tableIndex:%d, vnodeIndex:%d", pSql, tableIndex, pTableMetaInfo->vnodeIndex);
     tscFreeSqlObj(pNew);
     return NULL;
   }
@@ -2025,7 +2027,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
     pNewQueryInfo->type |= TSDB_QUERY_TYPE_SUBQUERY;  // it must be the subquery
   }
 
-  uint64_t uid = pMeterMetaInfo->pMeterMeta->uid;
+  uint64_t uid = pTableMetaInfo->pTableMeta->uid;
   tscSqlExprCopy(&pNewQueryInfo->exprsInfo, &pQueryInfo->exprsInfo, uid, true);
 
   int32_t numOfOutputCols = pNewQueryInfo->exprsInfo.numOfExprs;
@@ -2067,34 +2069,34 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
   printf("the metricmeta key is:%s\n", key);
 #endif
 
-  char*           name = pMeterMetaInfo->name;
-  SMeterMetaInfo* pFinalInfo = NULL;
+  char*           name = pTableMetaInfo->name;
+  STableMetaInfo* pFinalInfo = NULL;
 
   if (pPrevSql == NULL) {
-    STableMeta*  pMeterMeta = taosCacheAcquireByName(tscCacheHandle, name);
+    STableMeta*  pTableMeta = taosCacheAcquireByName(tscCacheHandle, name);
     SSuperTableMeta* pMetricMeta = taosCacheAcquireByName(tscCacheHandle, key);
 
-    pFinalInfo = tscAddMeterMetaInfo(pNewQueryInfo, name, pMeterMeta, pMetricMeta, pMeterMetaInfo->numOfTags,
-                                     pMeterMetaInfo->tagColumnIndex);
-  } else {  // transfer the ownership of pMeterMeta/pMetricMeta to the newly create sql object.
-    SMeterMetaInfo* pPrevInfo = tscGetMeterMetaInfo(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex, 0);
+    pFinalInfo = tscAddMeterMetaInfo(pNewQueryInfo, name, pTableMeta, pMetricMeta, pTableMetaInfo->numOfTags,
+                                     pTableMetaInfo->tagColumnIndex);
+  } else {  // transfer the ownership of pTableMeta/pMetricMeta to the newly create sql object.
+    STableMetaInfo* pPrevInfo = tscGetMeterMetaInfo(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex, 0);
 
-    STableMeta*  pPrevMeterMeta = taosCacheTransfer(tscCacheHandle, (void**)&pPrevInfo->pMeterMeta);
+    STableMeta*  pPrevMeterMeta = taosCacheTransfer(tscCacheHandle, (void**)&pPrevInfo->pTableMeta);
     SSuperTableMeta* pPrevMetricMeta = taosCacheTransfer(tscCacheHandle, (void**)&pPrevInfo->pMetricMeta);
 
-    pFinalInfo = tscAddMeterMetaInfo(pNewQueryInfo, name, pPrevMeterMeta, pPrevMetricMeta, pMeterMetaInfo->numOfTags,
-                                     pMeterMetaInfo->tagColumnIndex);
+    pFinalInfo = tscAddMeterMetaInfo(pNewQueryInfo, name, pPrevMeterMeta, pPrevMetricMeta, pTableMetaInfo->numOfTags,
+                                     pTableMetaInfo->tagColumnIndex);
   }
 
-  assert(pFinalInfo->pMeterMeta != NULL && pNewQueryInfo->numOfTables == 1);
-  if (UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo)) {
+  assert(pFinalInfo->pTableMeta != NULL && pNewQueryInfo->numOfTables == 1);
+  if (UTIL_METER_IS_SUPERTABLE(pTableMetaInfo)) {
     assert(pFinalInfo->pMetricMeta != NULL);
   }
   
   tscTrace(
       "%p new subquery: %p, tableIndex:%d, vnodeIdx:%d, type:%d, exprInfo:%d, colList:%d,"
       "fieldInfo:%d, name:%s, qrang:%" PRId64 " - %" PRId64 " order:%d, limit:%" PRId64,
-      pSql, pNew, tableIndex, pMeterMetaInfo->vnodeIndex, pNewQueryInfo->type, pNewQueryInfo->exprsInfo.numOfExprs,
+      pSql, pNew, tableIndex, pTableMetaInfo->vnodeIndex, pNewQueryInfo->type, pNewQueryInfo->exprsInfo.numOfExprs,
       pNewQueryInfo->colList.numOfCols, pNewQueryInfo->fieldsInfo.numOfOutputCols, pFinalInfo->name, pNewQueryInfo->stime,
       pNewQueryInfo->etime, pNewQueryInfo->order.order, pNewQueryInfo->limit.limit);
   
@@ -2187,14 +2189,14 @@ bool hasMoreVnodesToTry(SSqlObj* pSql) {
 
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
   
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  if (!UTIL_METER_IS_SUPERTABLE(pMeterMetaInfo) || (pMeterMetaInfo->pMetricMeta == NULL)) {
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  if (!UTIL_METER_IS_SUPERTABLE(pTableMetaInfo) || (pTableMetaInfo->pMetricMeta == NULL)) {
     return false;
   }
   
-  int32_t totalVnode = pMeterMetaInfo->pMetricMeta->numOfVnodes;
+  int32_t totalVnode = pTableMetaInfo->pMetricMeta->numOfVnodes;
   return pRes->numOfRows == 0 && tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) &&
-         (!tscHasReachLimitation(pQueryInfo, pRes)) && (pMeterMetaInfo->vnodeIndex < totalVnode - 1);
+         (!tscHasReachLimitation(pQueryInfo, pRes)) && (pTableMetaInfo->vnodeIndex < totalVnode - 1);
 }
 
 void tscTryQueryNextVnode(SSqlObj* pSql, __async_cb_func_t fp) {
@@ -2209,12 +2211,12 @@ void tscTryQueryNextVnode(SSqlObj* pSql, __async_cb_func_t fp) {
    */
   assert(pRes->numOfRows == 0 && tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) && !tscHasReachLimitation(pQueryInfo, pRes));
 
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  int32_t         totalVnode = pMeterMetaInfo->pMetricMeta->numOfVnodes;
+  STableMetaInfo* pTableMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
+  int32_t         totalVnode = pTableMetaInfo->pMetricMeta->numOfVnodes;
 
-  while (++pMeterMetaInfo->vnodeIndex < totalVnode) {
+  while (++pTableMetaInfo->vnodeIndex < totalVnode) {
     tscTrace("%p current vnode:%d exhausted, try next:%d. total vnode:%d. current numOfRes:%d", pSql,
-             pMeterMetaInfo->vnodeIndex - 1, pMeterMetaInfo->vnodeIndex, totalVnode, pRes->numOfTotalInCurrentClause);
+             pTableMetaInfo->vnodeIndex - 1, pTableMetaInfo->vnodeIndex, totalVnode, pRes->numOfTotalInCurrentClause);
 
     /*
      * update the limit and offset value for the query on the next vnode,
@@ -2233,7 +2235,7 @@ void tscTryQueryNextVnode(SSqlObj* pSql, __async_cb_func_t fp) {
 
     assert((pRes->offset >= 0 && pRes->numOfRows == 0) || (pRes->offset == 0 && pRes->numOfRows >= 0));
     tscTrace("%p new query to next vnode, vnode index:%d, limit:%" PRId64 ", offset:%" PRId64 ", glimit:%" PRId64, pSql,
-             pMeterMetaInfo->vnodeIndex, pQueryInfo->limit.limit, pQueryInfo->limit.offset, pQueryInfo->clauseLimit);
+             pTableMetaInfo->vnodeIndex, pQueryInfo->limit.limit, pQueryInfo->limit.offset, pQueryInfo->clauseLimit);
 
     /*
      * For project query with super table join, the numOfSub is equalled to the number of all subqueries.

src/inc/taosdef.h

@@ -165,7 +165,7 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size);
 #define TSDB_MAX_COLUMNS          256
 #define TSDB_MIN_COLUMNS          2       //PRIMARY COLUMN(timestamp) + other columns
 
-#define TSDB_TABLE_NAME_LEN       64
+#define TSDB_TABLE_NAME_LEN       192
 #define TSDB_DB_NAME_LEN          32
 #define TSDB_COL_NAME_LEN         64
 #define TSDB_MAX_SAVED_SQL_LEN    TSDB_MAX_COLUMNS * 16

src/inc/taosmsg.h

@@ -678,15 +678,15 @@ typedef struct {
   int32_t  list[]; /* offset of SVnodeSidList, compared to the SSuperTableMeta struct */
 } SSuperTableMeta;
 
-typedef struct STableMeta {
-  char    tableId[TSDB_TABLE_ID_LEN + 1];  // note: This field must be at the front
+typedef struct STableMetaMsg {
+  char    tableId[TSDB_TABLE_ID_LEN];  // note: This field must be at the front
   int32_t contLen;
-  uint8_t numOfTags : 6;
-  uint8_t precision : 2;
-  uint8_t tableType : 4;
-  uint8_t index : 4;  // used locally
+  uint8_t numOfTags;
+  uint8_t precision;
+  uint8_t tableType;
+//  uint8_t index : 4;  // used locally
   int16_t numOfColumns;
-  int16_t rowSize;  // used locally, calculated in client
+//  int16_t rowSize;  // used locally, calculated in client
   int16_t sversion;
   int8_t  numOfVpeers;
   SVnodeDesc vpeerDesc[TSDB_VNODES_SUPPORT];
@@ -694,12 +694,12 @@ typedef struct STableMeta {
   int32_t  vgid;
   uint64_t uid;
   SSchema  schema[];
-} STableMeta;
+} STableMetaMsg;
 
 typedef struct SMultiTableMeta {
   int32_t    numOfTables;
   int32_t    contLen;
-  STableMeta metas[];
+  STableMetaMsg metas[];
 } SMultiTableMeta;
 
 typedef struct {
@@ -719,9 +719,9 @@ typedef struct {
   char     payload[];
 } SCMShowMsg;
 
-typedef struct {
+typedef struct SCMShowRsp {
   uint64_t      qhandle;
-  STableMeta tableMeta;
+  STableMetaMsg tableMeta;
 } SCMShowRsp;
 
 typedef struct {

src/mnode/inc/mgmtChildTable.h

@@ -36,7 +36,7 @@ void *mgmtBuildCreateChildTableMsg(SCMCreateTableMsg *pCreate, SChildTableObj *p
 int32_t mgmtDropChildTable(SQueuedMsg *newMsg, SChildTableObj *pTable);
 int32_t mgmtModifyChildTableTagValueByName(SChildTableObj *pTable, char *tagName, char *nContent);
 
-int32_t mgmtGetChildTableMeta(SDbObj *pDb, SChildTableObj *pTable, STableMeta *pMeta, bool usePublicIp);
+int32_t mgmtGetChildTableMeta(SDbObj *pDb, SChildTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp);
 
 void mgmtDropAllChildTables(SDbObj *pDropDb);
 

src/mnode/inc/mgmtNormalTable.h

@@ -35,7 +35,7 @@ int32_t mgmtDropNormalTable(SQueuedMsg *newMsg, SNormalTableObj *pTable);
 int32_t mgmtAddNormalTableColumn(SNormalTableObj *pTable, SSchema schema[], int32_t ncols);
 int32_t mgmtDropNormalTableColumnByName(SNormalTableObj *pTable, char *colName);
 
-int32_t mgmtGetNormalTableMeta(SDbObj *pDb, SNormalTableObj *pTable, STableMeta *pMeta, bool usePublicIp);
+int32_t mgmtGetNormalTableMeta(SDbObj *pDb, SNormalTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp);
 
 void mgmtDropAllNormalTables(SDbObj *pDropDb);
 

src/mnode/inc/mgmtShell.h

@@ -25,7 +25,7 @@ int32_t mgmtInitShell();
 void mgmtCleanUpShell();
 void mgmtAddShellMsgHandle(uint8_t msgType, void (*fp)(SQueuedMsg *queuedMsg));
 
-typedef int32_t (*SShowMetaFp)(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 void mgmtAddShellShowMetaHandle(uint8_t showType, SShowMetaFp fp);
 void mgmtAddShellShowRetrieveHandle(uint8_t showType, SShowRetrieveFp fp);

src/mnode/inc/mgmtSuperTable.h

@@ -39,7 +39,7 @@ int32_t mgmtModifySuperTableTagNameByName(SSuperTableObj *pTable, char *oldTagNa
 int32_t mgmtAddSuperTableColumn(SSuperTableObj *pTable, SSchema schema[], int32_t ncols);
 int32_t mgmtDropSuperTableColumnByName(SSuperTableObj *pTable, char *colName);
 
-int32_t mgmtGetSuperTableMeta(SDbObj *pDb, SSuperTableObj *pTable, STableMeta *pMeta, bool usePublicIp);
+int32_t mgmtGetSuperTableMeta(SDbObj *pDb, SSuperTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp);
 void *  mgmtGetSuperTableVgroup(SSuperTableObj *pStable);
 
 int32_t mgmtFindSuperTableTagIndex(SSuperTableObj *pTable, const char *tagName);

src/mnode/inc/mgmtTable.h

@@ -30,7 +30,7 @@ void        mgmtCleanUpTables();
 STableInfo* mgmtGetTable(char *tableId);
 
 STableInfo* mgmtGetTableByPos(uint32_t dnodeIp, int32_t vnode, int32_t sid);
-int32_t     mgmtGetTableMeta(SDbObj *pDb, STableInfo *pTable, STableMeta *pMeta, bool usePublicIp);
+int32_t     mgmtGetTableMeta(SDbObj *pDb, STableInfo *pTable, STableMetaMsg *pMeta, bool usePublicIp);
 
 void    mgmtAddTableIntoSuperTable(SSuperTableObj *pStable);
 void    mgmtRemoveTableFromSuperTable(SSuperTableObj *pStable);

src/mnode/src/mgmtChildTable.c

@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "taosmsg.h"
-#include "tschemautil.h"
 #include "tscompression.h"
 #include "tskiplist.h"
 #include "ttime.h"
@@ -442,7 +441,7 @@ int32_t mgmtModifyChildTableTagValueByName(SChildTableObj *pTable, char *tagName
   return 0;
 }
 
-int32_t mgmtGetChildTableMeta(SDbObj *pDb, SChildTableObj *pTable, STableMeta *pMeta, bool usePublicIp) {
+int32_t mgmtGetChildTableMeta(SDbObj *pDb, SChildTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp) {
   pMeta->uid          = htobe64(pTable->uid);
   pMeta->sid          = htonl(pTable->sid);
   pMeta->vgid         = htonl(pTable->vgId);
@@ -451,7 +450,7 @@ int32_t mgmtGetChildTableMeta(SDbObj *pDb, SChildTableObj *pTable, STableMeta *p
   pMeta->numOfTags    = pTable->superTable->numOfTags;
   pMeta->numOfColumns = htons(pTable->superTable->numOfColumns);
   pMeta->tableType    = pTable->type;
-  pMeta->contLen      = sizeof(STableMeta) + mgmtSetSchemaFromSuperTable(pMeta->schema, pTable->superTable);
+  pMeta->contLen      = sizeof(STableMetaMsg) + mgmtSetSchemaFromSuperTable(pMeta->schema, pTable->superTable);
   strcpy(pMeta->tableId, pTable->tableId);
 
   SVgObj *pVgroup = mgmtGetVgroup(pTable->vgId);

src/mnode/src/mgmtDb.c

@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "taoserror.h"
-#include "tschemautil.h"
 #include "tstatus.h"
 #include "tutil.h"
 #include "mnode.h"
@@ -41,7 +40,7 @@ static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate);
 static void    mgmtDropDb(void *handle, void *tmrId);
 static void    mgmtSetDbDirty(SDbObj *pDb);
 
-static int32_t mgmtGetDbMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t mgmtRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 static void    mgmtProcessCreateDbMsg(SQueuedMsg *pMsg);
 static void    mgmtProcessAlterDbMsg(SQueuedMsg *pMsg);
@@ -295,7 +294,8 @@ static int32_t mgmtCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) {
 
 bool mgmtCheckIsMonitorDB(char *db, char *monitordb) {
   char dbName[TSDB_DB_NAME_LEN + 1] = {0};
-  extractDBName(db, dbName);
+  assert(0);
+//  extractDBName(db, dbName);
 
   size_t len = strlen(dbName);
   return (strncasecmp(dbName, monitordb, len) == 0 && len == strlen(monitordb));
@@ -421,10 +421,10 @@ void mgmtCleanUpDbs() {
   sdbCloseTable(tsDbSdb);
 }
 
-static int32_t mgmtGetDbMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mgmtGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
   SUserObj *pUser = mgmtGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
 

src/mnode/src/mgmtDnode.c

@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "tmodule.h"
-#include "tschemautil.h"
 #include "tstatus.h"
 #include "mgmtBalance.h"
 #include "mgmtDnode.h"
@@ -37,11 +36,11 @@ void       (*mgmtSetDnodeUnRemoveFp)(SDnodeObj *pDnode) = NULL;
 static SDnodeObj tsDnodeObj = {0};
 static void *  mgmtGetNextDnode(SShowObj *pShow, SDnodeObj **pDnode);
 static bool    mgmtCheckConfigShow(SGlobalConfig *cfg);
-static int32_t mgmtGetModuleMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mgmtGetConfigMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mgmtGetVnodeMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t mgmtRetrieveVnodes(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 static void    mgmtProcessCfgDnodeMsg(SQueuedMsg *pMsg);
 
@@ -123,7 +122,7 @@ bool mgmtCheckModuleInDnode(SDnodeObj *pDnode, int32_t moduleType) {
   return status > 0;
 }
 
-int32_t mgmtGetModuleMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mgmtGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
   SUserObj *pUser = mgmtGetUserFromConn(pConn);
@@ -131,7 +130,7 @@ int32_t mgmtGetModuleMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
 
   if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
 
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = 16;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
@@ -216,7 +215,7 @@ int32_t mgmtRetrieveModules(SShowObj *pShow, char *data, int32_t rows, void *pCo
   return numOfRows;
 }
 
-static int32_t mgmtGetConfigMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mgmtGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
   SUserObj *pUser = mgmtGetUserFromConn(pConn);
@@ -224,7 +223,7 @@ static int32_t mgmtGetConfigMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn
 
   if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
 
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = TSDB_CFG_OPTION_LEN;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
@@ -304,13 +303,13 @@ static int32_t mgmtRetrieveConfigs(SShowObj *pShow, char *data, int32_t rows, vo
   return numOfRows;
 }
 
-static int32_t mgmtGetVnodeMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mgmtGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
   SUserObj *pUser = mgmtGetUserFromConn(pConn);
   if (pUser == NULL) return 0;
   if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS;
 
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;

src/mnode/src/mgmtNormalTable.c

@@ -521,7 +521,7 @@ static int32_t mgmtSetSchemaFromNormalTable(SSchema *pSchema, SNormalTableObj *p
   return numOfCols * sizeof(SSchema);
 }
 
-int32_t mgmtGetNormalTableMeta(SDbObj *pDb, SNormalTableObj *pTable, STableMeta *pMeta, bool usePublicIp) {
+int32_t mgmtGetNormalTableMeta(SDbObj *pDb, SNormalTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp) {
   pMeta->uid          = htobe64(pTable->uid);
   pMeta->sid          = htonl(pTable->sid);
   pMeta->vgid         = htonl(pTable->vgId);
@@ -530,7 +530,7 @@ int32_t mgmtGetNormalTableMeta(SDbObj *pDb, SNormalTableObj *pTable, STableMeta
   pMeta->numOfTags    = 0;
   pMeta->numOfColumns = htons(pTable->numOfColumns);
   pMeta->tableType    = pTable->type;
-  pMeta->contLen      = sizeof(STableMeta) + mgmtSetSchemaFromNormalTable(pMeta->schema, pTable);
+  pMeta->contLen      = sizeof(STableMetaMsg) + mgmtSetSchemaFromNormalTable(pMeta->schema, pTable);
 
   SVgObj *pVgroup = mgmtGetVgroup(pTable->vgId);
   if (pVgroup == NULL) {

src/mnode/src/mgmtProfile.c

@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "taosmsg.h"
-#include "tschemautil.h"
 #include "mgmtMnode.h"
 #include "mgmtProfile.h"
 #include "mgmtShell.h"
@@ -137,10 +136,10 @@ int32_t mgmtGetQueries(SShowObj *pShow, void *pConn) {
   return 0;
 }
 
-int32_t mgmtGetQueryMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mgmtGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = TSDB_USER_LEN;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
@@ -336,9 +335,9 @@ int32_t mgmtGetStreams(SShowObj *pShow, void *pConn) {
   return 0;
 }
 
-int32_t mgmtGetStreamMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mgmtGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t      cols = 0;
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = TSDB_USER_LEN;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
@@ -600,11 +599,11 @@ int mgmtGetConns(SShowObj *pShow, void *pConn) {
   return 0;
 }
 
-int32_t mgmtGetConnsMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mgmtGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   int32_t cols = 0;
 
   pShow->bytes[cols] = TSDB_TABLE_NAME_LEN;
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
   strcpy(pSchema[cols].name, "user");

src/mnode/src/mgmtShell.c

@@ -38,7 +38,7 @@
 #include "mgmtUser.h"
 #include "mgmtVgroup.h"
 
-typedef int32_t (*SShowMetaFp)(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+typedef int32_t (*SShowMetaFp)(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 typedef int32_t (*SShowRetrieveFp)(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
 static int  mgmtShellRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey);

src/mnode/src/mgmtSuperTable.c

@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "taosmsg.h"
-#include "tschemautil.h"
 #include "tscompression.h"
 #include "tskiplist.h"
 #include "tsqlfunction.h"
@@ -47,7 +46,7 @@ static void *mgmtSuperTableActionDecode(void *row, char *str, int32_t size, int3
 static void *mgmtSuperTableActionReset(void *row, char *str, int32_t size, int32_t *ssize);
 static void *mgmtSuperTableActionDestroy(void *row, char *str, int32_t size, int32_t *ssize);
 static int32_t mgmtRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
-static int32_t mgmtGetShowSuperTableMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mgmtGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 
 static void mgmtDestroySuperTable(SSuperTableObj *pTable) {
   free(pTable->schema);
@@ -492,14 +491,14 @@ int32_t mgmtDropSuperTableColumnByName(SSuperTableObj *pStable, char *colName) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mgmtGetShowSuperTableMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mgmtGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   SDbObj *pDb = mgmtGetDb(pShow->db);
   if (pDb == NULL) {
     return TSDB_CODE_DB_NOT_SELECTED;
   }
 
   int32_t cols = 0;
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = TSDB_TABLE_NAME_LEN;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
@@ -657,7 +656,7 @@ int32_t mgmtSetSchemaFromSuperTable(SSchema *pSchema, SSuperTableObj *pTable) {
   return (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema);
 }
 
-int32_t mgmtGetSuperTableMeta(SDbObj *pDb, SSuperTableObj *pTable, STableMeta *pMeta, bool usePublicIp) {
+int32_t mgmtGetSuperTableMeta(SDbObj *pDb, SSuperTableObj *pTable, STableMetaMsg *pMeta, bool usePublicIp) {
   pMeta->uid          = htobe64(pTable->uid);
   pMeta->sid          = htonl(pTable->sid);
   pMeta->vgid         = htonl(pTable->vgId);
@@ -666,7 +665,7 @@ int32_t mgmtGetSuperTableMeta(SDbObj *pDb, SSuperTableObj *pTable, STableMeta *p
   pMeta->numOfTags    = pTable->numOfTags;
   pMeta->numOfColumns = htons(pTable->numOfColumns);
   pMeta->tableType    = pTable->type;
-  pMeta->contLen      = sizeof(STableMeta) + mgmtSetSchemaFromSuperTable(pMeta->schema, pTable);
+  pMeta->contLen      = sizeof(STableMetaMsg) + mgmtSetSchemaFromSuperTable(pMeta->schema, pTable);
   strcpy(pMeta->tableId, pTable->tableId);
 
   return TSDB_CODE_SUCCESS;

src/mnode/src/mgmtTable.c

@@ -15,6 +15,7 @@
 
 #define _DEFAULT_SOURCE
 #include "mgmtTable.h"
+//#include "../../client/inc/tsclient.h"
 #include "mgmtAcct.h"
 #include "mgmtChildTable.h"
 #include "mgmtDClient.h"
@@ -34,7 +35,6 @@
 #include "qextbuffer.h"
 #include "taoserror.h"
 #include "taosmsg.h"
-#include "tschemautil.h"
 #include "tscompression.h"
 #include "tskiplist.h"
 #include "tsqlfunction.h"
@@ -52,7 +52,7 @@ static void mgmtProcessMultiTableMetaMsg(SQueuedMsg *queueMsg);
 static void mgmtProcessSuperTableMetaMsg(SQueuedMsg *queueMsg);
 static void mgmtProcessCreateTableRsp(SRpcMsg *rpcMsg);
 static void mgmtProcessDropTableRsp(SRpcMsg *rpcMsg);
-static int32_t mgmtGetShowTableMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mgmtGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t mgmtRetrieveShowTables(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 static void mgmtProcessGetTableMeta(STableInfo *pTable, void *thandle);
 
@@ -122,7 +122,7 @@ STableInfo* mgmtGetTableByPos(uint32_t dnodeIp, int32_t vnode, int32_t sid) {
   return NULL;
 }
 
-int32_t mgmtGetTableMeta(SDbObj *pDb, STableInfo *pTable, STableMeta *pMeta, bool usePublicIp) {
+int32_t mgmtGetTableMeta(SDbObj *pDb, STableInfo *pTable, STableMetaMsg *pMeta, bool usePublicIp) {
   if (pTable->type == TSDB_CHILD_TABLE) {
     mgmtGetChildTableMeta(pDb, (SChildTableObj *) pTable, pMeta, usePublicIp);
   } else if (pTable->type == TSDB_NORMAL_TABLE) {
@@ -187,14 +187,14 @@ void mgmtCleanUpTables() {
   mgmtCleanUpSuperTables();
 }
 
-int32_t mgmtGetShowTableMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mgmtGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   SDbObj *pDb = mgmtGetDb(pShow->db);
   if (pDb == NULL) {
     return TSDB_CODE_DB_NOT_SELECTED;
   }
 
   int32_t cols = 0;
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = TSDB_TABLE_NAME_LEN;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
@@ -602,7 +602,7 @@ void mgmtProcessGetTableMeta(STableInfo *pTable, void *thandle) {
 
   bool usePublicIp = (connInfo.serverIp == tsPublicIpInt);
   
-  STableMeta *pMeta = rpcMallocCont(sizeof(STableMeta) + sizeof(SSchema) * TSDB_MAX_COLUMNS);
+  STableMetaMsg *pMeta = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * TSDB_MAX_COLUMNS);
   rpcRsp.code = mgmtGetTableMeta(pDb, pTable, pMeta, usePublicIp);
 
   if (rpcRsp.code != TSDB_CODE_SUCCESS) {
@@ -695,7 +695,7 @@ void mgmtProcessMultiTableMetaMsg(SQueuedMsg *pMsg) {
     if (pDb == NULL) continue;
 
     int availLen = totalMallocLen - pMultiMeta->contLen;
-    if (availLen <= sizeof(STableMeta) + sizeof(SSchema) * TSDB_MAX_COLUMNS) {
+    if (availLen <= sizeof(STableMetaMsg) + sizeof(SSchema) * TSDB_MAX_COLUMNS) {
       //TODO realloc
       //totalMallocLen *= 2;
       //pMultiMeta = rpcReMalloc(pMultiMeta, totalMallocLen);
@@ -708,7 +708,7 @@ void mgmtProcessMultiTableMetaMsg(SQueuedMsg *pMsg) {
       //}
     }
 
-    STableMeta *pMeta = (STableMeta *)(pMultiMeta->metas + pMultiMeta->contLen);
+    STableMetaMsg *pMeta = (STableMetaMsg *)(pMultiMeta->metas + pMultiMeta->contLen);
     int32_t code = mgmtGetTableMeta(pDb, pTable, pMeta, usePublicIp);
     if (code == TSDB_CODE_SUCCESS) {
       pMultiMeta->numOfTables ++;

src/mnode/src/mgmtUser.c

@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "trpc.h"
-#include "tschemautil.h"
 #include "ttime.h"
 #include "mgmtAcct.h"
 #include "mgmtGrant.h"
@@ -30,7 +29,7 @@ static int32_t tsUserUpdateSize = 0;
 static int32_t   mgmtCreateUser(SAcctObj *pAcct, char *name, char *pass);
 static int32_t   mgmtDropUser(SAcctObj *pAcct, char *name);
 static int32_t   mgmtUpdateUser(SUserObj *pUser);
-static int32_t   mgmtGetUserMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+static int32_t   mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t   mgmtRetrieveUsers(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 
 static void mgmtProcessCreateUserMsg(SQueuedMsg *pMsg);
@@ -171,14 +170,14 @@ static int32_t mgmtDropUser(SAcctObj *pAcct, char *name) {
   return 0;
 }
 
-static int32_t mgmtGetUserMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+static int32_t mgmtGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   SUserObj *pUser = mgmtGetUserFromConn(pConn);
   if (pUser == NULL) {
     return TSDB_CODE_INVALID_USER;
   }
 
   int32_t cols     = 0;
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = TSDB_USER_LEN;
   pSchema[cols].type = TSDB_DATA_TYPE_BINARY;

src/mnode/src/mgmtVgroup.c

@@ -17,7 +17,6 @@
 #include "os.h"
 #include "taoserror.h"
 #include "tlog.h"
-#include "tschemautil.h"
 #include "tstatus.h"
 #include "mnode.h"
 #include "mgmtBalance.h"
@@ -41,7 +40,7 @@ static void *mgmtVgroupActionDecode(void *row, char *str, int32_t size, int32_t
 static void *mgmtVgroupActionReset(void *row, char *str, int32_t size, int32_t *ssize);
 static void *mgmtVgroupActionDestroy(void *row, char *str, int32_t size, int32_t *ssize);
 
-static int32_t mgmtGetVgroupMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn);
+static int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn);
 static int32_t mgmtRetrieveVgroups(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 static void    mgmtProcessCreateVnodeRsp(SRpcMsg *rpcMsg);
 static void    mgmtProcessDropVnodeRsp(SRpcMsg *rpcMsg);
@@ -211,14 +210,14 @@ void mgmtCleanUpVgroups() {
   sdbCloseTable(tsVgroupSdb);
 }
 
-int32_t mgmtGetVgroupMeta(STableMeta *pMeta, SShowObj *pShow, void *pConn) {
+int32_t mgmtGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
   SDbObj *pDb = mgmtGetDb(pShow->db);
   if (pDb == NULL) {
     return TSDB_CODE_DB_NOT_SELECTED;
   }
 
   int32_t cols = 0;
-  SSchema *pSchema = tsGetSchema(pMeta);
+  SSchema *pSchema = pMeta->schema;
 
   pShow->bytes[cols] = 4;
   pSchema[cols].type = TSDB_DATA_TYPE_INT;

src/inc/qpercentile.h → src/query/inc/qpercentile.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_TPERCENTILE_H
-#define TDENGINE_TPERCENTILE_H
+#ifndef TDENGINE_QPERCENTILE_H
+#define TDENGINE_QPERCENTILE_H
 
 #include "qextbuffer.h"
 
@@ -74,4 +74,4 @@ void tBucketIntHash(tMemBucket *pBucket, void *value, int16_t *segIdx, int16_t *
 
 void tBucketDoubleHash(tMemBucket *pBucket, void *value, int16_t *segIdx, int16_t *slotIdx);
 
-#endif  // TDENGINE_TPERCENTILE_H
+#endif  // TDENGINE_QPERCENTILE_H

src/query/src/qast.c

@@ -20,7 +20,7 @@
 #include "taosdef.h"
 #include "taosmsg.h"
 #include "tlog.h"
-#include "tschemautil.h"
+//#include "tschemautil.h"
 #include "tsqlfunction.h"
 #include "tstoken.h"
 #include "ttokendef.h"