Merge branch '2.0' into feature/2.0tsdb

documentation/webdocs/markdowndocs/TAOS SQL-ch.md

@@ -191,9 +191,10 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     ```
     同时向表tb1_name和tb2_name中按列分别插入多条记录 
 
-注意：对同一张表，插入的新记录的时间戳必须递增，否则会跳过插入该条记录。如果时间戳为0，系统将自动使用服务器当前时间作为该记录的时间戳。
+注意：1、对同一张表，插入的新记录的时间戳必须递增，否则会跳过插入该条记录。如果时间戳为0，系统将自动使用服务器当前时间作为该记录的时间戳。
+      2、允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的keep值（数据保留的天数），允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的days值（数据文件存储数据的时间跨度，单位为天）。keep和days都是可以在创建数据库时指定的，缺省值分别是3650天和10天。
 
-**IMPORT**：如果需要将时间戳小于最后一条记录时间的记录写入到数据库中，可使用IMPORT替代INSERT命令，IMPORT的语法与INSERT完全一样。如果同时IMPORT多条记录，需要保证一批记录是按时间戳排序好的。
+**IMPORT**：如果需要将时间戳小于最后一条记录时间的记录写入到数据库中，可使用IMPORT替代INSERT命令，IMPORT的语法与INSERT完全一样。
 
 ## 数据查询
 

documentation/webdocs/markdowndocs/TAOS SQL.md

@@ -181,9 +181,10 @@ All the keywords in a SQL statement are case-insensitive, but strings values are
                 tb2_name (tb2_field1_name, ...) VALUES(field1_value1, ...) (field1_value2, ...)
     ```
 
-Note: For a table, the new record must have a timestamp bigger than the last data record, otherwise, it will be discarded and not inserted. If the timestamp is 0, the time stamp will be set to the system time on the server.
+Note: 1. For a table, the new record must have a timestamp bigger than the last data record, otherwise, it will be discarded and not inserted. If the timestamp is 0, the time stamp will be set to the system time on the server.
+      2.The timestamp of the oldest record allowed to be inserted is relative to the current server time, minus the configured keep value (the number of days the data is retained), and the timestamp of the latest record allowed to be inserted is relative to the current server time, plus the configured days value (the time span in which the data file stores data, in days). Both keep and days can be specified when creating the database. The default values are 3650 days and 10 days, respectively.
  
-**IMPORT**: If you do want to insert a historical data record into a table, use IMPORT command instead of INSERT. IMPORT has the same syntax as INSERT. If you want to import a batch of historical records, the records must be ordered by the timestamp, otherwise, TDengine won't handle it in the right way.
+**IMPORT**: If you do want to insert a historical data record into a table, use IMPORT command instead of INSERT. IMPORT has the same syntax as INSERT. 
 
 ## Data Query
 

src/client/inc/tscSQLParser.h

@@ -86,15 +86,16 @@ enum _sql_cmd {
   TSDB_SQL_MAX   //48
 };
 
-#define MAX_TOKEN_LEN 30
-
-// token type
 enum {
   TSQL_NODE_TYPE_EXPR = 0x1,
   TSQL_NODE_TYPE_ID = 0x2,
   TSQL_NODE_TYPE_VALUE = 0x4,
 };
 
+#define NON_ARITHMEIC_EXPR 0
+#define NORMAL_ARITHMETIC 1
+#define AGG_ARIGHTMEIC    2
+
 extern char tTokenTypeSwitcher[13];
 
 #define toTSDBType(x)                          \
@@ -112,7 +113,7 @@ typedef struct SLimitVal {
 } SLimitVal;
 
 typedef struct SOrderVal {
-  int32_t order;
+  uint32_t order;
   int32_t orderColId;
 } SOrderVal;
 

src/client/inc/tscUtil.h

@@ -67,7 +67,7 @@ typedef struct SJoinSubquerySupporter {
 } SJoinSubquerySupporter;
 
 int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOffset, const char* name,
-                           SMeterMeta* pMeterMeta, STableDataBlocks** dataBlocks);
+                           STableMeta* pMeterMeta, STableDataBlocks** dataBlocks);
 void    tscAppendDataBlock(SDataBlockList* pList, STableDataBlocks* pBlocks);
 void    tscDestroyDataBlock(STableDataBlocks* pDataBlock);
 
@@ -81,11 +81,11 @@ 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, SMeterMeta* pMeterMeta,
+                                int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pMeterMeta,
                                 STableDataBlocks** dataBlocks);
 
-SVnodeSidList*    tscGetVnodeSidList(SMetricMeta* pMetricmeta, int32_t vnodeIdx);
-SMeterSidExtInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx);
+SVnodeSidList*    tscGetVnodeSidList(SSuperTableMeta* pMetricmeta, int32_t vnodeIdx);
+STableSidExtInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx);
 
 /**
  *
@@ -120,7 +120,7 @@ void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 bool tscIsInsertOrImportData(char* sqlstr);
 
 /* use for keep current db info temporarily, for handle table with db prefix */
-void tscGetDBInfoFromMeterId(char* meterId, char* db);
+void tscGetDBInfoFromMeterId(char* tableId, char* db);
 
 int tscAllocPayload(SSqlCmd* pCmd, int size);
 
@@ -128,6 +128,8 @@ void tscFieldInfoSetValFromSchema(SFieldInfo* pFieldInfo, int32_t index, SSchema
 void tscFieldInfoSetValFromField(SFieldInfo* pFieldInfo, int32_t index, TAOS_FIELD* pField);
 void tscFieldInfoSetValue(SFieldInfo* pFieldInfo, int32_t index, int8_t type, const char* name, int16_t bytes);
 void tscFieldInfoUpdateVisible(SFieldInfo* pFieldInfo, int32_t index, bool visible);
+void tscFieldInfoSetExpr(SFieldInfo* pFieldInfo, int32_t index, SSqlExpr* pExpr);
+void tscFieldInfoSetBinExpr(SFieldInfo* pFieldInfo, int32_t index, SSqlFunctionExpr* pExpr);
 
 void tscFieldInfoCalOffset(SQueryInfo* pQueryInfo);
 void tscFieldInfoUpdateOffsetForInterResult(SQueryInfo* pQueryInfo);
@@ -149,9 +151,10 @@ SSqlExpr* tscSqlExprInsertEmpty(SQueryInfo* pQueryInfo, int32_t index, int16_t f
 
 SSqlExpr* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
                            int16_t size);
+int32_t   tscSqlExprNumOfExprs(SQueryInfo* pQueryInfo);
 
 SSqlExpr* tscSqlExprGet(SQueryInfo* pQueryInfo, int32_t index);
-void      tscSqlExprCopy(SSqlExprInfo* dst, const SSqlExprInfo* src, uint64_t uid);
+void      tscSqlExprCopy(SSqlExprInfo* dst, const SSqlExprInfo* src, uint64_t uid, bool deepcopy);
 void*     tscSqlExprDestroy(SSqlExpr* pExpr);
 void      tscSqlExprInfoDestroy(SSqlExprInfo* pExprInfo);
 
@@ -196,7 +199,7 @@ int32_t tscGetQueryInfoDetailSafely(SSqlCmd *pCmd, int32_t subClauseIndex, SQuer
 SMeterMetaInfo* tscGetMeterMetaInfoByUid(SQueryInfo* pQueryInfo, uint64_t uid, int32_t* index);
 void            tscClearMeterMetaInfo(SMeterMetaInfo* pMeterMetaInfo, bool removeFromCache);
 
-SMeterMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, SMeterMeta* pMeterMeta, SMetricMeta* pMetricMeta,
+SMeterMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pMeterMeta, SSuperTableMeta* pMetricMeta,
                                     int16_t numOfTags, int16_t* tags);
 SMeterMetaInfo* tscAddEmptyMeterMetaInfo(SQueryInfo *pQueryInfo);
 int32_t tscAddSubqueryInfo(SSqlCmd *pCmd);

src/client/inc/tsclient.h

@@ -32,8 +32,7 @@ extern "C" {
 #include "tutil.h"
 #include "trpc.h"
 
-#define TSC_GET_RESPTR_BASE(res, _queryinfo, col, ord)                     \
-  (res->data + tscFieldInfoGetOffset(_queryinfo, col) * res->numOfRows)
+#define TSC_GET_RESPTR_BASE(res, _queryinfo, col) (res->data + ((_queryinfo)->fieldsInfo.pSqlExpr[col]->offset) * res->numOfRows)
 
 // forward declaration
 struct SSqlInfo;
@@ -47,8 +46,8 @@ typedef struct SSqlGroupbyExpr {
 } SSqlGroupbyExpr;
 
 typedef struct SMeterMetaInfo {
-  SMeterMeta * pMeterMeta;   // metermeta
-  SMetricMeta *pMetricMeta;  // metricmeta
+  STableMeta * pMeterMeta;   // metermeta
+  SSuperTableMeta *pMetricMeta;  // metricmeta
 
   /*
    * 1. keep the vnode index during the multi-vnode super table projection query
@@ -71,13 +70,19 @@ typedef struct SSqlExpr {
   int16_t     interResBytes;  // inter result buffer size
   int16_t     numOfParams;    // argument value of each function
   tVariant    param[3];       // parameters are not more than 3
+  int32_t     offset;         // sub result column value of arithmetic expression.
 } SSqlExpr;
 
+typedef struct SColumnIndex {
+  int16_t tableIndex;
+  int16_t columnIndex;
+} SColumnIndex;
+
 typedef struct SFieldInfo {
   int16_t     numOfOutputCols;  // number of column in result
   int16_t     numOfAlloc;       // allocated size
   TAOS_FIELD *pFields;
-  short *     pOffset;
+//  short *     pOffset;
 
   /*
    * define if this column is belong to the queried result, it may be add by parser to faciliate
@@ -87,19 +92,16 @@ typedef struct SFieldInfo {
    */
   bool *  pVisibleCols;
   int32_t numOfHiddenCols;   // the number of column not belongs to the queried result columns
+  SSqlFunctionExpr** pExpr;  // used for aggregation arithmetic express,such as count(*)+count(*)
+  SSqlExpr** pSqlExpr;
 } SFieldInfo;
 
 typedef struct SSqlExprInfo {
   int16_t    numOfAlloc;
   int16_t    numOfExprs;
-  SSqlExpr *pExprs;
+  SSqlExpr** pExprs;
 } SSqlExprInfo;
 
-typedef struct SColumnIndex {
-  int16_t tableIndex;
-  int16_t columnIndex;
-} SColumnIndex;
-
 typedef struct SColumnBase {
   SColumnIndex       colIndex;
   int32_t            numOfFilters;
@@ -120,7 +122,7 @@ typedef struct SCond {
 } SCond;
 
 typedef struct SJoinNode {
-  char     meterId[TSDB_TABLE_ID_LEN];
+  char     tableId[TSDB_TABLE_ID_LEN];
   uint64_t uid;
   int16_t  tagCol;
 } SJoinNode;
@@ -155,12 +157,12 @@ typedef struct SParamInfo {
 } SParamInfo;
 
 typedef struct STableDataBlocks {
-  char    meterId[TSDB_TABLE_ID_LEN];
+  char    tableId[TSDB_TABLE_ID_LEN];
   int8_t  tsSource;     // where does the UNIX timestamp come from, server or client
   bool    ordered;      // if current rows are ordered or not
   int64_t vgid;         // virtual group id
   int64_t prevTS;       // previous timestamp, recorded to decide if the records array is ts ascending
-  int32_t numOfMeters;  // number of tables in current submit block
+  int32_t numOfTables;  // number of tables in current submit block
 
   int32_t  rowSize;  // row size for current table
   uint32_t nAllocSize;
@@ -171,7 +173,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
    */
-  SMeterMeta *pMeterMeta;
+  STableMeta *pMeterMeta;
 
   union {
     char *filename;
@@ -199,8 +201,8 @@ typedef struct SQueryInfo {
   char     intervalTimeUnit;
 
   int64_t         etime, stime;
-  int64_t         nAggTimeInterval;  // aggregation time interval
-  int64_t         nSlidingTime;      // sliding window in mseconds
+  int64_t         intervalTime;  // aggregation time interval
+  int64_t         slidingTime;   // sliding window in mseconds
   SSqlGroupbyExpr groupbyExpr;   // group by tags info
 
   SColumnBaseInfo  colList;
@@ -270,11 +272,10 @@ typedef struct SResRec {
 struct STSBuf;
 
 typedef struct {
-  uint8_t               code;
+  int32_t       code;
   int64_t       numOfRows;                  // num of results in current retrieved
   int64_t       numOfTotal;                 // num of total results
   int64_t       numOfTotalInCurrentClause;  // num of total result in current subclause
-  
   char *        pRsp;
   int           rspType;
   int           rspLen;
@@ -283,16 +284,15 @@ typedef struct {
   int64_t       useconds;
   int64_t       offset;  // offset value from vnode during projection query of stable
   int           row;
-  int16_t               numOfnchar;
+  int16_t       numOfCols;
   int16_t       precision;
   int32_t       numOfGroups;
   SResRec *     pGroupRec;
   char *        data;
-  short *               bytes;
   void **       tsrow;
   char **       buffer;  // Buffer used to put multibytes encoded using unicode (wchar_t)
+  SColumnIndex *pColumnIndex;
   struct SLocalReducer *pLocalReducer;
-  SColumnIndex *        pColumnIndex;
 } SSqlRes;
 
 typedef struct _tsc_obj {
@@ -324,14 +324,12 @@ typedef struct _sql_obj {
   short             vnode;
   int64_t           stime;
   uint32_t          queryId;
-  void *            thandle;
-  SRpcIpSet         ipSet;
   void *            pStream;
   void *            pSubscription;
   char *            sqlstr;
   char              retry;
   char              maxRetry;
-  uint8_t           index;
+  SRpcIpSet        *ipList;
   char              freed : 4;
   char              listed : 4;
   tsem_t            rspSem;
@@ -373,18 +371,20 @@ typedef struct _sstream {
   struct _sstream *prev, *next;
 } SSqlStream;
 
+int32_t tscInitRpc(const char *user, const char *secret);
+
 // tscSql API
 int tsParseSql(SSqlObj *pSql, bool multiVnodeInsertion);
 
 void tscInitMsgs();
 extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo);
 
-void *tscProcessMsgFromServer(char *msg, void *ahandle, void *thandle);
+void tscProcessMsgFromServer(char type, void *pCont, int contLen, void *ahandle, int32_t code);
 int  tscProcessSql(SSqlObj *pSql);
 
 void tscAsyncInsertMultiVnodesProxy(void *param, TAOS_RES *tres, int numOfRows);
 
-int  tscRenewMeterMeta(SSqlObj *pSql, char *meterId);
+int  tscRenewMeterMeta(SSqlObj *pSql, char *tableId);
 void tscQueueAsyncRes(SSqlObj *pSql);
 
 void tscQueueAsyncError(void(*fp), void *param);
@@ -400,19 +400,17 @@ int taos_retrieve(TAOS_RES *res);
 int32_t tscTansformSQLFunctionForSTableQuery(SQueryInfo *pQueryInfo);
 void    tscRestoreSQLFunctionForMetricQuery(SQueryInfo *pQueryInfo);
 
-void tscClearSqlMetaInfoForce(SSqlCmd *pCmd);
-
 int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
 void    tscDestroyResPointerInfo(SSqlRes *pRes);
 
 void tscFreeSqlCmdData(SSqlCmd *pCmd);
-void tscFreeResData(SSqlObj* pSql);
+void tscFreeResData(SSqlObj *pSql);
 
 /**
  * free query result of the sql object
  * @param pObj
  */
-void tscFreeSqlResult(SSqlObj* pSql);
+void tscFreeSqlResult(SSqlObj *pSql);
 
 /**
  * only free part of resources allocated during query.

src/client/src/tscAst.c

@@ -139,7 +139,7 @@ static tSQLSyntaxNode *tSQLSyntaxNodeCreate(SSchema *pSchema, int32_t numOfCols,
     } else {
       pNode->colId = -1;
       pNode->pSchema->type = TSDB_DATA_TYPE_BINARY;
-      pNode->pSchema->bytes = TSDB_METER_NAME_LEN;
+      pNode->pSchema->bytes = TSDB_TABLE_NAME_LEN;
       strcpy(pNode->pSchema->name, TSQL_TBNAME_L);
       pNode->pSchema->colId = -1;
     }
@@ -158,7 +158,7 @@ static tSQLSyntaxNode *tSQLSyntaxNodeCreate(SSchema *pSchema, int32_t numOfCols,
   return pNode;
 }
 
-static uint8_t getBinaryExprOptr(SSQLToken *pToken) {
+uint8_t getBinaryExprOptr(SSQLToken *pToken) {
   switch (pToken->type) {
     case TK_LT:
       return TSDB_RELATION_LESS;
@@ -183,6 +183,7 @@ static uint8_t getBinaryExprOptr(SSQLToken *pToken) {
     case TK_STAR:
       return TSDB_BINARY_OP_MULTIPLY;
     case TK_SLASH:
+    case TK_DIVIDE:
       return TSDB_BINARY_OP_DIVIDE;
     case TK_REM:
       return TSDB_BINARY_OP_REMAINDER;

src/client/src/tscAsync.c

@@ -284,8 +284,15 @@ void tscAsyncFetchSingleRowProxy(void *param, TAOS_RES *tres, int numOfRows) {
     return;
   }
   
-  for (int i = 0; i < pCmd->numOfCols; ++i)
-    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i, pQueryInfo->order) + pRes->bytes[i] * pRes->row;
+  for (int i = 0; i < pCmd->numOfCols; ++i){
+    SSqlExpr* pExpr = pQueryInfo->fieldsInfo.pSqlExpr[i];
+    if (pExpr != NULL) {
+      pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i) + pExpr->resBytes * pRes->row;
+    } else {
+      //todo add
+    }
+  }
+  
   pRes->row++;
 
   (*pSql->fetchFp)(pSql->param, pSql, pSql->res.tsrow);
@@ -299,7 +306,12 @@ void tscProcessFetchRow(SSchedMsg *pMsg) {
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
 
   for (int i = 0; i < pCmd->numOfCols; ++i) {
-    pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i, pQueryInfo->order) + pRes->bytes[i] * pRes->row;
+    SSqlExpr* pExpr = pQueryInfo->fieldsInfo.pSqlExpr[i];
+    if (pExpr != NULL) {
+      pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i) + pExpr->resBytes * pRes->row;
+    } else {
+      //todo add
+    }
   }
   
   pRes->row++;
@@ -318,13 +330,6 @@ void tscProcessAsyncRes(SSchedMsg *pMsg) {
   int cmd = pCmd->command;
   int code = pRes->code ? -pRes->code : pRes->numOfRows;
 
-  if ((tscKeepConn[cmd] == 0 || (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_ACTION_IN_PROGRESS)) &&
-      pSql->pStream == NULL) {
-    if (pSql->thandle) taosAddConnIntoCache(tscConnCache, pSql->thandle, pSql->ip, pSql->vnode, pTscObj->user);
-
-    pSql->thandle = NULL;
-  }
-
   // in case of async insert, restore the user specified callback function
   bool shouldFree = tscShouldFreeAsyncSqlObj(pSql);
 
@@ -451,11 +456,11 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
     if (code != 0) {
       code = abs(code);
       pRes->code = code;
-      tscTrace("%p failed to renew meterMeta", pSql);
+      tscTrace("%p failed to renew tableMeta", pSql);
       tsem_post(&pSql->rspSem);
     } else {
-      tscTrace("%p renew meterMeta successfully, command:%d, code:%d, thandle:%p, retry:%d",
-          pSql, pSql->cmd.command, pSql->res.code, pSql->thandle, pSql->retry);
+      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);
@@ -553,7 +558,7 @@ void tscMeterMetaCallBack(void *param, TAOS_RES *res, int code) {
     tscTansformSQLFunctionForSTableQuery(pQueryInfo);
     tscIncStreamExecutionCount(pSql->pStream);
   } else {
-    tscTrace("%p get meterMeta/metricMeta successfully", pSql);
+    tscTrace("%p get tableMeta/metricMeta successfully", pSql);
   }
 
   tscDoQuery(pSql);

src/client/src/tscFunctionImpl.c

@@ -322,6 +322,10 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
   return TSDB_CODE_SUCCESS;
 }
 
+bool stableQueryFunctChanged(int32_t funcId) {
+  return (aAggs[funcId].stableFuncId != funcId);
+}
+
 /**
  * the numOfRes should be kept, since it may be used later
  * and allow the ResultInfo to be re initialized
@@ -719,12 +723,15 @@ static int32_t first_dist_data_req_info(SQLFunctionCtx *pCtx, TSKEY start, TSKEY
     return BLK_DATA_NO_NEEDED;
   }
 
-  SFirstLastInfo *pInfo = (SFirstLastInfo*) (pCtx->aOutputBuf + pCtx->inputBytes);
-  if (pInfo->hasResult != DATA_SET_FLAG) {
+  // result buffer has not been set yet.
   return BLK_DATA_ALL_NEEDED;
-  } else {  // data in current block is not earlier than current result
-    return (pInfo->ts <= start) ? BLK_DATA_NO_NEEDED : BLK_DATA_ALL_NEEDED;
-  }
+  //todo optimize the filter info
+//  SFirstLastInfo *pInfo = (SFirstLastInfo*) (pCtx->aOutputBuf + pCtx->inputBytes);
+//  if (pInfo->hasResult != DATA_SET_FLAG) {
+//    return BLK_DATA_ALL_NEEDED;
+//  } else {  // data in current block is not earlier than current result
+//    return (pInfo->ts <= start) ? BLK_DATA_NO_NEEDED : BLK_DATA_ALL_NEEDED;
+//  }
 }
 
 static int32_t last_dist_data_req_info(SQLFunctionCtx *pCtx, TSKEY start, TSKEY end, int32_t colId,
@@ -733,12 +740,13 @@ static int32_t last_dist_data_req_info(SQLFunctionCtx *pCtx, TSKEY start, TSKEY
     return BLK_DATA_NO_NEEDED;
   }
 
-  SFirstLastInfo *pInfo = (SFirstLastInfo*) (pCtx->aOutputBuf + pCtx->inputBytes);
-  if (pInfo->hasResult != DATA_SET_FLAG) {
   return BLK_DATA_ALL_NEEDED;
-  } else {
-    return (pInfo->ts > end) ? BLK_DATA_NO_NEEDED : BLK_DATA_ALL_NEEDED;
-  }
+//  SFirstLastInfo *pInfo = (SFirstLastInfo*) (pCtx->aOutputBuf + pCtx->inputBytes);
+//  if (pInfo->hasResult != DATA_SET_FLAG) {
+//    return BLK_DATA_ALL_NEEDED;
+//  } else {
+//    return (pInfo->ts > end) ? BLK_DATA_NO_NEEDED : BLK_DATA_ALL_NEEDED;
+//  }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
@@ -1438,6 +1446,8 @@ static void stddev_next_step(SQLFunctionCtx *pCtx) {
     pStd->stage++;
     avg_finalizer(pCtx);
   
+    pResInfo->initialized = true; // set it initialized to avoid re-initialization
+    
     // save average value into tmpBuf, for second stage scan
     SAvgInfo *pAvg = pResInfo->interResultBuf;
 
@@ -2184,7 +2194,7 @@ static STopBotInfo *getTopBotOutputInfo(SQLFunctionCtx *pCtx) {
   // only the first_stage_merge is directly written data into final output buffer
   if (pResInfo->superTableQ && pCtx->currentStage != SECONDARY_STAGE_MERGE) {
     return (STopBotInfo*) pCtx->aOutputBuf;
-  } else {  // for normal table query and super table at the secondary_stage, result is written to intermediate buffer
+  } else {  // during normal table query and super table at the secondary_stage, result is written to intermediate buffer
     return pResInfo->interResultBuf;
   }
 }
@@ -3312,7 +3322,7 @@ static void arithmetic_function(SQLFunctionCtx *pCtx) {
   tSQLBinaryExprCalcTraverse(sas->pExpr->pBinExprInfo.pBinExpr, pCtx->size, pCtx->aOutputBuf, sas, pCtx->order,
                              arithmetic_callback_function);
 
-  pCtx->aOutputBuf += pCtx->outputBytes * pCtx->size/* * GET_FORWARD_DIRECTION_FACTOR(pCtx->order)*/;
+  pCtx->aOutputBuf += pCtx->outputBytes * pCtx->size;
   pCtx->param[1].pz = NULL;
 }
 
@@ -3573,6 +3583,7 @@ void spread_function_finalizer(SQLFunctionCtx *pCtx) {
   }
   
   GET_RES_INFO(pCtx)->numOfRes = 1;  // todo add test case
+  doFinalizer(pCtx);
 }
 
 /*

src/client/src/tscJoinProcess.c

@@ -100,7 +100,7 @@ static int64_t doTSBlockIntersect(SSqlObj* pSql, SJoinSubquerySupporter* pSuppor
        * in case of stable query, limit/offset is not applied here. the limit/offset is applied to the
        * final results which is acquired after the secondry merge of in the client.
        */
-      if (pLimit->offset == 0 || pQueryInfo->nAggTimeInterval > 0 || QUERY_IS_STABLE_QUERY(pQueryInfo->type)) {
+      if (pLimit->offset == 0 || pQueryInfo->intervalTime > 0 || QUERY_IS_STABLE_QUERY(pQueryInfo->type)) {
         if (*st > elem1.ts) {
           *st = elem1.ts;
         }
@@ -165,7 +165,7 @@ SJoinSubquerySupporter* tscCreateJoinSupporter(SSqlObj* pSql, SSubqueryState* pS
   pSupporter->subqueryIndex = index;
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
   
-  pSupporter->interval = pQueryInfo->nAggTimeInterval;
+  pSupporter->interval = pQueryInfo->intervalTime;
   pSupporter->limit = pQueryInfo->limit;
 
   SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, pSql->cmd.clauseIndex, index);
@@ -275,6 +275,7 @@ int32_t tscLaunchSecondPhaseSubqueries(SSqlObj* pSql) {
     pSubQueryInfo->tsBuf = NULL;
   
     // free result for async object will also free sqlObj
+    assert(pSubQueryInfo->exprsInfo.numOfExprs == 1); // ts_comp query only requires one resutl columns
     taos_free_result(pPrevSub);
   
     SSqlObj *pNew = createSubqueryObj(pSql, (int16_t) i, tscJoinQueryCallback, pSupporter, NULL);
@@ -293,24 +294,26 @@ int32_t tscLaunchSecondPhaseSubqueries(SSqlObj* pSql) {
     // set the second stage sub query for join process
     pQueryInfo->type |= TSDB_QUERY_TYPE_JOIN_SEC_STAGE;
   
-    pQueryInfo->nAggTimeInterval = pSupporter->interval;
+    pQueryInfo->intervalTime = pSupporter->interval;
     pQueryInfo->groupbyExpr = pSupporter->groupbyExpr;
   
     tscColumnBaseInfoCopy(&pQueryInfo->colList, &pSupporter->colList, 0);
     tscTagCondCopy(&pQueryInfo->tagCond, &pSupporter->tagCond);
   
-    tscSqlExprCopy(&pQueryInfo->exprsInfo, &pSupporter->exprsInfo, pSupporter->uid);
+    tscSqlExprCopy(&pQueryInfo->exprsInfo, &pSupporter->exprsInfo, pSupporter->uid, false);
     tscFieldInfoCopyAll(&pQueryInfo->fieldsInfo, &pSupporter->fieldsInfo);
     
+    pSupporter->exprsInfo.numOfExprs = 0;
+    pSupporter->fieldsInfo.numOfOutputCols = 0;
+    
     /*
      * if the first column of the secondary query is not ts function, add this function.
      * Because this column is required to filter with timestamp after intersecting.
      */
-    if (pSupporter->exprsInfo.pExprs[0].functionId != TSDB_FUNC_TS) {
+    if (pSupporter->exprsInfo.pExprs[0]->functionId != TSDB_FUNC_TS) {
       tscAddTimestampColumn(pQueryInfo, TSDB_FUNC_TS, 0);
     }
   
-    // todo refactor function name
     SQueryInfo *pNewQueryInfo = tscGetQueryInfoDetail(&pNew->cmd, 0);
     assert(pNew->numOfSubs == 0 && pNew->cmd.numOfClause == 1 && pNewQueryInfo->numOfTables == 1);
   

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) {
-  SMeterMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0, 0)->pMeterMeta;
+  STableMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0, 0)->pMeterMeta;
 
   if (pMeta->tableType == TSDB_TABLE_TYPE_SUPER_TABLE || pMeta->tableType == TSDB_TABLE_TYPE_NORMAL_TABLE ||
       pMeta->tableType == TSDB_TABLE_TYPE_STREAM_TABLE) {
@@ -109,7 +109,7 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
   
   SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
-  SMeterMeta *    pMeta = pMeterMetaInfo->pMeterMeta;
+  STableMeta *    pMeta = pMeterMetaInfo->pMeterMeta;
 
   /*
    * tagValueCnt is to denote the number of tags columns for meter, not metric. and is to show the column data.
@@ -252,6 +252,13 @@ static int32_t tscBuildMeterSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   tscFieldInfoSetValue(&pQueryInfo->fieldsInfo, 3, TSDB_DATA_TYPE_BINARY, "Note", noteColLength);
   rowLen += noteColLength;
   
+  //set the sqlexpr part
+  SColumnIndex index = {0};
+  pQueryInfo->fieldsInfo.pSqlExpr[0] = tscSqlExprInsert(pQueryInfo, 0, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, TSDB_COL_NAME_LEN, TSDB_COL_NAME_LEN);
+  pQueryInfo->fieldsInfo.pSqlExpr[1] = tscSqlExprInsert(pQueryInfo, 1, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, typeColLength, typeColLength);
+  pQueryInfo->fieldsInfo.pSqlExpr[2] = tscSqlExprInsert(pQueryInfo, 2, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t), sizeof(int32_t));
+  pQueryInfo->fieldsInfo.pSqlExpr[3] = tscSqlExprInsert(pQueryInfo, 3, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, noteColLength, noteColLength);
+
   return rowLen;
 }
 
@@ -285,7 +292,7 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
   
   SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0);
 
-  SMetricMeta *pMetricMeta = pMeterMetaInfo->pMetricMeta;
+  SSuperTableMeta *pMetricMeta = pMeterMetaInfo->pMetricMeta;
   SSchema *    pSchema = tsGetTagSchema(pMeterMetaInfo->pMeterMeta);
 
   int32_t vOffset[TSDB_MAX_COLUMNS] = {0};
@@ -293,13 +300,13 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
   for (int32_t f = 1; f < pMeterMetaInfo->numOfTags; ++f) {
     int16_t tagColumnIndex = pMeterMetaInfo->tagColumnIndex[f - 1];
     if (tagColumnIndex == -1) {
-      vOffset[f] = vOffset[f - 1] + TSDB_METER_NAME_LEN;
+      vOffset[f] = vOffset[f - 1] + TSDB_TABLE_NAME_LEN;
     } else {
       vOffset[f] = vOffset[f - 1] + pSchema[tagColumnIndex].bytes;
     }
   }
 
-  int32_t totalNumOfResults = pMetricMeta->numOfMeters;
+  int32_t totalNumOfResults = pMetricMeta->numOfTables;
   int32_t rowLen = tscGetResRowLength(pQueryInfo);
 
   tscInitResObjForLocalQuery(pSql, totalNumOfResults, rowLen);
@@ -309,7 +316,7 @@ static int tscBuildMetricTagProjectionResult(SSqlObj *pSql) {
     SVnodeSidList *pSidList = (SVnodeSidList *)((char *)pMetricMeta + pMetricMeta->list[i]);
 
     for (int32_t j = 0; j < pSidList->numOfSids; ++j) {
-      SMeterSidExtInfo *pSidExt = tscGetMeterSidInfo(pSidList, j);
+      STableSidExtInfo *pSidExt = tscGetMeterSidInfo(pSidList, j);
       
       for (int32_t k = 0; k < pQueryInfo->fieldsInfo.numOfOutputCols; ++k) {
         SColIndexEx *pColIndex = &tscSqlExprGet(pQueryInfo, k)->colInfo;
@@ -336,7 +343,7 @@ static int tscBuildMetricTagSqlFunctionResult(SSqlObj *pSql) {
 
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
   
-  SMetricMeta *pMetricMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMetricMeta;
+  SSuperTableMeta *pMetricMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMetricMeta;
   int32_t      totalNumOfResults = 1;  // count function only produce one result
   int32_t      rowLen = tscGetResRowLength(pQueryInfo);
 
@@ -351,7 +358,7 @@ static int tscBuildMetricTagSqlFunctionResult(SSqlObj *pSql) {
         TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, k);
 
         memcpy(pRes->data + tscFieldInfoGetOffset(pQueryInfo, i) * totalNumOfResults + pField->bytes * rowIdx,
-               &pMetricMeta->numOfMeters, sizeof(pMetricMeta->numOfMeters));
+               &pMetricMeta->numOfTables, sizeof(pMetricMeta->numOfTables));
       } else {
         tscError("not support operations");
         continue;
@@ -368,7 +375,7 @@ static int tscProcessQueryTags(SSqlObj *pSql) {
   
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
   
-  SMeterMeta *pMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMeterMeta;
+  STableMeta *pMeterMeta = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, 0)->pMeterMeta;
   if (pMeterMeta == NULL || pMeterMeta->numOfTags == 0 || pMeterMeta->numOfColumns == 0) {
     strcpy(pCmd->payload, "invalid table");
     pSql->res.code = TSDB_CODE_INVALID_TABLE;
@@ -455,6 +462,8 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
   tscInitResObjForLocalQuery(pSql, 1, valueLength);
 
   TAOS_FIELD *pField = tscFieldInfoGetField(pQueryInfo, 0);
+  pQueryInfo->fieldsInfo.pSqlExpr[0] = pQueryInfo->exprsInfo.pExprs[0];
+  
   strncpy(pRes->data, val, pField->bytes);
 }
 

src/client/src/tscParseInsert.c

@@ -496,7 +496,7 @@ static int32_t rowDataCompar(const void *lhs, const void *rhs) {
   }
 }
 
-int tsParseValues(char **str, STableDataBlocks *pDataBlock, SMeterMeta *pMeterMeta, int maxRows,
+int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pMeterMeta, int maxRows,
                   SParsedDataColInfo *spd, char *error, int32_t *code, char *tmpTokenBuf) {
   int32_t   index = 0;
   SSQLToken sToken;
@@ -601,7 +601,7 @@ int32_t tscAllocateMemIfNeed(STableDataBlocks *pDataBlock, int32_t rowSize, int3
   return TSDB_CODE_SUCCESS;
 }
 
-static void tsSetBlockInfo(SShellSubmitBlock *pBlocks, const SMeterMeta *pMeterMeta, int32_t numOfRows) {
+static void tsSetBlockInfo(SShellSubmitBlock *pBlocks, const STableMeta *pMeterMeta, int32_t numOfRows) {
   pBlocks->sid = pMeterMeta->sid;
   pBlocks->uid = pMeterMeta->uid;
   pBlocks->sversion = pMeterMeta->sversion;
@@ -655,7 +655,7 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableHashList, char
                                       int32_t *totalNum) {
   SSqlCmd *       pCmd = &pSql->cmd;
   SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  SMeterMeta *    pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMeta *    pMeterMeta = pMeterMetaInfo->pMeterMeta;
 
   STableDataBlocks *dataBuf = NULL;
   int32_t ret = tscGetDataBlockFromList(pTableHashList, pCmd->pDataBlocks, pMeterMeta->uid, TSDB_DEFAULT_PAYLOAD_SIZE,
@@ -695,7 +695,7 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableHashList, char
   tsSetBlockInfo(pBlocks, pMeterMeta, numOfRows);
 
   dataBuf->vgid = pMeterMeta->vgid;
-  dataBuf->numOfMeters = 1;
+  dataBuf->numOfTables = 1;
 
   /*
    * the value of pRes->numOfRows does not affect the true result of AFFECTED ROWS,
@@ -1136,7 +1136,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       wordfree(&full_path);
 
       STableDataBlocks *pDataBlock = NULL;
-      SMeterMeta* pMeterMeta = pMeterMetaInfo->pMeterMeta;
+      STableMeta* pMeterMeta = pMeterMetaInfo->pMeterMeta;
       
       int32_t ret = tscCreateDataBlock(PATH_MAX, pMeterMeta->rowSize, sizeof(SShellSubmitBlock), pMeterMetaInfo->name,
                                        pMeterMeta, &pDataBlock);
@@ -1148,7 +1148,7 @@ 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); */
-      SMeterMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0)->pMeterMeta;
+      STableMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0)->pMeterMeta;
       SSchema *   pSchema = tsGetSchema(pMeterMeta);
 
       if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
@@ -1349,7 +1349,7 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
   SSqlCmd *pCmd = &pSql->cmd;
 
   assert(pCmd->numOfClause == 1);
-  SMeterMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0)->pMeterMeta;
+  STableMeta *pMeterMeta = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0)->pMeterMeta;
 
   SShellSubmitBlock *pBlocks = (SShellSubmitBlock *)(pTableDataBlocks->pData);
   tsSetBlockInfo(pBlocks, pMeterMeta, numOfRows);
@@ -1383,7 +1383,7 @@ static int tscInsertDataFromFile(SSqlObj *pSql, FILE *fp, char *tmpTokenBuf) {
   int             nrows = 0;
   
   SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, pCmd->clauseIndex, 0);
-  SMeterMeta *    pMeterMeta = pMeterMetaInfo->pMeterMeta;
+  STableMeta *    pMeterMeta = pMeterMetaInfo->pMeterMeta;
   assert(pCmd->numOfClause == 1);
   
   int32_t         rowSize = pMeterMeta->rowSize;
@@ -1544,7 +1544,7 @@ void tscProcessMultiVnodesInsertFromFile(SSqlObj *pSql) {
       continue;
     }
 
-    strncpy(pMeterMetaInfo->name, pDataBlock->meterId, TSDB_TABLE_ID_LEN);
+    strncpy(pMeterMetaInfo->name, pDataBlock->tableId, TSDB_TABLE_ID_LEN);
     memset(pDataBlock->pData, 0, pDataBlock->nAllocSize);
 
     int32_t ret = tscGetMeterMeta(pSql, pMeterMetaInfo);

src/client/src/tscPrepare.c

@@ -451,7 +451,6 @@ static int insertStmtExecute(STscStmt* stmt) {
   pRes->numOfTotalInCurrentClause = 0;
   
   pRes->qhandle = 0;
-  pSql->thandle = NULL;
 
   tscDoQuery(pSql);
 

src/client/src/tscProfile.c

@@ -145,7 +145,7 @@ void tscKillQuery(STscObj *pObj, uint32_t killId) {
 
   if (pSql == NULL) return;
 
-  tscTrace("%p query is killed, queryId:%d thandle:%p", pSql, killId, pSql->thandle);
+  tscTrace("%p query is killed, queryId:%d", pSql, killId);
   taos_stop_query(pSql);
 }
 
@@ -209,16 +209,16 @@ void tscKillStream(STscObj *pObj, uint32_t killId) {
 }
 
 char *tscBuildQueryStreamDesc(char *pMsg, STscObj *pObj) {
-  SQList *pQList = (SQList *)pMsg;
+  SQqueryList *pQList = (SQqueryList *)pMsg;
   char *  pMax = pMsg + TSDB_PAYLOAD_SIZE - 256;
 
-  SQDesc *pQdesc = pQList->qdesc;
+  SQueryDesc *pQdesc = pQList->qdesc;
   pQList->numOfQueries = 0;
 
   // We extract the lock to tscBuildHeartBeatMsg function.
   /* pthread_mutex_lock (&pObj->mutex); */
 
-  pMsg += sizeof(SQList);
+  pMsg += sizeof(SQqueryList);
   SSqlObj *pSql = pObj->sqlList;
   while (pSql) {
     /*
@@ -239,15 +239,15 @@ char *tscBuildQueryStreamDesc(char *pMsg, STscObj *pObj) {
     pQList->numOfQueries++;
     pQdesc++;
     pSql = pSql->next;
-    pMsg += sizeof(SQDesc);
+    pMsg += sizeof(SQueryDesc);
     if (pMsg > pMax) break;
   }
 
-  SSList *pSList = (SSList *)pMsg;
-  SSDesc *pSdesc = pSList->sdesc;
+  SStreamList *pSList = (SStreamList *)pMsg;
+  SStreamDesc *pSdesc = pSList->sdesc;
   pSList->numOfStreams = 0;
 
-  pMsg += sizeof(SSList);
+  pMsg += sizeof(SStreamList);
   SSqlStream *pStream = pObj->streamList;
   while (pStream) {
     strncpy(pSdesc->sql, pStream->pSql->sqlstr, TSDB_SHOW_SQL_LEN - 1);
@@ -265,7 +265,7 @@ char *tscBuildQueryStreamDesc(char *pMsg, STscObj *pObj) {
     pSList->numOfStreams++;
     pSdesc++;
     pStream = pStream->next;
-    pMsg += sizeof(SSDesc);
+    pMsg += sizeof(SStreamDesc);
     if (pMsg > pMax) break;
   }
 

src/client/src/tscSchemaUtil.c

@@ -64,14 +64,14 @@ bool isValidSchema(struct SSchema* pSchema, int32_t numOfCols) {
   return (rowLen <= TSDB_MAX_BYTES_PER_ROW);
 }
 
-struct SSchema* tsGetSchema(SMeterMeta* pMeta) {
+struct SSchema* tsGetSchema(STableMeta* pMeta) {
   if (pMeta == NULL) {
     return NULL;
   }
   return tsGetColumnSchema(pMeta, 0);
 }
 
-struct SSchema* tsGetTagSchema(SMeterMeta* pMeta) {
+struct SSchema* tsGetTagSchema(STableMeta* pMeta) {
   if (pMeta == NULL || pMeta->numOfTags == 0) {
     return NULL;
   }
@@ -79,12 +79,12 @@ struct SSchema* tsGetTagSchema(SMeterMeta* pMeta) {
   return tsGetColumnSchema(pMeta, pMeta->numOfColumns);
 }
 
-struct SSchema* tsGetColumnSchema(SMeterMeta* pMeta, int32_t startCol) {
-  return (SSchema*)(((char*)pMeta + sizeof(SMeterMeta)) + startCol * sizeof(SSchema));
+struct SSchema* tsGetColumnSchema(STableMeta* pMeta, int32_t startCol) {
+  return (SSchema*)(((char*)pMeta + sizeof(STableMeta)) + startCol * sizeof(SSchema));
 }
 
 struct SSchema tsGetTbnameColumnSchema() {
-  struct SSchema s = {.colId = TSDB_TBNAME_COLUMN_INDEX, .type = TSDB_DATA_TYPE_BINARY, .bytes = TSDB_METER_NAME_LEN};
+  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;
@@ -94,7 +94,7 @@ struct SSchema tsGetTbnameColumnSchema() {
  * the MeterMeta data format in memory is as follows:
  *
  * +--------------------+
- * |SMeterMeta Body data|  sizeof(SMeterMeta)
+ * |STableMeta Body data|  sizeof(STableMeta)
  * +--------------------+
  * |Schema data         |  numOfTotalColumns * sizeof(SSchema)
  * +--------------------+
@@ -104,14 +104,14 @@ struct SSchema tsGetTbnameColumnSchema() {
  * @param pMeta
  * @return
  */
-char* tsGetTagsValue(SMeterMeta* pMeta) {
+char* tsGetTagsValue(STableMeta* pMeta) {
   int32_t  numOfTotalCols = pMeta->numOfColumns + pMeta->numOfTags;
-  uint32_t offset = sizeof(SMeterMeta) + numOfTotalCols * sizeof(SSchema);
+  uint32_t offset = sizeof(STableMeta) + numOfTotalCols * sizeof(SSchema);
 
   return ((char*)pMeta + offset);
 }
 
-bool tsMeterMetaIdentical(SMeterMeta* p1, SMeterMeta* p2) {
+bool tsMeterMetaIdentical(STableMeta* p1, STableMeta* p2) {
   if (p1 == NULL || p2 == NULL || p1->uid != p2->uid || p1->sversion != p2->sversion) {
     return false;
   }
@@ -120,7 +120,7 @@ bool tsMeterMetaIdentical(SMeterMeta* p1, SMeterMeta* p2) {
     return true;
   }
 
-  size_t size = sizeof(SMeterMeta) + p1->numOfColumns * sizeof(SSchema);
+  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);
@@ -151,16 +151,16 @@ static FORCE_INLINE size_t copy(char* dst, const char* src, char delimiter) {
 
 /**
  * extract table name from meterid, which the format of userid.dbname.metername
- * @param meterId
+ * @param tableId
  * @return
  */
-void extractTableName(char* meterId, char* name) {
-  char* r = skipSegments(meterId, TS_PATH_DELIMITER[0], 2);
+void extractTableName(char* tableId, char* name) {
+  char* r = skipSegments(tableId, TS_PATH_DELIMITER[0], 2);
   copy(name, r, TS_PATH_DELIMITER[0]);
 }
 
-SSQLToken extractDBName(char* meterId, char* name) {
-  char* r = skipSegments(meterId, TS_PATH_DELIMITER[0], 1);
+SSQLToken extractDBName(char* tableId, char* name) {
+  char* r = skipSegments(tableId, TS_PATH_DELIMITER[0], 1);
   size_t len = copy(name, r, TS_PATH_DELIMITER[0]);
 
   SSQLToken token = {.z = name, .n = len, .type = TK_STRING};